speechrecorderng 2.21.9 → 2.22.0

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

@@ -0,0 +1,1144 @@
+import { Action } from '../../action/action';
+import { AudioCapture } from '../../audio/capture/capture';
+import { AudioPlayer, EventType } from '../../audio/playback/player';
+import { WavWriter } from '../../audio/impl/wavwriter';
+import { RecordingFile } from '../recording';
+import { Component, ViewChild, Inject, HostListener, Input } from "@angular/core";
+import { SessionService } from "./session.service";
+import { SPEECHRECORDER_CONFIG } from "../../spr.config";
+import { ProjectUtil } from "../project/project";
+import { LevelMeasure, StreamLevelMeasure } from "../../audio/dsp/level_measure";
+import { SequenceAudioFloat32ChunkerOutStream } from "../../audio/io/stream";
+import { TransportActions } from "./controlpanel";
+import { MessageDialog } from "../../ui/message_dialog";
+import { AudioContextProvider } from "../../audio/context";
+import { AudioClip } from "../../audio/persistor";
+import { Upload, UploaderStatus } from "../../net/uploader";
+import { UUID } from "../../utils/utils";
+import { MIN_DB_LEVEL } from "../../ui/recordingitem_display";
+import { LevelBar } from "../../audio/ui/livelevel";
+import { RecorderCombiPane } from "./recorder_combi_pane";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../project/project.service";
+import * as i4 from "./session.service";
+import * as i5 from "../recordings/recordings.service";
+import * as i6 from "../spruploader";
+import * as i7 from "./warning_bar";
+import * as i8 from "./recorder_combi_pane";
+import * as i9 from "../../audio/ui/livelevel";
+import * as i10 from "../../ui/recordingitem_display";
+import * as i11 from "./controlpanel";
+import * as i12 from "@angular/material/button";
+import * as i13 from "@angular/material/icon";
+import * as i14 from "@angular/flex-layout/flex";
+import * as i15 from "@angular/flex-layout/extended";
+import * as i16 from "@angular/common";
+import * as i17 from "../../spr.config";
+export const RECFILE_API_CTX = 'recfile';
+const MAX_RECORDING_TIME_MS = 1000 * 60 * 60 * 60; // 1 hour
+const LEVEL_BAR_INTERVALL_SECONDS = 0.1; // 100ms
+export class Item {
+    constructor(promptAsString, training) {
+        this.promptAsString = promptAsString;
+        this.training = training;
+        this.recs = null;
+    }
+}
+// TODO enum not possible in template language , use string for now
+//export enum StatusAlertType {INFO,WARN,ERROR};
+export class AudioRecorder {
+    constructor(changeDetectorRef, route, renderer, dialog, projectService, sessionService, recFileService, uploader, config) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.route = route;
+        this.renderer = renderer;
+        this.dialog = dialog;
+        this.projectService = projectService;
+        this.sessionService = sessionService;
+        this.recFileService = recFileService;
+        this.uploader = uploader;
+        this.config = config;
+        this._project = null;
+        this.projectName = null;
+        this.enableUploadRecordings = true;
+        this.enableDownloadRecordings = false;
+        this.status = 0 /* BLOCKED */;
+        this.ac = null;
+        this._channelCount = 2; //TODO define constant for default format
+        this.dataSaved = true;
+        this.startedDate = null;
+        this.maxRecTimerId = null;
+        this.maxRecTimerRunning = false;
+        this._session = null;
+        this._promptIndex = null;
+        //items: Array<Item>|null=null;
+        //selectedItemIdx: number;
+        this._displayRecFile = null;
+        this.displayRecFileVersion = 0;
+        this.displayAudioClip = null;
+        this.displayLevelInfos = null;
+        this.peakLevelInDb = MIN_DB_LEVEL;
+        this.readonly = false;
+        this.statusMsg = '';
+        this.statusWaiting = false;
+        this.processingRecording = false;
+        this.uploadProgress = 100;
+        this.uploadStatus = 'ok';
+        this.audioSignalCollapsed = true;
+        this.audioFetchSubscription = null;
+        this.destroyed = false;
+        this.navigationDisabled = true;
+        this.status = 1 /* IDLE */;
+        this.transportActions = new TransportActions();
+        this.playStartAction = new Action('Play');
+        this.audio = document.getElementById('audio');
+        this.selCaptureDeviceId = null;
+        this.levelMeasure = new LevelMeasure();
+        this.streamLevelMeasure = new StreamLevelMeasure();
+        if (this.config && this.config.enableUploadRecordings != null) {
+            this.enableUploadRecordings = this.config.enableUploadRecordings;
+        }
+        if (this.config && this.config.enableDownloadRecordings != null) {
+            this.enableDownloadRecordings = this.config.enableDownloadRecordings;
+        }
+        this.init();
+    }
+    ngAfterViewInit() {
+        this.route.queryParams.subscribe((params) => {
+            if (params['sessionId']) {
+                this.fetchSession(params['sessionId']);
+            }
+        });
+        this.streamLevelMeasure.levelListener = this.liveLevelDisplay;
+        this.streamLevelMeasure.peakLevelListener = (peakLvlInDb) => {
+            this.peakLevelInDb = peakLvlInDb;
+            this.changeDetectorRef.detectChanges();
+        };
+    }
+    ngOnDestroy() {
+        this.destroyed = true;
+        // TODO stop capture /playback
+    }
+    init() {
+        this.transportActions.startAction.disabled = true;
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.transportActions.pauseAction.disabled = true;
+        this.playStartAction.disabled = true;
+        let context = null;
+        try {
+            context = AudioContextProvider.audioContextInstance();
+        }
+        catch (err) {
+            this.status = 4 /* ERROR */;
+            let errMsg = 'Unknown';
+            if (err instanceof Error) {
+                errMsg = err.message;
+            }
+            this.statusMsg = 'ERROR: ' + errMsg;
+            this.statusAlertType = 'error';
+            this.dialog.open(MessageDialog, {
+                data: {
+                    type: 'error',
+                    title: 'Error',
+                    msg: errMsg,
+                    advise: 'Please use a supported browser.',
+                }
+            });
+            return;
+        }
+        if (context) {
+            console.info("State of audio context: " + context.state);
+        }
+        if (!context || !navigator.mediaDevices) {
+            this.status = 4 /* ERROR */;
+            let errMsg = 'Browser does not support Media streams!';
+            this.statusMsg = 'ERROR: ' + errMsg;
+            this.statusAlertType = 'error';
+            this.dialog.open(MessageDialog, {
+                data: {
+                    type: 'error',
+                    title: 'Error',
+                    msg: errMsg,
+                    advise: 'Please use a supported browser.',
+                }
+            });
+            return;
+        }
+        else {
+            this.controlAudioPlayer = new AudioPlayer(context, this);
+            this.ac = new AudioCapture(context);
+            if (this.ac) {
+                this.transportActions.startAction.onAction = () => this.startItem();
+                this.ac.listener = this;
+                this.ac.audioOutStream = new SequenceAudioFloat32ChunkerOutStream(this.streamLevelMeasure, LEVEL_BAR_INTERVALL_SECONDS);
+                // Don't list the devices here. If we do not have audio permissions we only get anonymized devices without labels.
+                //this.ac.listDevices();
+            }
+            else {
+                this.transportActions.startAction.disabled = true;
+                let errMsg = 'Browser does not support Media/Audio API!';
+                this.statusMsg = 'ERROR: ' + errMsg;
+                this.statusAlertType = 'error';
+                this.dialog.open(MessageDialog, {
+                    data: {
+                        type: 'error',
+                        title: 'Error',
+                        msg: errMsg,
+                        advise: 'Please use a supported browser.',
+                    }
+                });
+                return;
+            }
+            this.transportActions.stopAction.onAction = () => this.stopItem();
+            this.transportActions.nextAction.onAction = () => this.stopItem();
+            //this.transportActions.pauseAction.onAction = () => this.pauseItem();
+            this.playStartAction.onAction = () => this.controlAudioPlayer.start();
+        }
+        this.uploader.listener = (ue) => {
+            this.uploadUpdate(ue);
+        };
+    }
+    onKeyPress(ke) {
+        if (ke.key == ' ') {
+            this.transportActions.startAction.perform();
+            this.transportActions.nextAction.perform();
+        }
+    }
+    onKeyDown(ke) {
+        if (ke.key == ' ' || ke.key == 'Escape') {
+            this.transportActions.stopAction.perform();
+        }
+        if (ke.key == 'p' || ke.key == 'Escape') {
+            this.transportActions.pauseAction.perform();
+        }
+        if (ke.key == 'MediaPlayPause') {
+            this.playStartAction.perform();
+        }
+        if (ke.key === 'ArrowRight') {
+            this.transportActions.fwdAction.perform();
+        }
+        if (ke.key === 'ArrowLeft') {
+            this.transportActions.bwdAction.perform();
+        }
+    }
+    isTestSession() {
+        return ((this._session != null) && (this._session.type === 'TEST' || this._session.type === 'TEST_DEF_A' || this._session.type === 'SINUS_TEST'));
+    }
+    isDefaultAudioTestSession() {
+        return ((this._session != null) && (this._session.type === 'TEST_DEF_A'));
+    }
+    isDefaultAudioTestSessionOverwriteingProjectRequirements() {
+        return ((this._session != null) && (this._session.type === 'TEST_DEF_A') && (this.audioDevices != null) && this.audioDevices.length > 0);
+    }
+    fetchSession(sessionId) {
+        //Error: ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: 'statusMsg: Player initialized.'. Current value: 'statusMsg: Fetching session info...'.
+        // params.subscribe seems not to be asynchronous
+        // this.sm.statusAlertType='info';
+        // this.sm.statusMsg = 'Fetching session info...';
+        // this.sm.statusWaiting=true;
+        let sessObs = this.sessionService.sessionObserver(sessionId);
+        if (sessObs) {
+            sessObs.subscribe(sess => {
+                //this.setSession(sess);
+                this.statusAlertType = 'info';
+                this.statusMsg = 'Received session info.';
+                this.statusWaiting = false;
+                this.session = sess;
+                if (sess.project) {
+                    //console.debug("Session associated project: "+sess.project)
+                    this.projectService.projectObservable(sess.project).subscribe(project => {
+                        this.project = project;
+                        this.fetchRecordings(sess);
+                    }, reason => {
+                        this.statusMsg = reason;
+                        this.statusAlertType = 'error';
+                        this.statusWaiting = false;
+                        console.error("Error fetching project config: " + reason);
+                    });
+                }
+                else {
+                    console.info("Session has no associated project. Using default configuration.");
+                }
+            }, (reason) => {
+                this.statusMsg = reason;
+                this.statusAlertType = 'error';
+                this.statusWaiting = false;
+                console.error("Error fetching session " + reason);
+            });
+        }
+    }
+    fetchRecordings(sess) {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Fetching infos of recordings...';
+        this.statusWaiting = true;
+        let prNm = null;
+        if (this.project) {
+            let rfsObs = this.recFileService.recordingFileList(this.project.name, sess.sessionId);
+            rfsObs.subscribe((rfs) => {
+                this.statusAlertType = 'info';
+                this.statusMsg = 'Received infos of recordings.';
+                this.statusWaiting = false;
+                if (rfs) {
+                    if (rfs instanceof Array) {
+                        rfs.forEach((rf) => {
+                            //console.debug("Already recorded: " + rf+ " "+rf.recording.itemcode);
+                            //this.addRecordingFileByDescriptor(rf);
+                            this.recorderCombiPane.push(rf);
+                        });
+                    }
+                    else {
+                        console.error('Expected type array for list of already recorded files ');
+                    }
+                }
+                else {
+                    //console.debug("Recording file list: " + rfs);
+                }
+            }, () => {
+                // Failed fetching existing, but we start the session anyway
+                this.start();
+            }, () => {
+                // Normal start
+                this.start();
+            });
+        }
+        else {
+            // No project def -> error
+            this.statusAlertType = 'error';
+            this.statusMsg = 'No project definiton.';
+            this.statusWaiting = false;
+            console.error(this.statusMsg);
+        }
+    }
+    set project(project) {
+        this._project = project;
+        let chCnt = ProjectUtil.DEFAULT_AUDIO_CHANNEL_COUNT;
+        if (project) {
+            console.info("Project name: " + project.name);
+            this.audioDevices = project.audioDevices;
+            chCnt = ProjectUtil.audioChannelCount(project);
+            console.info("Project requested recording channel count: " + chCnt);
+            this.autoGainControlConfigs = project.autoGainControlConfigs;
+        }
+        else {
+            console.error("Empty project configuration!");
+        }
+        this.channelCount = chCnt;
+    }
+    get project() {
+        return this._project;
+    }
+    set autoGainControlConfigs(autoGainControlConfigs) {
+        this._autoGainControlConfigs = autoGainControlConfigs;
+    }
+    selectRecordingFile(rf) {
+        this.displayRecFile = rf;
+    }
+    uploadUpdate(ue) {
+        let upStatus = ue.status;
+        this.dataSaved = (UploaderStatus.DONE === upStatus);
+        let percentUpl = ue.percentDone();
+        if (UploaderStatus.ERR === upStatus) {
+            this.uploadStatus = 'warn';
+        }
+        else {
+            if (percentUpl < 50) {
+                this.uploadStatus = 'accent';
+            }
+            else {
+                this.uploadStatus = 'success';
+            }
+            this.uploadProgress = percentUpl;
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    set controlAudioPlayer(controlAudioPlayer) {
+        if (this._controlAudioPlayer) {
+            //this._controlAudioPlayer.listener=null;
+        }
+        this._controlAudioPlayer = controlAudioPlayer;
+        if (this._controlAudioPlayer) {
+            this._controlAudioPlayer.listener = this;
+        }
+    }
+    get controlAudioPlayer() {
+        return this._controlAudioPlayer;
+    }
+    set session(session) {
+        this._session = session;
+    }
+    get session() {
+        return this._session;
+    }
+    set channelCount(channelCount) {
+        this._channelCount = channelCount;
+    }
+    set audioDevices(audioDevices) {
+        this._audioDevices = audioDevices;
+    }
+    update(e) {
+        if (e.type == EventType.STARTED) {
+            this.playStartAction.disabled = true;
+            this.updateTimerId = window.setInterval(() => {
+                //this.audioSignal.playFramePosition = this.ap.playPositionFrames;
+            }, 50);
+        }
+        else if (e.type == EventType.STOPPED || e.type == EventType.ENDED) {
+            window.clearInterval(this.updateTimerId);
+            // this.audioSignal.playFramePosition = this.ap.playPositionFrames;
+            this.playStartAction.disabled = (!(this.displayRecFile));
+        }
+    }
+    startDisabled() {
+        return !this.transportActions || this.readonly || this.transportActions.startAction.disabled;
+    }
+    stopDisabled() {
+        return !this.transportActions || this.transportActions.stopAction.disabled;
+    }
+    startStopNextName() {
+        if (!this.startDisabled()) {
+            this.startStopNextButtonName = "Start";
+        }
+        else if (!this.stopDisabled()) {
+            this.startStopNextButtonName = "Stop";
+        }
+        return this.startStopNextButtonName;
+    }
+    startStopNextIconName() {
+        if (!this.startDisabled()) {
+            this.startStopNextButtonIconName = "fiber_manual_record";
+        }
+        else if (!this.stopDisabled()) {
+            this.startStopNextButtonIconName = "stop";
+        }
+        return this.startStopNextButtonIconName;
+    }
+    startStopNextIconColor() {
+        if (!this.startDisabled()) {
+            return "red";
+        }
+        else if (!this.stopDisabled()) {
+            return "yellow";
+        }
+        else {
+            return "grey";
+        }
+    }
+    startStopPerform() {
+        if (!this.startDisabled()) {
+            this.transportActions.startAction.perform();
+        }
+        else if (!this.stopDisabled()) {
+            this.transportActions.stopAction.perform();
+        }
+    }
+    startItem() {
+        this.transportActions.startAction.disabled = true;
+        this.transportActions.pauseAction.disabled = true;
+        if (this.readonly) {
+            return;
+        }
+        this.transportActions.fwdAction.disabled = true;
+        this.transportActions.fwdNextAction.disabled = true;
+        this.transportActions.bwdAction.disabled = true;
+        this.displayRecFile = null;
+        this.displayRecFileVersion = 0;
+        this.displayAudioClip = null;
+        this.showRecording();
+        if (this.ac) {
+            if (!this.ac.opened) {
+                if (this._selectedDeviceId) {
+                    console.log("Open session with audio device Id: \'" + this._selectedDeviceId + "\' for " + this._channelCount + " channels");
+                }
+                else {
+                    console.log("Open session with default audio device for " + this._channelCount + " channels");
+                }
+                this.ac.open(this._channelCount, this._selectedDeviceId, this._autoGainControlConfigs);
+            }
+            else {
+                this.ac.start();
+            }
+        }
+    }
+    downloadRecording() {
+        if (this.displayRecFile) {
+            let ab = this.displayRecFile.audioBuffer;
+            let ww = new WavWriter();
+            if (ab) {
+                let wavFile = ww.writeAsync(ab, (wavFile) => {
+                    let blob = new Blob([wavFile], { type: 'audio/wav' });
+                    let rfUrl = URL.createObjectURL(blob);
+                    let dataDnlLnk = this.renderer.createElement('a');
+                    //dataDnlLnk.name = 'Recording';
+                    dataDnlLnk.href = rfUrl;
+                    this.renderer.appendChild(document.body, dataDnlLnk);
+                    // download property not yet in TS def
+                    if (this.displayRecFile) {
+                        let fn = this.displayRecFile.filenameString();
+                        fn += '_' + this.displayRecFileVersion;
+                        fn += '.wav';
+                        dataDnlLnk.download = fn;
+                        dataDnlLnk.click();
+                    }
+                    this.renderer.removeChild(document.body, dataDnlLnk);
+                });
+            }
+        }
+    }
+    set displayRecFile(displayRecFile) {
+        this._displayRecFile = displayRecFile;
+        if (this._displayRecFile) {
+            let ab = this._displayRecFile.audioBuffer;
+            if (ab) {
+                this.displayAudioClip = new AudioClip(ab);
+                this.controlAudioPlayer.audioClip = this.displayAudioClip;
+            }
+            else {
+                // clear for now ...
+                this.displayAudioClip = null;
+                this.controlAudioPlayer.audioClip = null;
+                if (this._controlAudioPlayer && this._session) {
+                    //... and try to fetch from server
+                    this.audioFetchSubscription = this.recFileService.fetchAndApplyRecordingFile(this._controlAudioPlayer.context, this._session.project, this._displayRecFile).subscribe((rf) => {
+                        let fab = null;
+                        if (rf && this._displayRecFile) {
+                            fab = this._displayRecFile.audioBuffer;
+                        }
+                        else {
+                            this.statusMsg = 'Recording file could not be loaded.';
+                            this.statusAlertType = 'error';
+                        }
+                        if (fab) {
+                            this.displayAudioClip = new AudioClip(fab);
+                        }
+                        this.controlAudioPlayer.audioClip = this.displayAudioClip;
+                        this.showRecording();
+                    }, err => {
+                        console.error("Could not load recording file from server: " + err);
+                        this.statusMsg = 'Recording file could not be loaded: ' + err;
+                        this.statusAlertType = 'error';
+                    });
+                }
+                else {
+                    this.statusMsg = 'Recording file could not be decoded. Audio context unavailable.';
+                    this.statusAlertType = 'error';
+                }
+            }
+        }
+        else {
+            this.displayAudioClip = null;
+            this.controlAudioPlayer.audioClip = null;
+        }
+        this.showRecording();
+    }
+    get displayRecFile() {
+        return this._displayRecFile;
+    }
+    showRecording() {
+        this.controlAudioPlayer.stop();
+        if (this.displayAudioClip) {
+            this.levelMeasure.calcBufferLevelInfos(this.displayAudioClip.buffer, LEVEL_BAR_INTERVALL_SECONDS).then((levelInfos) => {
+                this.displayLevelInfos = levelInfos;
+                this.changeDetectorRef.detectChanges();
+            });
+            this.playStartAction.disabled = false;
+        }
+        else {
+            // TODO
+            // Setting to null does not trigger a change if it was  null before (happens after nextitem() in AUTOPROGRESS mode)
+            // The level bar display does not clear, it shows the last captured stream
+            this.displayLevelInfos = null;
+            this.playStartAction.disabled = true;
+            // Collapse audio signal display if open
+            if (!this.audioSignalCollapsed) {
+                this.audioSignalCollapsed = true;
+            }
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    updateStartActionDisableState() {
+        this.transportActions.startAction.disabled = !(this.ac);
+    }
+    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();
+            }
+        }
+        //console.log("Session ID: "+this._session.session+ " status: "+this._session.status)
+        this._selectedDeviceId = undefined;
+        if (!this.readonly && this.ac) {
+            this.statusMsg = 'Requesting audio permissions...';
+            this.statusAlertType = 'info';
+            this.ac.deviceInfos((mdis) => {
+                let audioCaptureDeviceAvail = false;
+                let audioPlayDeviceAvail = false;
+                if (mdis && 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."
+                                    }
+                                });
+                            }
+                            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
+                                if (!navigator.userAgent.match(".*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();
+                    }
+                }
+            });
+        }
+        if (this.recorderCombiPane.recordingListComp.recordingList.length > 0) {
+            this.selectRecordingFile(this.recorderCombiPane.recordingListComp.recordingList[0]);
+        }
+        this.enableNavigation();
+    }
+    isRecording() {
+        return (this.status === 2 /* RECORDING */);
+    }
+    isActive() {
+        return (!(this.status === 0 /* BLOCKED */ || this.status === 1 /* IDLE */ || this.status === 4 /* ERROR */) || this.processingRecording || this.sessionService.uploadCount > 0);
+    }
+    updateNavigationActions() {
+        this.transportActions.fwdAction.disabled = this.navigationDisabled;
+        this.transportActions.bwdAction.disabled = this.navigationDisabled;
+    }
+    enableStartUserGesture() {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Ready.';
+        //this.updateStartActionDisableState()
+        this.transportActions.startAction.disabled = !(this.ac);
+    }
+    enableNavigation() {
+        this.navigationDisabled = false;
+        this.updateNavigationActions();
+    }
+    opened() {
+        if (this.ac) {
+            this.ac.start();
+        }
+    }
+    started() {
+        this.startedDate = new Date();
+        this.transportActions.startAction.disabled = true;
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Recording...';
+        let maxRecordingTimeMs = MAX_RECORDING_TIME_MS;
+        this.maxRecTimerId = window.setTimeout(() => {
+            this.stopRecordingMaxRec();
+        }, maxRecordingTimeMs);
+        this.maxRecTimerRunning = true;
+        this.status = 2 /* RECORDING */;
+        this.transportActions.stopAction.disabled = false;
+    }
+    stopItem() {
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.status = 3 /* STOPPING_STOP */;
+        this.stopRecording();
+    }
+    stopRecording() {
+        if (this.maxRecTimerRunning && this.maxRecTimerId != null) {
+            window.clearTimeout(this.maxRecTimerId);
+            this.maxRecTimerRunning = false;
+        }
+        if (this.ac) {
+            this.ac.stop();
+        }
+    }
+    stopRecordingMaxRec() {
+        this.maxRecTimerRunning = false;
+        this.status = 3 /* STOPPING_STOP */;
+        if (this.ac) {
+            this.ac.stop();
+        }
+    }
+    // addRecordingFileByDescriptor(rfd:RecordingFileDescriptorImpl){
+    //    let prIdx=0;
+    //    if(this.items) {
+    //      let it = this.items[prIdx];
+    //      if (it) {
+    //        if (!it.recs) {
+    //          it.recs = new Array<SprRecordingFile>();
+    //        }
+    //
+    //      } else {
+    //        //console.debug("WARN: No recording item with code: \"" +rfd.recording.itemcode+ "\" found.");
+    //      }
+    //    }
+    // }
+    //
+    // addRecordingFileByPromptIndex(promptIndex:number, rf:SprRecordingFile){
+    //
+    // }
+    stopped() {
+        this.updateStartActionDisableState();
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.transportActions.pauseAction.disabled = true;
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Recorded.';
+        //this.startStopSignalState = StartStopSignalState.IDLE;
+        let ad;
+        if (this.ac) {
+            ad = this.ac.audioBuffer();
+            //}
+            //if (this._session && this._promptIndex ) {
+            let sessId = 0;
+            if (this._session) {
+                sessId = this._session.sessionId;
+            }
+            // let cpIdx = this._promptIndex;
+            // let it = this.items[cpIdx];
+            // if (!it.recs) {
+            //   it.recs = new Array<RecordingFile>();
+            // }
+            let rf = new RecordingFile(UUID.generate(), sessId, ad);
+            rf.startedDate = this.startedDate;
+            // it.recs.push(rf);
+            //
+            // if (this.enableUploadRecordings) {
+            //   // TODO use SpeechRecorderconfig resp. RecfileService
+            //   //new REST API URL
+            //
+            let apiEndPoint = '';
+            if (this.config && this.config.apiEndPoint) {
+                apiEndPoint = this.config.apiEndPoint;
+            }
+            if (apiEndPoint !== '') {
+                apiEndPoint = apiEndPoint + '/';
+            }
+            let sessionsUrl = apiEndPoint + SessionService.SESSION_API_CTX;
+            let recUrl = sessionsUrl + '/' + rf.session + '/' + RECFILE_API_CTX + '/' + rf.uuid;
+            //
+            //
+            //
+            //     // convert asynchronously to 16-bit integer PCM
+            //     // TODO could we avoid conversion to save CPU resources and transfer float PCM directly?
+            //     // TODO duplicate conversion for manual download
+            //     //console.log("Build wav writer...");
+            this.processingRecording = true;
+            let ww = new WavWriter();
+            ww.writeAsync(ad, (wavFile) => {
+                //this.postRecording(wavFile, recUrl);
+                //rf._dateAsDateObj=new Date();
+                rf.frames = ad.length;
+                this.displayRecFile = rf;
+                //this.recordingListComp.recordingList.push(rf);
+                this.recorderCombiPane.push(rf);
+                this.postRecordingMultipart(wavFile, rf.uuid, rf.session, rf.startedDate, recUrl);
+                this.processingRecording = false;
+                this.changeDetectorRef.detectChanges();
+            });
+            // }
+        }
+        // check complete session
+        let complete = true;
+        let autoStart = (this.status === 3 /* STOPPING_STOP */);
+        this.status = 1 /* IDLE */;
+        let startNext = false;
+        this.navigationDisabled = false;
+        this.updateNavigationActions();
+        this.changeDetectorRef.detectChanges();
+    }
+    postRecording(wavFile, recUrl) {
+        let wavBlob = new Blob([wavFile], { type: 'audio/wav' });
+        let ul = new Upload(wavBlob, recUrl);
+        this.uploader.queueUpload(ul);
+    }
+    postRecordingMultipart(wavFile, uuid, sessionId, startedDate, recUrl) {
+        let wavBlob = new Blob([wavFile], { type: 'audio/wav' });
+        let fd = new FormData();
+        if (uuid) {
+            fd.set('uuid', uuid);
+        }
+        if (sessionId !== null) {
+            fd.set('sessionId', sessionId.toString());
+        }
+        if (startedDate) {
+            fd.set('startedDate', startedDate.toJSON());
+        }
+        fd.set('audio', wavBlob);
+        let ul = new Upload(fd, recUrl);
+        this.uploader.queueUpload(ul);
+    }
+    stop() {
+        if (this.ac) {
+            this.ac.close();
+        }
+    }
+    updateControlPlaybackPosition() {
+        if (this._controlAudioPlayer.playPositionFrames) {
+            this.recorderCombiPane.audioDisplay.playFramePosition = this._controlAudioPlayer.playPositionFrames;
+            this.liveLevelDisplay.playFramePosition = this._controlAudioPlayer.playPositionFrames;
+        }
+    }
+    audioPlayerUpdate(e) {
+        if (EventType.READY === e.type) {
+        }
+        else if (EventType.STARTED === e.type) {
+            //this.status = 'Playback...';
+            this.updateTimerId = window.setInterval(() => this.updateControlPlaybackPosition(), 50);
+        }
+        else if (EventType.ENDED === e.type) {
+            //.status='Ready.';
+            window.clearInterval(this.updateTimerId);
+        }
+        if (!this.destroyed) {
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    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
+            }
+        });
+    }
+}
+AudioRecorder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AudioRecorder, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ActivatedRoute }, { token: i0.Renderer2 }, { token: i2.MatDialog }, { token: i3.ProjectService }, { token: i4.SessionService }, { token: i5.RecordingService }, { token: i6.SpeechRecorderUploader }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Component });
+AudioRecorder.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AudioRecorder, selector: "app-audiorecorder", inputs: { projectName: "projectName", dataSaved: "dataSaved" }, host: { listeners: { "window:keypress": "onKeyPress($event)", "window:keydown": "onKeyDown($event)" } }, providers: [SessionService], viewQueries: [{ propertyName: "recorderCombiPane", first: true, predicate: RecorderCombiPane, descendants: true, static: true }, { propertyName: "liveLevelDisplay", first: true, predicate: LevelBar, descendants: true, static: true }], ngImport: i0, template: `
+    <app-warningbar [show]="isTestSession()" warningText="Test recording only!"></app-warningbar>
+    <app-warningbar [show]="isDefaultAudioTestSession()"
+                    warningText="This test uses default audio device! Regular sessions may require a particular audio device (microphone)!"></app-warningbar>
+    <app-recordercombipane (selectedRecordingFileChanged)="selectRecordingFile($event)"
+                           [audioSignalCollapsed]="audioSignalCollapsed"
+                           [selectedRecordingFile]="displayRecFile"
+                           [selectDisabled]="isActive()"
+                           [displayAudioClip]="displayAudioClip"
+                           [playStartAction]="controlAudioPlayer.startAction"
+                           [playStopAction]="controlAudioPlayer.stopAction"
+                           [playSelectionAction]="controlAudioPlayer.startSelectionAction"
+                           [autoPlayOnSelectToggleAction]="controlAudioPlayer.autoPlayOnSelectToggleAction"
+    ></app-recordercombipane>
+
+    <div fxLayout="row" fxLayout.xs="column" [ngStyle]="{'height.px':100,'min-height.px': 100}"
+         [ngStyle.xs]="{'height.px':125,'min-height.px': 125}">
+      <audio-levelbar fxFlex="1 0 1" [streamingMode]="isRecording()"
+                      [displayLevelInfos]="displayLevelInfos"></audio-levelbar>
+      <div fxLayout="row">
+        <spr-recordingitemcontrols fxFlex="10 0 1"
+                                   [audioLoaded]="displayAudioClip?.buffer!==null"
+                                   [playStartAction]="controlAudioPlayer?.startAction"
+                                   [playStopAction]="controlAudioPlayer?.stopAction"
+                                   [peakDbLvl]="peakLevelInDb"
+                                   [agc]="this.ac?.agcStatus"
+                                   (onShowRecordingDetails)="audioSignalCollapsed=!audioSignalCollapsed">
+        </spr-recordingitemcontrols>
+        <app-uploadstatus class="ricontrols dark" fxHide fxShow.xs fxFlex="0 0 0" *ngIf="enableUploadRecordings"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-readystateindicator class="ricontrols dark" fxHide fxShow.xs fxFlex="0 0 0"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+    <div #controlpanel class="controlpanel" fxLayout="row">
+      <app-sprstatusdisplay fxHide.xs fxFlex="30% 1 30%" [statusMsg]="statusMsg" [statusAlertType]="statusAlertType"
+                            [statusWaiting]="statusWaiting"
+                            class="hidden-xs"></app-sprstatusdisplay>
+      <div fxFlex="100% 0 100%" class="startstop">
+        <div style="align-content: center">
+        <button (click)="startStopPerform()" [disabled]="startDisabled() && stopDisabled()" mat-raised-button class="bigbutton">
+          <mat-icon [style.color]="startStopNextIconColor()" inline="true">{{startStopNextIconName()}}</mat-icon>
+          <span style="font-weight: bolder;font-size: 14px">{{startStopNextName()}}</span>
+        </button>
+        </div>
+      </div>
+      <div fxFlex="30% 1 30%" >
+        <div fxFlex="1 1 auto"></div>
+        <app-uploadstatus class="ricontrols" fxHide.xs fxFlex="0 0 0" *ngIf="enableUploadRecordings"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-readystateindicator class="ricontrols" fxHide.xs
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{flex:2;background:lightgrey;display:flex;flex-direction:column;margin:0;padding:0;min-height:0px;overflow:hidden}\n", ".ricontrols{padding:4px;box-sizing:border-box;height:100%}\n", ".dark{background:darkgray}\n", ".controlpanel{align-content:center;align-items:center;margin:0;padding:20px;min-height:-webkit-min-content;min-height:min-content}\n", ".startstop{width:100%;text-align:center;align-content:center;align-items:center}\n", ".bigbutton{min-width:70px;min-height:50px;font-size:50px;border-radius:20px}\n"], components: [{ type: i7.WarningBar, selector: "app-warningbar", inputs: ["warningText", "show"] }, { type: i8.RecorderCombiPane, selector: "app-recordercombipane", inputs: ["selectDisabled", "selectedRecordingFile", "audioSignalCollapsed", "displayAudioClip", "playStartAction", "playSelectionAction", "autoPlayOnSelectToggleAction", "playStopAction"], outputs: ["selectedRecordingFileChanged"] }, { type: i9.LevelBar, selector: "audio-levelbar", inputs: ["streamingMode", "displayLevelInfos"] }, { type: i10.RecordingItemControls, selector: "spr-recordingitemcontrols", inputs: ["audioSignalCollapsed", "enableDownload", "peakDbLvl", "agc", "audioLoaded", "playStartAction", "playStopAction", "displayLevelInfos"], outputs: ["onShowRecordingDetails", "onDownloadRecording"] }, { type: i11.UploadStatus, selector: "app-uploadstatus", inputs: ["value", "awaitNewUpload", "status"] }, { type: i11.ReadyStateIndicator, selector: "app-readystateindicator", inputs: ["ready"] }, { type: i11.StatusDisplay, selector: "app-sprstatusdisplay", inputs: ["statusAlertType", "statusMsg", "statusWaiting"] }, { type: i12.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i13.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i14.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { type: i15.DefaultStyleDirective, selector: "  [ngStyle],  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]", inputs: ["ngStyle", "ngStyle.xs", "ngStyle.sm", "ngStyle.md", "ngStyle.lg", "ngStyle.xl", "ngStyle.lt-sm", "ngStyle.lt-md", "ngStyle.lt-lg", "ngStyle.lt-xl", "ngStyle.gt-xs", "ngStyle.gt-sm", "ngStyle.gt-md", "ngStyle.gt-lg"] }, { type: i16.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i14.DefaultFlexDirective, selector: "  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],  [fxFlex.gt-md], [fxFlex.gt-lg]", inputs: ["fxFlex", "fxFlex.xs", "fxFlex.sm", "fxFlex.md", "fxFlex.lg", "fxFlex.xl", "fxFlex.lt-sm", "fxFlex.lt-md", "fxFlex.lt-lg", "fxFlex.lt-xl", "fxFlex.gt-xs", "fxFlex.gt-sm", "fxFlex.gt-md", "fxFlex.gt-lg"] }, { type: i16.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i15.DefaultShowHideDirective, selector: "  [fxShow], [fxShow.print],  [fxShow.xs], [fxShow.sm], [fxShow.md], [fxShow.lg], [fxShow.xl],  [fxShow.lt-sm], [fxShow.lt-md], [fxShow.lt-lg], [fxShow.lt-xl],  [fxShow.gt-xs], [fxShow.gt-sm], [fxShow.gt-md], [fxShow.gt-lg],  [fxHide], [fxHide.print],  [fxHide.xs], [fxHide.sm], [fxHide.md], [fxHide.lg], [fxHide.xl],  [fxHide.lt-sm], [fxHide.lt-md], [fxHide.lt-lg], [fxHide.lt-xl],  [fxHide.gt-xs], [fxHide.gt-sm], [fxHide.gt-md], [fxHide.gt-lg]", inputs: ["fxShow", "fxShow.print", "fxShow.xs", "fxShow.sm", "fxShow.md", "fxShow.lg", "fxShow.xl", "fxShow.lt-sm", "fxShow.lt-md", "fxShow.lt-lg", "fxShow.lt-xl", "fxShow.gt-xs", "fxShow.gt-sm", "fxShow.gt-md", "fxShow.gt-lg", "fxHide", "fxHide.print", "fxHide.xs", "fxHide.sm", "fxHide.md", "fxHide.lg", "fxHide.xl", "fxHide.lt-sm", "fxHide.lt-md", "fxHide.lt-lg", "fxHide.lt-xl", "fxHide.gt-xs", "fxHide.gt-sm", "fxHide.gt-md", "fxHide.gt-lg"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AudioRecorder, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-audiorecorder',
+                    providers: [SessionService],
+                    template: `
+    <app-warningbar [show]="isTestSession()" warningText="Test recording only!"></app-warningbar>
+    <app-warningbar [show]="isDefaultAudioTestSession()"
+                    warningText="This test uses default audio device! Regular sessions may require a particular audio device (microphone)!"></app-warningbar>
+    <app-recordercombipane (selectedRecordingFileChanged)="selectRecordingFile($event)"
+                           [audioSignalCollapsed]="audioSignalCollapsed"
+                           [selectedRecordingFile]="displayRecFile"
+                           [selectDisabled]="isActive()"
+                           [displayAudioClip]="displayAudioClip"
+                           [playStartAction]="controlAudioPlayer.startAction"
+                           [playStopAction]="controlAudioPlayer.stopAction"
+                           [playSelectionAction]="controlAudioPlayer.startSelectionAction"
+                           [autoPlayOnSelectToggleAction]="controlAudioPlayer.autoPlayOnSelectToggleAction"
+    ></app-recordercombipane>
+
+    <div fxLayout="row" fxLayout.xs="column" [ngStyle]="{'height.px':100,'min-height.px': 100}"
+         [ngStyle.xs]="{'height.px':125,'min-height.px': 125}">
+      <audio-levelbar fxFlex="1 0 1" [streamingMode]="isRecording()"
+                      [displayLevelInfos]="displayLevelInfos"></audio-levelbar>
+      <div fxLayout="row">
+        <spr-recordingitemcontrols fxFlex="10 0 1"
+                                   [audioLoaded]="displayAudioClip?.buffer!==null"
+                                   [playStartAction]="controlAudioPlayer?.startAction"
+                                   [playStopAction]="controlAudioPlayer?.stopAction"
+                                   [peakDbLvl]="peakLevelInDb"
+                                   [agc]="this.ac?.agcStatus"
+                                   (onShowRecordingDetails)="audioSignalCollapsed=!audioSignalCollapsed">
+        </spr-recordingitemcontrols>
+        <app-uploadstatus class="ricontrols dark" fxHide fxShow.xs fxFlex="0 0 0" *ngIf="enableUploadRecordings"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-readystateindicator class="ricontrols dark" fxHide fxShow.xs fxFlex="0 0 0"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+    <div #controlpanel class="controlpanel" fxLayout="row">
+      <app-sprstatusdisplay fxHide.xs fxFlex="30% 1 30%" [statusMsg]="statusMsg" [statusAlertType]="statusAlertType"
+                            [statusWaiting]="statusWaiting"
+                            class="hidden-xs"></app-sprstatusdisplay>
+      <div fxFlex="100% 0 100%" class="startstop">
+        <div style="align-content: center">
+        <button (click)="startStopPerform()" [disabled]="startDisabled() && stopDisabled()" mat-raised-button class="bigbutton">
+          <mat-icon [style.color]="startStopNextIconColor()" inline="true">{{startStopNextIconName()}}</mat-icon>
+          <span style="font-weight: bolder;font-size: 14px">{{startStopNextName()}}</span>
+        </button>
+        </div>
+      </div>
+      <div fxFlex="30% 1 30%" >
+        <div fxFlex="1 1 auto"></div>
+        <app-uploadstatus class="ricontrols" fxHide.xs fxFlex="0 0 0" *ngIf="enableUploadRecordings"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-readystateindicator class="ricontrols" fxHide.xs
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+  `,
+                    styles: [`:host {
+    flex: 2;
+    background: lightgrey;
+    display: flex; /* Vertical flex container: Bottom transport panel, above prompting panel */
+    flex-direction: column;
+    margin: 0;
+    padding: 0;
+    min-height: 0px;
+
+      /* Prevents horizontal scroll bar on swipe right */
+      overflow: hidden;
+  }`, `.ricontrols {
+        padding: 4px;
+        box-sizing: border-box;
+        height: 100%;
+    }`, `.dark {
+    background: darkgray;
+  }`, `.controlpanel {
+    align-content: center;
+    align-items: center;
+    margin: 0;
+    padding: 20px;
+    min-height: min-content; /* important */
+  }`, `.startstop {
+    width: 100%;
+    text-align: center;
+    align-content: center;
+    align-items: center;
+  }`, `.bigbutton {
+    min-width: 70px;
+    min-height: 50px;
+    font-size: 50px;
+    border-radius: 20px;
+  }`
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.ActivatedRoute }, { type: i0.Renderer2 }, { type: i2.MatDialog }, { type: i3.ProjectService }, { type: i4.SessionService }, { type: i5.RecordingService }, { type: i6.SpeechRecorderUploader }, { type: i17.SpeechRecorderConfig, decorators: [{
+                    type: Inject,
+                    args: [SPEECHRECORDER_CONFIG]
+                }] }]; }, propDecorators: { projectName: [{
+                type: Input
+            }], recorderCombiPane: [{
+                type: ViewChild,
+                args: [RecorderCombiPane, { static: true }]
+            }], liveLevelDisplay: [{
+                type: ViewChild,
+                args: [LevelBar, { static: true }]
+            }], dataSaved: [{
+                type: Input
+            }], onKeyPress: [{
+                type: HostListener,
+                args: ['window:keypress', ['$event']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['window:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audiorecorder.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/speechrecorder/session/audiorecorder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Action} from '../../action/action'\r\nimport {AudioCapture, AudioCaptureListener} from '../../audio/capture/capture';\r\nimport {AudioPlayer, AudioPlayerEvent, EventType} from '../../audio/playback/player'\r\nimport {WavWriter} from '../../audio/impl/wavwriter'\r\n\r\nimport {RecordingFile, RecordingFileDescriptorImpl, SprRecordingFile} from '../recording'\r\n\r\nimport {\r\n  Component, ViewChild, ChangeDetectorRef, Inject,\r\n  AfterViewInit, HostListener, OnDestroy, Input, Renderer2\r\n} from \"@angular/core\";\r\nimport {SessionService} from \"./session.service\";\r\n\r\nimport { MatDialog } from \"@angular/material/dialog\";\r\nimport {SpeechRecorderUploader} from \"../spruploader\";\r\nimport {SPEECHRECORDER_CONFIG, SpeechRecorderConfig} from \"../../spr.config\";\r\nimport {Session} from \"./session\";\r\nimport {AudioDevice, AutoGainControlConfig, Project, ProjectUtil} from \"../project/project\";\r\n\r\nimport {LevelInfos, LevelMeasure, StreamLevelMeasure} from \"../../audio/dsp/level_measure\";\r\n\r\nimport {SequenceAudioFloat32ChunkerOutStream} from \"../../audio/io/stream\";\r\nimport {TransportActions} from \"./controlpanel\";\r\nimport {MessageDialog} from \"../../ui/message_dialog\";\r\nimport {RecordingService} from \"../recordings/recordings.service\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {AudioContextProvider} from \"../../audio/context\";\r\nimport {AudioClip} from \"../../audio/persistor\";\r\nimport {RecordingList} from \"./recording_list\";\r\nimport {Upload, UploaderStatus, UploaderStatusChangeEvent} from \"../../net/uploader\";\r\nimport {ActivatedRoute, Params} from \"@angular/router\";\r\nimport {ProjectService} from \"../project/project.service\";\r\nimport {UUID} from \"../../utils/utils\";\r\nimport {MIN_DB_LEVEL, RecordingItemDisplay} from \"../../ui/recordingitem_display\";\r\nimport {LevelBar} from \"../../audio/ui/livelevel\";\r\nimport {RecorderCombiPane} from \"./recorder_combi_pane\";\r\nimport {Script} from \"../script/script\";\r\n\r\n\r\nexport const RECFILE_API_CTX = 'recfile';\r\n\r\n\r\nconst MAX_RECORDING_TIME_MS = 1000 * 60 * 60 * 60; // 1 hour\r\n\r\n\r\nconst LEVEL_BAR_INTERVALL_SECONDS = 0.1;  // 100ms\r\nexport const enum Mode {SERVER_BOUND, STAND_ALONE}\r\n\r\nexport const enum Status {\r\n  BLOCKED, IDLE, RECORDING,  STOPPING_STOP, ERROR\r\n}\r\n\r\nexport class Item {\r\n  promptAsString: string;\r\n  training: boolean;\r\n  recs: Array<RecordingFile> | null;\r\n\r\n  constructor(promptAsString: string, training: boolean) {\r\n    this.promptAsString = promptAsString;\r\n    this.training = training;\r\n    this.recs = null;\r\n  }\r\n\r\n}\r\n\r\n// TODO enum not possible in template language , use string for now\r\n//export enum StatusAlertType {INFO,WARN,ERROR};\r\n\r\n@Component({\r\n\r\n  selector: 'app-audiorecorder',\r\n  providers: [SessionService],\r\n  template: `\r\n    <app-warningbar [show]=\"isTestSession()\" warningText=\"Test recording only!\"></app-warningbar>\r\n    <app-warningbar [show]=\"isDefaultAudioTestSession()\"\r\n                    warningText=\"This test uses default audio device! Regular sessions may require a particular audio device (microphone)!\"></app-warningbar>\r\n    <app-recordercombipane (selectedRecordingFileChanged)=\"selectRecordingFile($event)\"\r\n                           [audioSignalCollapsed]=\"audioSignalCollapsed\"\r\n                           [selectedRecordingFile]=\"displayRecFile\"\r\n                           [selectDisabled]=\"isActive()\"\r\n                           [displayAudioClip]=\"displayAudioClip\"\r\n                           [playStartAction]=\"controlAudioPlayer.startAction\"\r\n                           [playStopAction]=\"controlAudioPlayer.stopAction\"\r\n                           [playSelectionAction]=\"controlAudioPlayer.startSelectionAction\"\r\n                           [autoPlayOnSelectToggleAction]=\"controlAudioPlayer.autoPlayOnSelectToggleAction\"\r\n    ></app-recordercombipane>\r\n\r\n    <div fxLayout=\"row\" fxLayout.xs=\"column\" [ngStyle]=\"{'height.px':100,'min-height.px': 100}\"\r\n         [ngStyle.xs]=\"{'height.px':125,'min-height.px': 125}\">\r\n      <audio-levelbar fxFlex=\"1 0 1\" [streamingMode]=\"isRecording()\"\r\n                      [displayLevelInfos]=\"displayLevelInfos\"></audio-levelbar>\r\n      <div fxLayout=\"row\">\r\n        <spr-recordingitemcontrols fxFlex=\"10 0 1\"\r\n                                   [audioLoaded]=\"displayAudioClip?.buffer!==null\"\r\n                                   [playStartAction]=\"controlAudioPlayer?.startAction\"\r\n                                   [playStopAction]=\"controlAudioPlayer?.stopAction\"\r\n                                   [peakDbLvl]=\"peakLevelInDb\"\r\n                                   [agc]=\"this.ac?.agcStatus\"\r\n                                   (onShowRecordingDetails)=\"audioSignalCollapsed=!audioSignalCollapsed\">\r\n        </spr-recordingitemcontrols>\r\n        <app-uploadstatus class=\"ricontrols dark\" fxHide fxShow.xs fxFlex=\"0 0 0\" *ngIf=\"enableUploadRecordings\"\r\n                          [value]=\"uploadProgress\"\r\n                          [status]=\"uploadStatus\" [awaitNewUpload]=\"processingRecording\"></app-uploadstatus>\r\n        <app-readystateindicator class=\"ricontrols dark\" fxHide fxShow.xs fxFlex=\"0 0 0\"\r\n                                 [ready]=\"dataSaved && !isActive()\"></app-readystateindicator>\r\n      </div>\r\n    </div>\r\n    <div #controlpanel class=\"controlpanel\" fxLayout=\"row\">\r\n      <app-sprstatusdisplay fxHide.xs fxFlex=\"30% 1 30%\" [statusMsg]=\"statusMsg\" [statusAlertType]=\"statusAlertType\"\r\n                            [statusWaiting]=\"statusWaiting\"\r\n                            class=\"hidden-xs\"></app-sprstatusdisplay>\r\n      <div fxFlex=\"100% 0 100%\" class=\"startstop\">\r\n        <div style=\"align-content: center\">\r\n        <button (click)=\"startStopPerform()\" [disabled]=\"startDisabled() && stopDisabled()\" mat-raised-button class=\"bigbutton\">\r\n          <mat-icon [style.color]=\"startStopNextIconColor()\" inline=\"true\">{{startStopNextIconName()}}</mat-icon>\r\n          <span style=\"font-weight: bolder;font-size: 14px\">{{startStopNextName()}}</span>\r\n        </button>\r\n        </div>\r\n      </div>\r\n      <div fxFlex=\"30% 1 30%\" >\r\n        <div fxFlex=\"1 1 auto\"></div>\r\n        <app-uploadstatus class=\"ricontrols\" fxHide.xs fxFlex=\"0 0 0\" *ngIf=\"enableUploadRecordings\"\r\n                          [value]=\"uploadProgress\"\r\n                          [status]=\"uploadStatus\" [awaitNewUpload]=\"processingRecording\"></app-uploadstatus>\r\n        <app-readystateindicator class=\"ricontrols\" fxHide.xs\r\n                                 [ready]=\"dataSaved && !isActive()\"></app-readystateindicator>\r\n      </div>\r\n    </div>\r\n  `,\r\n  styles: [`:host {\r\n    flex: 2;\r\n    background: lightgrey;\r\n    display: flex; /* Vertical flex container: Bottom transport panel, above prompting panel */\r\n    flex-direction: column;\r\n    margin: 0;\r\n    padding: 0;\r\n    min-height: 0px;\r\n\r\n      /* Prevents horizontal scroll bar on swipe right */\r\n      overflow: hidden;\r\n  }`,`.ricontrols {\r\n        padding: 4px;\r\n        box-sizing: border-box;\r\n        height: 100%;\r\n    }`,`.dark {\r\n    background: darkgray;\r\n  }`,`.controlpanel {\r\n    align-content: center;\r\n    align-items: center;\r\n    margin: 0;\r\n    padding: 20px;\r\n    min-height: min-content; /* important */\r\n  }`,`.startstop {\r\n    width: 100%;\r\n    text-align: center;\r\n    align-content: center;\r\n    align-items: center;\r\n  }`,`.bigbutton {\r\n    min-width: 70px;\r\n    min-height: 50px;\r\n    font-size: 50px;\r\n    border-radius: 20px;\r\n  }`\r\n   ]\r\n})\r\nexport class AudioRecorder implements AfterViewInit,OnDestroy, AudioCaptureListener {\r\n\r\n  _project:Project|null=null;\r\n  @Input() projectName:string|null=null;\r\n  enableUploadRecordings: boolean = true;\r\n  enableDownloadRecordings: boolean = false;\r\n  status: Status = Status.BLOCKED;\r\n\r\n  ac: AudioCapture|null=null;\r\n  private _channelCount = 2; //TODO define constant for default format\r\n  private _selectedDeviceId:string|undefined;\r\n\r\n  @ViewChild(RecorderCombiPane, { static: true }) recorderCombiPane!: RecorderCombiPane;\r\n  @ViewChild(LevelBar, { static: true }) liveLevelDisplay!: LevelBar;\r\n\r\n  @Input() dataSaved=true\r\n\r\n  // Property audioDevices from project config: list of names of allowed audio devices.\r\n  private _audioDevices: Array<AudioDevice> | null | undefined;\r\n  private selCaptureDeviceId: ConstrainDOMString | null;\r\n  private _autoGainControlConfigs: Array<AutoGainControlConfig> | null| undefined;\r\n\r\n  private startedDate:Date|null=null;\r\n  private maxRecTimerId: number|null=null;\r\n  private maxRecTimerRunning: boolean=false;\r\n  private updateTimerId: any;\r\n\r\n  transportActions: TransportActions;\r\n  startStopNextButtonName!:string;\r\n  startStopNextButtonIconName!:string;\r\n  playStartAction: Action<void>;\r\n  audio: any;\r\n\r\n  _session: Session|null=null;\r\n\r\n  private _promptIndex:number|null=null;\r\n\r\n  //items: Array<Item>|null=null;\r\n  //selectedItemIdx: number;\r\n  private _displayRecFile: RecordingFile | null=null;\r\n  private displayRecFileVersion: number=0;\r\n  displayAudioClip: AudioClip | null=null;\r\n\r\n  displayLevelInfos: LevelInfos | null=null;\r\n\r\n  peakLevelInDb:number=MIN_DB_LEVEL;\r\n\r\n  readonly=false\r\n\r\n  statusMsg: string='';\r\n  statusAlertType!: string;\r\n  statusWaiting: boolean=false;\r\n\r\n  processingRecording=false\r\n\r\n  uploadProgress: number = 100;\r\n  uploadStatus: string = 'ok'\r\n  audioSignalCollapsed = true;\r\n\r\n  private streamLevelMeasure: StreamLevelMeasure;\r\n  private levelMeasure: LevelMeasure;\r\n  private _controlAudioPlayer!: AudioPlayer;\r\n\r\n  private audioFetchSubscription:Subscription|null=null;\r\n\r\n  private destroyed=false;\r\n\r\n  private navigationDisabled=true;\r\n\r\n  constructor(private changeDetectorRef: ChangeDetectorRef,\r\n              private route: ActivatedRoute,\r\n              private renderer: Renderer2,\r\n              public dialog: MatDialog,\r\n              private projectService:ProjectService,\r\n              private sessionService:SessionService,\r\n              private recFileService:RecordingService,\r\n              private uploader: SpeechRecorderUploader,\r\n              @Inject(SPEECHRECORDER_CONFIG) public config?: SpeechRecorderConfig) {\r\n    this.status = Status.IDLE;\r\n    this.transportActions = new TransportActions();\r\n    this.playStartAction = new Action('Play');\r\n    this.audio = document.getElementById('audio');\r\n    this.selCaptureDeviceId = null;\r\n    this.levelMeasure = new LevelMeasure();\r\n    this.streamLevelMeasure = new StreamLevelMeasure();\r\n    if (this.config && this.config.enableUploadRecordings != null) {\r\n      this.enableUploadRecordings = this.config.enableUploadRecordings;\r\n    }\r\n    if (this.config && this.config.enableDownloadRecordings != null) {\r\n      this.enableDownloadRecordings = this.config.enableDownloadRecordings;\r\n    }\r\n    this.init();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.route.queryParams.subscribe((params: Params) => {\r\n      if (params['sessionId']) {\r\n        this.fetchSession(params['sessionId']);\r\n      }\r\n    });\r\n    this.streamLevelMeasure.levelListener = this.liveLevelDisplay;\r\n    this.streamLevelMeasure.peakLevelListener=(peakLvlInDb)=>{\r\n      this.peakLevelInDb=peakLvlInDb;\r\n      this.changeDetectorRef.detectChanges();\r\n    }\r\n  }\r\n    ngOnDestroy() {\r\n       this.destroyed=true;\r\n       // TODO stop capture /playback\r\n    }\r\n\r\n  private init() {\r\n\r\n    this.transportActions.startAction.disabled = true;\r\n    this.transportActions.stopAction.disabled = true;\r\n    this.transportActions.nextAction.disabled = true;\r\n    this.transportActions.pauseAction.disabled = true;\r\n    this.playStartAction.disabled = true;\r\n\r\n    let context=null;\r\n    try {\r\n      context = AudioContextProvider.audioContextInstance()\r\n    } catch (err) {\r\n      this.status = Status.ERROR;\r\n      let errMsg = 'Unknown';\r\n      if(err instanceof Error){\r\n        errMsg=err.message;\r\n      }\r\n      this.statusMsg = 'ERROR: ' + errMsg;\r\n      this.statusAlertType = 'error';\r\n      this.dialog.open(MessageDialog, {\r\n        data: {\r\n          type: 'error',\r\n          title: 'Error',\r\n          msg: errMsg,\r\n          advise: 'Please use a supported browser.',\r\n        }\r\n      });\r\n      return;\r\n    }\r\n    if(context) {\r\n      console.info(\"State of audio context: \" + context.state)\r\n    }\r\n    if (!context || !navigator.mediaDevices) {\r\n      this.status = Status.ERROR;\r\n      let errMsg = 'Browser does not support Media streams!';\r\n      this.statusMsg = 'ERROR: ' + errMsg;\r\n      this.statusAlertType = 'error';\r\n      this.dialog.open(MessageDialog, {\r\n        data: {\r\n          type: 'error',\r\n          title: 'Error',\r\n          msg: errMsg,\r\n          advise: 'Please use a supported browser.',\r\n        }\r\n      });\r\n      return;\r\n    } else {\r\n      this.controlAudioPlayer = new AudioPlayer(context, this);\r\n      this.ac = new AudioCapture(context);\r\n      if (this.ac) {\r\n        this.transportActions.startAction.onAction = () => this.startItem();\r\n        this.ac.listener = this;\r\n        this.ac.audioOutStream = new SequenceAudioFloat32ChunkerOutStream(this.streamLevelMeasure, LEVEL_BAR_INTERVALL_SECONDS);\r\n        // Don't list the devices here. If we do not have audio permissions we only get anonymized devices without labels.\r\n        //this.ac.listDevices();\r\n      } else {\r\n        this.transportActions.startAction.disabled = true;\r\n        let errMsg = 'Browser does not support Media/Audio API!';\r\n        this.statusMsg = 'ERROR: ' + errMsg;\r\n        this.statusAlertType = 'error';\r\n        this.dialog.open(MessageDialog, {\r\n          data: {\r\n            type: 'error',\r\n            title: 'Error',\r\n            msg: errMsg,\r\n            advise: 'Please use a supported browser.',\r\n          }\r\n        });\r\n        return;\r\n      }\r\n      this.transportActions.stopAction.onAction = () => this.stopItem();\r\n      this.transportActions.nextAction.onAction = () => this.stopItem();\r\n      //this.transportActions.pauseAction.onAction = () => this.pauseItem();\r\n\r\n      this.playStartAction.onAction = () => this.controlAudioPlayer.start();\r\n\r\n    }\r\n    this.uploader.listener = (ue) => {\r\n      this.uploadUpdate(ue);\r\n    }\r\n}\r\n\r\n  @HostListener('window:keypress', ['$event'])\r\n  onKeyPress(ke: KeyboardEvent) {\r\n    if (ke.key == ' ') {\r\n      this.transportActions.startAction.perform();\r\n      this.transportActions.nextAction.perform();\r\n    }\r\n  }\r\n\r\n  @HostListener('window:keydown', ['$event'])\r\n  onKeyDown(ke: KeyboardEvent) {\r\n    if (ke.key == ' ' || ke.key == 'Escape') {\r\n      this.transportActions.stopAction.perform();\r\n    }\r\n    if (ke.key == 'p' || ke.key == 'Escape') {\r\n      this.transportActions.pauseAction.perform();\r\n    }\r\n    if (ke.key == 'MediaPlayPause') {\r\n      this.playStartAction.perform();\r\n    }\r\n    if (ke.key === 'ArrowRight') {\r\n      this.transportActions.fwdAction.perform();\r\n    }\r\n    if (ke.key === 'ArrowLeft') {\r\n      this.transportActions.bwdAction.perform();\r\n    }\r\n  }\r\n\r\n  isTestSession():boolean {\r\n    return ((this._session!=null) && (this._session.type === 'TEST' || this._session.type==='TEST_DEF_A' || this._session.type === 'SINUS_TEST'));\r\n  }\r\n\r\n  isDefaultAudioTestSession():boolean {\r\n    return ((this._session!=null) && (this._session.type==='TEST_DEF_A'));\r\n  }\r\n\r\n  isDefaultAudioTestSessionOverwriteingProjectRequirements():boolean {\r\n    return ((this._session!=null) && (this._session.type==='TEST_DEF_A') && (this.audioDevices!=null) && this.audioDevices.length>0)\r\n  }\r\n\r\n  fetchSession(sessionId:string){\r\n\r\n\r\n    //Error: ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: 'statusMsg: Player initialized.'. Current value: 'statusMsg: Fetching session info...'.\r\n    // params.subscribe seems not to be asynchronous\r\n\r\n    // this.sm.statusAlertType='info';\r\n    // this.sm.statusMsg = 'Fetching session info...';\r\n    // this.sm.statusWaiting=true;\r\n    let sessObs= this.sessionService.sessionObserver(sessionId);\r\n\r\n    if(sessObs) {\r\n      sessObs.subscribe(sess => {\r\n          //this.setSession(sess);\r\n          this.statusAlertType='info';\r\n          this.statusMsg = 'Received session info.';\r\n          this.statusWaiting=false;\r\n          this.session=sess;\r\n          if (sess.project) {\r\n            //console.debug(\"Session associated project: \"+sess.project)\r\n            this.projectService.projectObservable(sess.project).subscribe(project=>{\r\n              this.project=project;\r\n              this.fetchRecordings(sess);\r\n            },reason =>{\r\n              this.statusMsg=reason;\r\n              this.statusAlertType='error';\r\n              this.statusWaiting=false;\r\n              console.error(\"Error fetching project config: \"+reason)\r\n            });\r\n\r\n          } else {\r\n            console.info(\"Session has no associated project. Using default configuration.\")\r\n          }\r\n        },\r\n        (reason) => {\r\n          this.statusMsg = reason;\r\n          this.statusAlertType = 'error';\r\n          this.statusWaiting=false;\r\n          console.error(\"Error fetching session \" + reason)\r\n        });\r\n    }\r\n  }\r\n\r\n  fetchRecordings(sess:Session){\r\n    this.statusAlertType='info';\r\n    this.statusMsg = 'Fetching infos of recordings...';\r\n    this.statusWaiting=true;\r\n    let prNm:string|null=null;\r\n    if(this.project) {\r\n      let rfsObs = this.recFileService.recordingFileList(this.project.name, sess.sessionId);\r\n      rfsObs.subscribe((rfs: Array<RecordingFile>) => {\r\n        this.statusAlertType = 'info';\r\n        this.statusMsg = 'Received infos of recordings.';\r\n        this.statusWaiting = false;\r\n        if (rfs) {\r\n          if (rfs instanceof Array) {\r\n            rfs.forEach((rf) => {\r\n              //console.debug(\"Already recorded: \" + rf+ \" \"+rf.recording.itemcode);\r\n              //this.addRecordingFileByDescriptor(rf);\r\n              this.recorderCombiPane.push(rf);\r\n            })\r\n          } else {\r\n            console.error('Expected type array for list of already recorded files ')\r\n          }\r\n\r\n        } else {\r\n          //console.debug(\"Recording file list: \" + rfs);\r\n        }\r\n      }, () => {\r\n        // Failed fetching existing, but we start the session anyway\r\n        this.start()\r\n      }, () => {\r\n        // Normal start\r\n        this.start()\r\n      })\r\n    }else{\r\n      // No project def -> error\r\n      this.statusAlertType = 'error';\r\n      this.statusMsg = 'No project definiton.';\r\n      this.statusWaiting = false;\r\n      console.error(this.statusMsg);\r\n    }\r\n  }\r\n\r\n\r\n  set project(project: Project|null) {\r\n    this._project = project;\r\n    let chCnt = ProjectUtil.DEFAULT_AUDIO_CHANNEL_COUNT;\r\n\r\n    if (project) {\r\n      console.info(\"Project name: \" + project.name)\r\n      this.audioDevices = project.audioDevices;\r\n      chCnt = ProjectUtil.audioChannelCount(project);\r\n      console.info(\"Project requested recording channel count: \" + chCnt);\r\n      this.autoGainControlConfigs=project.autoGainControlConfigs;\r\n    } else {\r\n      console.error(\"Empty project configuration!\")\r\n    }\r\n    this.channelCount = chCnt;\r\n  }\r\n\r\n  get project():Project|null{\r\n    return this._project;\r\n  }\r\n\r\n  set autoGainControlConfigs(autoGainControlConfigs: Array<AutoGainControlConfig>|null|undefined){\r\n    this._autoGainControlConfigs=autoGainControlConfigs;\r\n  }\r\n\r\n  selectRecordingFile(rf:RecordingFile){\r\n    this.displayRecFile=rf;\r\n  }\r\n\r\n  uploadUpdate(ue: UploaderStatusChangeEvent) {\r\n    let upStatus = ue.status;\r\n    this.dataSaved = (UploaderStatus.DONE === upStatus);\r\n    let percentUpl = ue.percentDone();\r\n    if (UploaderStatus.ERR === upStatus) {\r\n      this.uploadStatus = 'warn'\r\n    } else {\r\n      if (percentUpl < 50) {\r\n        this.uploadStatus = 'accent'\r\n      } else {\r\n        this.uploadStatus = 'success'\r\n      }\r\n      this.uploadProgress = percentUpl;\r\n    }\r\n\r\n    this.changeDetectorRef.detectChanges()\r\n  }\r\n\r\n  set controlAudioPlayer(controlAudioPlayer: AudioPlayer) {\r\n    if (this._controlAudioPlayer) {\r\n      //this._controlAudioPlayer.listener=null;\r\n    }\r\n    this._controlAudioPlayer = controlAudioPlayer;\r\n    if (this._controlAudioPlayer) {\r\n      this._controlAudioPlayer.listener = this;\r\n    }\r\n  }\r\n\r\n  get controlAudioPlayer(): AudioPlayer {\r\n    return this._controlAudioPlayer;\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  set channelCount(channelCount: number) {\r\n    this._channelCount = channelCount;\r\n  }\r\n\r\n  set audioDevices(audioDevices: Array<AudioDevice> | null | undefined) {\r\n    this._audioDevices = audioDevices;\r\n  }\r\n\r\n  update(e: AudioPlayerEvent) {\r\n    if (e.type == EventType.STARTED) {\r\n      this.playStartAction.disabled = true;\r\n      this.updateTimerId = window.setInterval(() => {\r\n        //this.audioSignal.playFramePosition = this.ap.playPositionFrames;\r\n      }, 50);\r\n    } else if (e.type == EventType.STOPPED || e.type == EventType.ENDED) {\r\n      window.clearInterval(this.updateTimerId);\r\n      // this.audioSignal.playFramePosition = this.ap.playPositionFrames;\r\n      this.playStartAction.disabled = (!(this.displayRecFile));\r\n\r\n    }\r\n  }\r\n\r\n  startDisabled() {\r\n    return !this.transportActions || this.readonly || this.transportActions.startAction.disabled\r\n  }\r\n\r\n  stopDisabled() {\r\n    return !this.transportActions || this.transportActions.stopAction.disabled\r\n  }\r\n\r\n  startStopNextName():string{\r\n    if(!this.startDisabled()){\r\n      this.startStopNextButtonName=\"Start\"\r\n    }else if(!this.stopDisabled()) {\r\n      this.startStopNextButtonName = \"Stop\"\r\n    }\r\n    return this.startStopNextButtonName;\r\n  }\r\n  startStopNextIconName():string{\r\n    if(!this.startDisabled()){\r\n      this.startStopNextButtonIconName=\"fiber_manual_record\"\r\n    }else if(!this.stopDisabled()){\r\n      this.startStopNextButtonIconName=\"stop\"\r\n    }\r\n    return this.startStopNextButtonIconName\r\n  }\r\n  startStopNextIconColor():string{\r\n    if(!this.startDisabled()){\r\n      return \"red\"\r\n    }else if(!this.stopDisabled()){\r\n      return \"yellow\"\r\n    }else{\r\n      return \"grey\";\r\n    }\r\n  }\r\n\r\n  startStopPerform(){\r\n    if(!this.startDisabled()){\r\n      this.transportActions.startAction.perform();\r\n    }else if(!this.stopDisabled()){\r\n      this.transportActions.stopAction.perform();\r\n    }\r\n  }\r\n\r\n  startItem() {\r\n    this.transportActions.startAction.disabled = true;\r\n    this.transportActions.pauseAction.disabled = true;\r\n    if (this.readonly) {\r\n      return\r\n    }\r\n    this.transportActions.fwdAction.disabled = true\r\n    this.transportActions.fwdNextAction.disabled = true\r\n    this.transportActions.bwdAction.disabled = true\r\n    this.displayRecFile = null;\r\n    this.displayRecFileVersion = 0;\r\n    this.displayAudioClip = null;\r\n    this.showRecording();\r\n\r\n    if (this.ac) {\r\n      if (!this.ac.opened) {\r\n        if (this._selectedDeviceId) {\r\n          console.log(\"Open session with audio device Id: \\'\" + this._selectedDeviceId + \"\\' for \" + this._channelCount + \" channels\");\r\n        } else {\r\n          console.log(\"Open session with default audio device for \" + this._channelCount + \" channels\");\r\n        }\r\n        this.ac.open(this._channelCount, this._selectedDeviceId,this._autoGainControlConfigs);\r\n      } else {\r\n        this.ac.start();\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  downloadRecording() {\r\n    if (this.displayRecFile) {\r\n      let ab: AudioBuffer | null = this.displayRecFile.audioBuffer;\r\n      let ww = new WavWriter();\r\n      if (ab) {\r\n        let wavFile = ww.writeAsync(ab, (wavFile) => {\r\n          let blob = new Blob([wavFile], {type: 'audio/wav'});\r\n          let rfUrl = URL.createObjectURL(blob);\r\n\r\n          let dataDnlLnk = this.renderer.createElement('a');\r\n          //dataDnlLnk.name = 'Recording';\r\n          dataDnlLnk.href = rfUrl;\r\n\r\n          this.renderer.appendChild(document.body, dataDnlLnk);\r\n\r\n          // download property not yet in TS def\r\n          if (this.displayRecFile) {\r\n            let fn = this.displayRecFile.filenameString();\r\n            fn += '_' + this.displayRecFileVersion;\r\n            fn += '.wav';\r\n            dataDnlLnk.download = fn;\r\n            dataDnlLnk.click();\r\n          }\r\n          this.renderer.removeChild(document.body, dataDnlLnk);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  set displayRecFile(displayRecFile: RecordingFile | null) {\r\n    this._displayRecFile = displayRecFile;\r\n    if (this._displayRecFile) {\r\n      let ab: AudioBuffer| null = this._displayRecFile.audioBuffer;\r\n      if(ab) {\r\n        this.displayAudioClip = new AudioClip(ab);\r\n        this.controlAudioPlayer.audioClip = this.displayAudioClip;\r\n      }else {\r\n        // clear for now ...\r\n        this.displayAudioClip = null;\r\n        this.controlAudioPlayer.audioClip = null;\r\n\r\n        if (this._controlAudioPlayer && this._session) {\r\n            //... and try to fetch from server\r\n            this.audioFetchSubscription = this.recFileService.fetchAndApplyRecordingFile(this._controlAudioPlayer.context, this._session.project, this._displayRecFile).subscribe((rf) => {\r\n              let fab = null;\r\n              if (rf && this._displayRecFile) {\r\n                fab = this._displayRecFile.audioBuffer;\r\n              } else {\r\n                this.statusMsg = 'Recording file could not be loaded.'\r\n                this.statusAlertType = 'error'\r\n              }\r\n              if (fab){\r\n                this.displayAudioClip = new AudioClip(fab);\r\n              }\r\n              this.controlAudioPlayer.audioClip =this.displayAudioClip\r\n              this.showRecording();\r\n\r\n            }, err => {\r\n              console.error(\"Could not load recording file from server: \" + err)\r\n              this.statusMsg = 'Recording file could not be loaded: ' + err\r\n              this.statusAlertType = 'error'\r\n            })\r\n        }else{\r\n          this.statusMsg = 'Recording file could not be decoded. Audio context unavailable.'\r\n          this.statusAlertType = 'error'\r\n        }\r\n      }\r\n\r\n    } else {\r\n      this.displayAudioClip = null;\r\n      this.controlAudioPlayer.audioClip = null;\r\n    }\r\n    this.showRecording();\r\n  }\r\n\r\n  get displayRecFile(): RecordingFile | null {\r\n    return this._displayRecFile;\r\n  }\r\n\r\n  showRecording() {\r\n    this.controlAudioPlayer.stop();\r\n\r\n    if (this.displayAudioClip) {\r\n\r\n      this.levelMeasure.calcBufferLevelInfos(this.displayAudioClip.buffer, LEVEL_BAR_INTERVALL_SECONDS).then((levelInfos) => {\r\n        this.displayLevelInfos = levelInfos;\r\n        this.changeDetectorRef.detectChanges();\r\n      });\r\n      this.playStartAction.disabled = false;\r\n\r\n    } else {\r\n\r\n      // TODO\r\n      // Setting to null does not trigger a change if it was  null before (happens after nextitem() in AUTOPROGRESS mode)\r\n      // The level bar display does not clear, it shows the last captured stream\r\n      this.displayLevelInfos = null;\r\n\r\n      this.playStartAction.disabled = true;\r\n\r\n      // Collapse audio signal display if open\r\n      if (!this.audioSignalCollapsed) {\r\n        this.audioSignalCollapsed = true;\r\n      }\r\n    }\r\n    this.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  updateStartActionDisableState(){\r\n    this.transportActions.startAction.disabled=!(this.ac);\r\n  }\r\n\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    //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) {\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 && this.ac) {\r\n          this.ac.printDevices(mdis)\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              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                  if (!navigator.userAgent.match(\".*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    if(this.recorderCombiPane.recordingListComp.recordingList.length>0){\r\n      this.selectRecordingFile(this.recorderCombiPane.recordingListComp.recordingList[0]);\r\n    }\r\n    this.enableNavigation()\r\n  }\r\n\r\n  isRecording(): boolean {\r\n    return (this.status === Status.RECORDING);\r\n  }\r\n\r\n  isActive(): boolean{\r\n    return (!(this.status === Status.BLOCKED || this.status=== Status.IDLE || this.status===Status.ERROR) || this.processingRecording || this.sessionService.uploadCount>0)\r\n  }\r\n\r\n  private updateNavigationActions(){\r\n\r\n    this.transportActions.fwdAction.disabled = this.navigationDisabled;\r\n    this.transportActions.bwdAction.disabled = this.navigationDisabled;\r\n  }\r\n\r\n\r\n  enableStartUserGesture() {\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Ready.';\r\n    //this.updateStartActionDisableState()\r\n    this.transportActions.startAction.disabled=!(this.ac);\r\n\r\n  }\r\n\r\n  enableNavigation(){\r\n    this.navigationDisabled=false;\r\n    this.updateNavigationActions();\r\n  }\r\n\r\n  opened() {\r\n    if(this.ac) {\r\n      this.ac.start();\r\n    }\r\n  }\r\n\r\n  started() {\r\n    this.startedDate=new Date();\r\n    this.transportActions.startAction.disabled = true;\r\n\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Recording...';\r\n\r\n    let maxRecordingTimeMs = MAX_RECORDING_TIME_MS;\r\n    this.maxRecTimerId = window.setTimeout(() => {\r\n      this.stopRecordingMaxRec()\r\n    }, maxRecordingTimeMs);\r\n    this.maxRecTimerRunning = true;\r\n\r\n    this.status = Status.RECORDING;\r\n    this.transportActions.stopAction.disabled = false;\r\n  }\r\n\r\n  stopItem() {\r\n\r\n    this.transportActions.stopAction.disabled = true;\r\n    this.transportActions.nextAction.disabled = true;\r\n    this.status = Status.STOPPING_STOP;\r\n    this.stopRecording();\r\n\r\n  }\r\n\r\n  stopRecording() {\r\n    if (this.maxRecTimerRunning && this.maxRecTimerId!=null) {\r\n      window.clearTimeout(this.maxRecTimerId);\r\n      this.maxRecTimerRunning = false;\r\n    }\r\n    if(this.ac) {\r\n      this.ac.stop();\r\n    }\r\n  }\r\n\r\n  stopRecordingMaxRec(){\r\n\r\n    this.maxRecTimerRunning = false;\r\n    this.status = Status.STOPPING_STOP;\r\n    if(this.ac) {\r\n      this.ac.stop();\r\n    }\r\n  }\r\n\r\n  // addRecordingFileByDescriptor(rfd:RecordingFileDescriptorImpl){\r\n  //    let prIdx=0;\r\n  //    if(this.items) {\r\n  //      let it = this.items[prIdx];\r\n  //      if (it) {\r\n  //        if (!it.recs) {\r\n  //          it.recs = new Array<SprRecordingFile>();\r\n  //        }\r\n  //\r\n  //      } else {\r\n  //        //console.debug(\"WARN: No recording item with code: \\\"\" +rfd.recording.itemcode+ \"\\\" found.\");\r\n  //      }\r\n  //    }\r\n  // }\r\n  //\r\n  // addRecordingFileByPromptIndex(promptIndex:number, rf:SprRecordingFile){\r\n  //\r\n  // }\r\n\r\n\r\n  stopped() {\r\n    this.updateStartActionDisableState()\r\n    this.transportActions.stopAction.disabled = true;\r\n    this.transportActions.nextAction.disabled = true;\r\n    this.transportActions.pauseAction.disabled = true;\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Recorded.';\r\n    //this.startStopSignalState = StartStopSignalState.IDLE;\r\n    let ad:AudioBuffer;\r\n    if(this.ac) {\r\n      ad = this.ac.audioBuffer();\r\n    //}\r\n    //if (this._session && this._promptIndex ) {\r\n      let sessId: string | number = 0;\r\n      if(this._session){\r\n        sessId=this._session.sessionId;\r\n      }\r\n      // let cpIdx = this._promptIndex;\r\n      // let it = this.items[cpIdx];\r\n      // if (!it.recs) {\r\n      //   it.recs = new Array<RecordingFile>();\r\n      // }\r\n\r\n      let rf = new RecordingFile(UUID.generate(),sessId,ad);\r\n      rf.startedDate=this.startedDate;\r\n      // it.recs.push(rf);\r\n      //\r\n      // if (this.enableUploadRecordings) {\r\n      //   // TODO use SpeechRecorderconfig resp. RecfileService\r\n      //   //new REST API URL\r\n      //\r\n        let apiEndPoint = '';\r\n\r\n        if (this.config && this.config.apiEndPoint) {\r\n          apiEndPoint = this.config.apiEndPoint;\r\n        }\r\n        if (apiEndPoint !== '') {\r\n          apiEndPoint = apiEndPoint + '/'\r\n        }\r\n\r\n          let sessionsUrl = apiEndPoint + SessionService.SESSION_API_CTX;\r\n           let recUrl: string = sessionsUrl + '/' + rf.session + '/' + RECFILE_API_CTX + '/' + rf.uuid;\r\n      //\r\n      //\r\n      //\r\n      //     // convert asynchronously to 16-bit integer PCM\r\n      //     // TODO could we avoid conversion to save CPU resources and transfer float PCM directly?\r\n      //     // TODO duplicate conversion for manual download\r\n      //     //console.log(\"Build wav writer...\");\r\n          this.processingRecording=true\r\n          let ww = new WavWriter();\r\n          ww.writeAsync(ad, (wavFile) => {\r\n            //this.postRecording(wavFile, recUrl);\r\n            //rf._dateAsDateObj=new Date();\r\n            rf.frames=ad.length;\r\n            this.displayRecFile=rf;\r\n            //this.recordingListComp.recordingList.push(rf);\r\n            this.recorderCombiPane.push(rf);\r\n            this.postRecordingMultipart(wavFile, rf.uuid,rf.session,rf.startedDate,recUrl);\r\n            this.processingRecording=false;\r\n            this.changeDetectorRef.detectChanges();\r\n          });\r\n      // }\r\n    }\r\n\r\n    // check complete session\r\n    let complete = true;\r\n\r\n    let autoStart = (this.status === Status.STOPPING_STOP);\r\n    this.status = Status.IDLE;\r\n    let startNext=false;\r\n\r\n        this.navigationDisabled = false;\r\n        this.updateNavigationActions();\r\n\r\n    this.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  postRecording(wavFile: Uint8Array, recUrl: string) {\r\n    let wavBlob = new Blob([wavFile], {type: 'audio/wav'});\r\n    let ul = new Upload(wavBlob, recUrl);\r\n    this.uploader.queueUpload(ul);\r\n  }\r\n\r\n  postRecordingMultipart(wavFile: Uint8Array, uuid:string|null,sessionId:string|number|null,startedDate:Date|null|undefined,recUrl: string) {\r\n    let wavBlob = new Blob([wavFile], {type: 'audio/wav'});\r\n\r\n    let fd=new FormData();\r\n    if(uuid) {\r\n      fd.set('uuid', uuid);\r\n    }\r\n    if(sessionId!==null) {\r\n      fd.set('sessionId', sessionId.toString());\r\n    }\r\n    if(startedDate){\r\n      fd.set('startedDate',startedDate.toJSON());\r\n    }\r\n    fd.set('audio',wavBlob);\r\n    let ul = new Upload(fd, recUrl);\r\n    this.uploader.queueUpload(ul);\r\n  }\r\n\r\n  stop() {\r\n    if(this.ac) {\r\n      this.ac.close();\r\n    }\r\n  }\r\n\r\n  private updateControlPlaybackPosition() {\r\n    if (this._controlAudioPlayer.playPositionFrames) {\r\n      this.recorderCombiPane.audioDisplay.playFramePosition = this._controlAudioPlayer.playPositionFrames;\r\n      this.liveLevelDisplay.playFramePosition = this._controlAudioPlayer.playPositionFrames;\r\n    }\r\n  }\r\n\r\n  audioPlayerUpdate(e: AudioPlayerEvent) {\r\n    if (EventType.READY === e.type) {\r\n\r\n    } else if (EventType.STARTED === e.type) {\r\n      //this.status = 'Playback...';\r\n      this.updateTimerId = window.setInterval(() => this.updateControlPlaybackPosition(), 50);\r\n\r\n    } else if (EventType.ENDED === e.type) {\r\n      //.status='Ready.';\r\n      window.clearInterval(this.updateTimerId);\r\n\r\n    }\r\n\r\n    if(!this.destroyed) {\r\n        this.changeDetectorRef.detectChanges();\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\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"]}