speechrecorderng 3.6.0 → 3.8.0

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

@@ -0,0 +1,1179 @@
+import { AudioCapture } from '../../audio/capture/capture';
+import { AudioPlayer, EventType } from '../../audio/playback/player';
+import { WavWriter } from '../../audio/impl/wavwriter';
+import { RecordingFile, RecordingFileUtils } from '../recording';
+import { Component, HostListener, Inject, Input, ViewChild } from "@angular/core";
+import { SessionService } from "./session.service";
+import { SPEECHRECORDER_CONFIG } from "../../spr.config";
+import { AudioStorageType, ProjectUtil } from "../project/project";
+import { MessageDialog } from "../../ui/message_dialog";
+import { RecordingService } from "../recordings/recordings.service";
+import { AudioClip } from "../../audio/persistor";
+import { Upload, UploaderStatus, UploadHolder } from "../../net/uploader";
+import { LevelBar, State as LiveLevelState } from "../../audio/ui/livelevel";
+import { RecorderCombiPane } from "./recorder_combi_pane";
+import { BasicRecorder, MAX_RECORDING_TIME_MS, RECFILE_API_CTX } from "./basicrecorder";
+import { RecorderComponent } from "../../recorder_component";
+import { AudioBufferSource, AudioDataHolder } from "../../audio/audio_data_holder";
+import { NetAudioBuffer } from "../../audio/net_audio_buffer";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/layout";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "./session.service";
+import * as i4 from "../recordings/recordings.service";
+import * as i5 from "../spruploader";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/button";
+import * as i9 from "../../audio/ui/livelevel";
+import * as i10 from "./controlpanel";
+import * as i11 from "../../ui/recordingitem_display";
+import * as i12 from "./warning_bar";
+import * as i13 from "./recorder_combi_pane";
+import * as i14 from "../../spr.config";
+import * as i15 from "@angular/router";
+import * as i16 from "../project/project.service";
+export class AudioRecorder extends BasicRecorder {
+    constructor(bpo, changeDetectorRef, renderer, dialog, sessionService, recFileService, uploader, config) {
+        super(bpo, changeDetectorRef, dialog, sessionService, uploader, config);
+        this.bpo = bpo;
+        this.renderer = renderer;
+        this.recFileService = recFileService;
+        this.uploader = uploader;
+        this._project = null;
+        this.projectName = null;
+        this.enableUploadRecordings = true;
+        this.enableDownloadRecordings = false;
+        this.status = 0 /* Status.BLOCKED */;
+        this.dataSaved = true;
+        this._displayRecFile = null;
+        this.displayRecFileVersion = 0;
+        //super(injector);
+        this.status = 1 /* Status.IDLE */;
+        this.audio = document.getElementById('audio');
+        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.streamLevelMeasure.levelListener = this.liveLevelDisplay;
+        this.streamLevelMeasure.peakLevelListener = (peakLvlInDb) => {
+            this.peakLevelInDb = peakLvlInDb;
+            this.changeDetectorRef.detectChanges();
+        };
+        //let wakeLockSupp=('wakeLock' in navigator);
+        //alert('Wake lock API supported: '+wakeLockSupp);
+    }
+    ready() {
+        return this.dataSaved && !this.isActive();
+    }
+    ngOnDestroy() {
+        this.disableWakeLockCond();
+        this.destroyed = true;
+        // TODO stop capture /playback
+    }
+    ngOnInit() {
+        this.transportActions.startAction.disabled = true;
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.transportActions.pauseAction.disabled = true;
+        this.playStartAction.disabled = true;
+        this.ac = new AudioCapture();
+        if (this.ac) {
+            this.transportActions.startAction.onAction = () => this.startItem();
+            this.ac.listener = this;
+            this.configureStreamCaptureStream();
+            // 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,
+                    advice: '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 == ' ') {
+            if (!this.transportActions.startAction.disabled) {
+                this.transportActions.startAction.perform();
+            }
+            else if (!this.transportActions.stopAction.disabled) {
+                this.transportActions.stopAction.perform();
+            }
+        }
+        if (ke.key == 'p') {
+            this.transportActions.pauseAction.perform();
+        }
+        if (ke.key == 'Escape') {
+            if (!this.audioSignalCollapsed) {
+                this.audioSignalCollapsed = true;
+            }
+            this.transportActions.stopAction.perform();
+            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);
+    }
+    fetchRecordings(sess) {
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Fetching infos of recordings...';
+        this.statusWaiting = true;
+        //let prNm:string|null=null;
+        if (this.project) {
+            let rfsObs = this.recFileService.recordingFileList(this.project.name, sess.sessionId);
+            rfsObs.subscribe({ next: (rfs) => {
+                    this.statusAlertType = 'info';
+                    this.statusMsg = 'Received infos of recordings.';
+                    this.statusWaiting = false;
+                    if (rfs) {
+                        if (rfs instanceof Array) {
+                            rfs.forEach((rf) => {
+                                // the list comes from the server, asssuem all recording files as server persisted
+                                rf.serverPersisted = true;
+                                if (rf.startedDate) {
+                                    rf._startedAsDateObj = new Date(rf.startedDate);
+                                }
+                                if (rf.date) {
+                                    rf._dateAsDateObj = new Date(rf.date);
+                                }
+                                this.recorderCombiPane.addRecFile(rf);
+                            });
+                        }
+                        else {
+                            console.error('Expected type array for list of already recorded files ');
+                        }
+                    }
+                    else {
+                        //console.debug("Recording file list: " + rfs);
+                    }
+                }, error: (err) => {
+                    // Failed fetching existing, but we start the session anyway
+                    this.start();
+                }, complete: () => {
+                    // 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);
+            if (project.recordingDeviceWakeLock === true) {
+                this.wakeLock = true;
+            }
+            this.audioDevices = project.audioDevices;
+            chCnt = ProjectUtil.audioChannelCount(project);
+            console.info("Project requested recording channel count: " + chCnt);
+            this.autoGainControlConfigs = project.autoGainControlConfigs;
+            if (project.allowEchoCancellation !== undefined) {
+                this.allowEchoCancellation = project.allowEchoCancellation;
+            }
+            if (project.chunkedRecording === true) {
+                this.uploadChunkSizeSeconds = BasicRecorder.DEFAULT_CHUNK_SIZE_SECONDS;
+            }
+            else {
+                this.uploadChunkSizeSeconds = null;
+            }
+            if (project.clientAudioStorageType) {
+                this.clientAudioStorageType = project.clientAudioStorageType;
+            }
+        }
+        else {
+            console.error("Empty project configuration!");
+        }
+        this.channelCount = chCnt;
+    }
+    get project() {
+        return this._project;
+    }
+    selectRecordingFile(rf) {
+        this.liveLevelDisplayState = LiveLevelState.READY;
+        this.keepLiveLevel = false;
+        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) {
+        this._controlAudioPlayer = controlAudioPlayer;
+        if (this._controlAudioPlayer) {
+            this._controlAudioPlayer.listener = this;
+        }
+    }
+    get controlAudioPlayer() {
+        return this._controlAudioPlayer;
+    }
+    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);
+            //console.debug("Enable play start action (by player events stopped or ended): "+(!(this.displayRecFile)));
+            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.status = 2 /* Status.STARTING */;
+        super.startItem();
+        if (this.readonly) {
+            this.status = 1 /* Status.IDLE */;
+            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.liveLevelDisplay.reset(true);
+        this.liveLevelDisplayState = LiveLevelState.READY;
+        this.showRecording();
+        this.startCapture();
+    }
+    downloadRecording() {
+        if (this.displayRecFile) {
+            let ab = this.displayRecFile.audioDataHolder;
+            let ww = new WavWriter();
+            let as = ab?.audioSource;
+            if (as instanceof AudioBufferSource) {
+                ww.writeAsync(as.audioBuffer, (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.audioLoaded=false;
+        this._displayRecFile = displayRecFile;
+        if (this._displayRecFile) {
+            let adh = this._displayRecFile.audioDataHolder;
+            if (adh) {
+                this.displayAudioClip = new AudioClip(adh);
+                //this.audioLoaded=true;
+                //console.debug(" set recording file: display audio clip set");
+                if (this._controlAudioPlayer) {
+                    this._controlAudioPlayer.audioClip = this.displayAudioClip;
+                }
+                this.showRecording();
+            }
+            else {
+                // clear for now ...
+                this.displayAudioClip = null;
+                //console.debug("set recording file: display audio clip null");
+                if (this._controlAudioPlayer) {
+                    this._controlAudioPlayer.audioClip = null;
+                }
+                if (this._controlAudioPlayer && this._session) {
+                    //... and try to fetch from server
+                    this.liveLevelDisplayState = LiveLevelState.LOADING;
+                    const rf = this._displayRecFile;
+                    let audioDownloadType = this._clientAudioStorageType;
+                    if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this._clientAudioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this._clientAudioStorageType) {
+                        // Default is network mode
+                        audioDownloadType = AudioStorageType.NET_CHUNKED;
+                        if (rf.channels && rf.frames) {
+                            const samples = rf.channels * rf.frames;
+                            if (samples <= this._maxAutoNetMemStoreSamples) {
+                                // But if audio file is small, load in continuous resp. chunked mode
+                                if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this._clientAudioStorageType) {
+                                    audioDownloadType = AudioStorageType.MEM_ENTIRE;
+                                }
+                                else if (AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this._clientAudioStorageType) {
+                                    audioDownloadType = AudioStorageType.MEM_CHUNKED;
+                                }
+                            }
+                        }
+                    }
+                    if (AudioStorageType.DB_CHUNKED === this._clientAudioStorageType) {
+                        // Fetch chunked indexed db audio buffer
+                        let nextIab = null;
+                        if (!this._persistentAudioStorageTarget) {
+                            throw Error('Error: Persistent storage target not set.');
+                        }
+                        else {
+                            //console.debug("Fetch audio and store to indexed db...");
+                            this.audioFetchSubscription = this.recFileService.fetchRecordingFileIndDbAudioBuffer(this._persistentAudioStorageTarget, this._session.project, rf).subscribe({
+                                next: (iab) => {
+                                    //console.debug("Sessionmanager: Received inddb audio buffer: "+iab);
+                                    nextIab = iab;
+                                },
+                                complete: () => {
+                                    this.liveLevelDisplayState = LiveLevelState.READY;
+                                    let fabDh = null;
+                                    if (nextIab) {
+                                        if (rf) {
+                                            fabDh = new AudioDataHolder(nextIab);
+                                            //this.audioLoaded=true;
+                                            this.recorderCombiPane.setRecFileAudioData(rf, fabDh);
+                                        }
+                                    }
+                                    else {
+                                        // Should actually be handled by the error resolver
+                                        this.statusMsg = 'Recording file could not be loaded.';
+                                        this.statusAlertType = 'error';
+                                    }
+                                    if (fabDh) {
+                                        // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item
+                                        this.displayAudioClip = new AudioClip(fabDh);
+                                    }
+                                    if (this._controlAudioPlayer) {
+                                        this._controlAudioPlayer.audioClip = this.displayAudioClip;
+                                    }
+                                    this.showRecording();
+                                },
+                                error: err => {
+                                    console.error("Could not load recording file from server: " + err);
+                                    this.liveLevelDisplayState = LiveLevelState.READY;
+                                    this.statusMsg = 'Recording file could not be loaded: ' + err;
+                                    this.statusAlertType = 'error';
+                                    this.changeDetectorRef.detectChanges();
+                                }
+                            });
+                        }
+                    }
+                    else if (AudioStorageType.NET_CHUNKED === audioDownloadType) {
+                        // Fetch chunked audio buffer from network
+                        let nextNetAb = null;
+                        //console.debug("Fetch chunked audio from network");
+                        this.audioFetchSubscription = this.recFileService.fetchRecordingFileNetAudioBuffer(this._session.project, rf).subscribe({
+                            next: (netAb) => {
+                                //console.debug("Sessionmanager: Received net audio buffer: "+netAb);
+                                nextNetAb = netAb;
+                            },
+                            complete: () => {
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                let fabDh = null;
+                                if (nextNetAb) {
+                                    if (rf) {
+                                        fabDh = new AudioDataHolder(nextNetAb);
+                                        this.recorderCombiPane.setRecFileAudioData(rf, fabDh);
+                                    }
+                                }
+                                else {
+                                    // Should actually be handled by the error resolver
+                                    this.statusMsg = 'Recording file could not be loaded.';
+                                    this.statusAlertType = 'error';
+                                }
+                                if (fabDh) {
+                                    // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item
+                                    //console.debug("set displayRecFile(): fetch net ab complete, set displayAudioClip.")
+                                    this.displayAudioClip = new AudioClip(fabDh);
+                                    // fabDh.onReady=()=>{
+                                    //   this.audioLoaded=true;
+                                    // }
+                                }
+                                if (this._controlAudioPlayer) {
+                                    this._controlAudioPlayer.audioClip = this.displayAudioClip;
+                                }
+                                this.showRecording();
+                            },
+                            error: err => {
+                                console.error("Could not load recording file from server: " + err);
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                this.statusMsg = 'Recording file could not be loaded: ' + err;
+                                this.statusAlertType = 'error';
+                                this.changeDetectorRef.detectChanges();
+                            }
+                        });
+                    }
+                    else if (AudioStorageType.MEM_CHUNKED === audioDownloadType) {
+                        // Fetch chunked array audio buffer
+                        let nextAab = null;
+                        //console.debug("Fetch audio and store to (chunked) array buffer...");
+                        this.audioFetchSubscription = this.recFileService.fetchRecordingFileArrayAudioBuffer(this._session.project, rf).subscribe({
+                            next: (aab) => {
+                                nextAab = aab;
+                            },
+                            complete: () => {
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                let fabDh = null;
+                                if (nextAab) {
+                                    if (rf) {
+                                        fabDh = new AudioDataHolder(nextAab);
+                                        this.recorderCombiPane.setRecFileAudioData(rf, fabDh);
+                                    }
+                                }
+                                else {
+                                    // Should actually be handled by the error resolver
+                                    this.statusMsg = 'Recording file could not be loaded.';
+                                    this.statusAlertType = 'error';
+                                }
+                                if (fabDh) {
+                                    // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item
+                                    this.displayAudioClip = new AudioClip(fabDh);
+                                    //this.audioLoaded=true;
+                                }
+                                if (this._controlAudioPlayer) {
+                                    this._controlAudioPlayer.audioClip = this.displayAudioClip;
+                                }
+                                this.showRecording();
+                            },
+                            error: err => {
+                                console.error("Could not load recording file from server: " + err);
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                this.statusMsg = 'Recording file could not be loaded: ' + err;
+                                this.statusAlertType = 'error';
+                            }
+                        });
+                    }
+                    else {
+                        this.audioFetchSubscription = this.recFileService.fetchRecordingFileAudioBuffer(this._session.project, rf).subscribe({
+                            next: ab => {
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                let fabDh = null;
+                                if (ab) {
+                                    let abSrc = new AudioBufferSource(ab);
+                                    if (rf) {
+                                        fabDh = new AudioDataHolder(abSrc);
+                                        this.recorderCombiPane.setRecFileAudioData(rf, fabDh);
+                                    }
+                                }
+                                else {
+                                    console.error('Recording file could not be loaded.');
+                                    this.statusMsg = 'Recording file could not be loaded.';
+                                    this.statusAlertType = 'error';
+                                }
+                                if (fabDh) {
+                                    // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item
+                                    this.displayAudioClip = new AudioClip(fabDh);
+                                    //this.audioLoaded=true;
+                                    //console.debug("set recording file: display audio clip from fetched audio buffer");
+                                }
+                                if (this._controlAudioPlayer) {
+                                    this._controlAudioPlayer.audioClip = this.displayAudioClip;
+                                }
+                                this.showRecording();
+                            }, error: err => {
+                                console.error("Could not load recording file from server: " + err);
+                                this.liveLevelDisplayState = LiveLevelState.READY;
+                                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 {
+            //console.debug("recording file null");
+            this.displayAudioClip = null;
+            if (this._controlAudioPlayer) {
+                this._controlAudioPlayer.audioClip = null;
+            }
+        }
+        this.showRecording();
+    }
+    get displayRecFile() {
+        return this._displayRecFile;
+    }
+    updateStartActionDisableState() {
+        this.transportActions.startAction.disabled = !(this.ac);
+    }
+    start() {
+        super.start();
+        this.recorderCombiPane.selectTop();
+        this.enableNavigation();
+        this.updateStartActionDisableState();
+    }
+    isRecording() {
+        return (this.status === 3 /* Status.RECORDING */ || this.status === 4 /* Status.STOPPING_STOP */);
+    }
+    isActive() {
+        return (!(this.status === 0 /* Status.BLOCKED */ || this.status === 1 /* Status.IDLE */ || this.status === 5 /* Status.ERROR */) || this.processingRecording || this.sessionService.uploadCount > 0);
+    }
+    updateWakeLock(dataSaved = this.dataSaved) {
+        //console.debug("Update wake lock: dataSaved: "+dataSaved+", not active: "+! this.isActive())
+        if (dataSaved && !this.isActive()) {
+            this.disableWakeLockCond();
+        }
+    }
+    updateNavigationActions() {
+        this.transportActions.fwdAction.disabled = this.navigationDisabled;
+        this.transportActions.bwdAction.disabled = this.navigationDisabled;
+    }
+    enableStartUserGesture() {
+        super.enableStartUserGesture();
+        this.transportActions.startAction.disabled = !(this.ac);
+    }
+    enableNavigation() {
+        this.navigationDisabled = false;
+        this.updateNavigationActions();
+    }
+    started() {
+        this.status = 3 /* Status.RECORDING */;
+        super.started();
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Recording...';
+        let sessId = 0;
+        if (this._session) {
+            sessId = this._session.sessionId;
+        }
+        if (this.rfUuid) {
+            let rf = new RecordingFile(this.rfUuid, sessId, null);
+            rf._startedAsDateObj = this.startedDate;
+            if (rf._startedAsDateObj) {
+                rf.startedDate = rf._startedAsDateObj.toString();
+            }
+            this._recordingFile = rf;
+        }
+        let maxRecordingTimeMs = MAX_RECORDING_TIME_MS;
+        this.maxRecTimerId = window.setTimeout(() => {
+            this.stopRecordingMaxRec();
+        }, maxRecordingTimeMs);
+        this.maxRecTimerRunning = true;
+        this.transportActions.stopAction.disabled = false;
+    }
+    stopItem() {
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.status = 4 /* Status.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 = 4 /* Status.STOPPING_STOP */;
+        if (this.ac) {
+            this.ac.stop();
+        }
+    }
+    stopped() {
+        this.updateStartActionDisableState();
+        this.transportActions.stopAction.disabled = true;
+        this.transportActions.nextAction.disabled = true;
+        this.transportActions.pauseAction.disabled = true;
+        this.statusAlertType = 'info';
+        this.statusMsg = 'Recorded.';
+        let ab = null;
+        if (this.ac) {
+            let adh = null;
+            let as = null;
+            if (this.ac) {
+                if (AudioStorageType.NET_CHUNKED === this.ac.audioStorageType) {
+                    this.playStartAction.disabled = true;
+                    //this.audioLoaded=false;
+                    this.keepLiveLevel = true;
+                    let rUUID = null;
+                    let burl = null;
+                    if (this._session) {
+                        if (this._recordingFile) {
+                            let rf = this._recordingFile;
+                            rf.frames = this.ac.framesRecorded;
+                            rUUID = rf.uuid;
+                            //console.debug("stopped(): Set frames: "+rf.frames+" on rfId: "+this.displayRecFile?.recordingFileId);
+                            burl = this.recFileService.audioFileUrl(this._session?.project, rf);
+                        }
+                        else if (this.session?.project) {
+                            if (this.ac.recUUID) {
+                                rUUID = this.ac.recUUID;
+                                burl = this.recFileService.audioFileUrlByUUID(this.session.project, this.session.sessionId, rUUID);
+                            }
+                        }
+                        else {
+                            console.error("Could not create net audio buffer.");
+                        }
+                        if (burl) {
+                            const sr = this.ac.currentSampleRate;
+                            const chFl = sr * RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                            //console.debug("stopped(): rfID: "+this._recordingFile?.recordingFileId+", net ab url: " + burl+", frames: "+this.ac.framesRecorded+", sample rate: "+sr);
+                            let netAs = new NetAudioBuffer(this.recFileService, burl, this.ac.channelCount, sr, chFl, this.ac.framesRecorded, rUUID, chFl);
+                            as = netAs;
+                            if (this.uploadSet) {
+                                this.uploadSet.onDone = (uploadSet) => {
+                                    //console.debug("upload set on done: Call ready provider.ready");
+                                    netAs.ready();
+                                };
+                            }
+                        }
+                    }
+                }
+                else if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.ac.audioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.ac.audioStorageType) {
+                    if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.ac.audioStorageType) {
+                        const acAb = this.ac.audioBuffer();
+                        if (acAb) {
+                            as = new AudioBufferSource(acAb);
+                        }
+                    }
+                    if (AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.ac.audioStorageType) {
+                        as = this.ac.audioBufferArray();
+                    }
+                    if (!as) {
+                        this.playStartAction.disabled = true;
+                        this.keepLiveLevel = true;
+                        let rUUID = null;
+                        let burl = null;
+                        if (this._session) {
+                            if (this._recordingFile) {
+                                let rf = this._recordingFile;
+                                rf.frames = this.ac.framesRecorded;
+                                rUUID = rf.uuid;
+                                //console.debug("stopped(): Set frames: "+rf.frames+" on rfId: "+this.displayRecFile?.recordingFileId);
+                                burl = this.recFileService.audioFileUrl(this._session?.project, rf);
+                            }
+                            else if (this.session?.project) {
+                                if (this.ac.recUUID) {
+                                    rUUID = this.ac.recUUID;
+                                    burl = this.recFileService.audioFileUrlByUUID(this.session.project, this.session.sessionId, rUUID);
+                                }
+                            }
+                            else {
+                                console.error("Could not create net audio buffer.");
+                            }
+                            if (burl) {
+                                const sr = this.ac.currentSampleRate;
+                                const chFl = sr * RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;
+                                //console.debug("stopped(): rfID: "+this._recordingFile?.recordingFileId+", net ab url: " + burl+", frames: "+this.ac.framesRecorded+", sample rate: "+sr);
+                                let netAs = new NetAudioBuffer(this.recFileService, burl, this.ac.channelCount, sr, chFl, this.ac.framesRecorded, rUUID, chFl);
+                                as = netAs;
+                                if (this.uploadSet) {
+                                    this.uploadSet.onDone = (uploadSet) => {
+                                        //console.debug("upload set on done: Call ready provider.ready");
+                                        netAs.ready();
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (AudioStorageType.DB_CHUNKED === this.ac.audioStorageType) {
+                    as = this.ac.inddbAudioBufferArray();
+                }
+                else if (AudioStorageType.MEM_CHUNKED === this.ac.audioStorageType) {
+                    as = this.ac.audioBufferArray();
+                }
+                else {
+                    ab = this.ac.audioBuffer();
+                    if (ab) {
+                        as = new AudioBufferSource(ab);
+                    }
+                }
+                if (as) {
+                    adh = new AudioDataHolder(as);
+                }
+            }
+            let sessId = 0;
+            if (this._session) {
+                sessId = this._session.sessionId;
+            }
+            if (this._recordingFile) {
+                //this._recordingFile.samplerate=this.ac.currentSampleRate;
+                // Use an own reference since the writing of the wave file is asynchronous and this._recordingFile might already contain the next recording
+                let rf = this._recordingFile;
+                RecordingFileUtils.setAudioData(rf, adh);
+                this.recorderCombiPane.addRecFile(rf);
+                // Upload if upload enabled and not in chunked upload mode
+                if (this.enableUploadRecordings && this._uploadChunkSizeSeconds === null && AudioStorageType.MEM_ENTIRE === this._clientAudioStorageType && rf != null && ab != null) {
+                    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
+                    this.processingRecording = true;
+                    let ww = new WavWriter();
+                    ww.writeAsync(ab, (wavFile) => {
+                        this.postRecordingMultipart(wavFile, recUrl, rf);
+                        this.processingRecording = false;
+                        this.updateWakeLock();
+                        this.changeDetectorRef.detectChanges();
+                    });
+                }
+            }
+        }
+        this.displayRecFile = this._recordingFile;
+        this.status = 1 /* Status.IDLE */;
+        this.navigationDisabled = false;
+        this.updateNavigationActions();
+        this.updateWakeLock();
+        this.changeDetectorRef.detectChanges();
+    }
+    error(msg = 'An unknown error occured during recording.', advice = 'Please retry.') {
+        this.status = 5 /* Status.ERROR */;
+        super.error(msg, advice);
+        this.updateNavigationActions();
+        this.updateStartActionDisableState();
+    }
+    postRecordingMultipart(wavFile, recUrl, rf) {
+        let wavBlob = new Blob([wavFile], { type: 'audio/wav' });
+        let fd = new FormData();
+        if (rf.uuid) {
+            fd.set('uuid', rf.uuid);
+        }
+        if (rf.session !== null) {
+            fd.set('sessionId', rf.session.toString());
+        }
+        if (rf._startedAsDateObj) {
+            fd.set('startedDate', rf._startedAsDateObj.toJSON());
+        }
+        fd.set('audio', wavBlob);
+        let ul = new Upload(fd, recUrl, rf);
+        this.uploader.queueUpload(ul);
+    }
+    postChunkAudioBuffer(audioBuffer, chunkIdx) {
+        this.processingRecording = true;
+        let ww = new WavWriter();
+        let sessionsUrl = this.sessionsBaseUrl();
+        let recUrl = sessionsUrl + '/' + this.session?.sessionId + '/' + RECFILE_API_CTX + '/' + this.rfUuid + '/' + chunkIdx;
+        let rf = this._recordingFile;
+        // The upload holder is required to add the upload now to the upload set. The real upload is created async in postrecording and the upload set is already complete at that time.
+        let ulh = new UploadHolder();
+        if (this.uploadSet) {
+            this.uploadSet.add(ulh);
+        }
+        ww.writeAsync(audioBuffer, (wavFile) => {
+            this.postRecording(wavFile, recUrl, rf, ulh);
+            this.processingRecording = false;
+        });
+    }
+    stop() {
+        if (this.ac) {
+            this.ac.close();
+        }
+    }
+    updateControlPlaybackPosition() {
+        if (this._controlAudioPlayer) {
+            const ppFrames = this._controlAudioPlayer.playPositionFrames;
+            if (ppFrames !== null) {
+                this.recorderCombiPane.audioDisplay.playFramePosition = ppFrames;
+                this.liveLevelDisplay.playFramePosition = ppFrames;
+            }
+        }
+    }
+    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();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AudioRecorder, deps: [{ token: i1.BreakpointObserver }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i2.MatDialog }, { token: i3.SessionService }, { token: i4.RecordingService }, { token: i5.SpeechRecorderUploader }, { token: SPEECHRECORDER_CONFIG }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.6", 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 }], usesInheritance: 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 [class]="{audioStatusDisplay:!screenXs,audioStatusDisplayXs:screenXs}">
+      <audio-levelbar style="flex:1 0 1%" [streamingMode]="isRecording() || keepLiveLevel" [state]="liveLevelDisplayState"
+                      [displayLevelInfos]="displayAudioClip?.levelInfos"></audio-levelbar>
+      <div style="display:flex;flex-direction: row">
+        <spr-recordingitemcontrols style="flex:10 0 1px"
+                                   [disableAudioDetails]="disableAudioDetails"
+                                   [audioLoaded]="audioLoaded"
+                                   [playStartAction]="controlAudioPlayer?.startAction"
+                                   [playStopAction]="controlAudioPlayer?.stopAction"
+                                   [peakDbLvl]="peakLevelInDb"
+                                   [agc]="this.ac?.agcStatus"
+                                   (onShowRecordingDetails)="audioSignalCollapsed=!audioSignalCollapsed">
+        </spr-recordingitemcontrols>
+
+        <app-uploadstatus *ngIf="screenXs && enableUploadRecordings" class="ricontrols dark" style="flex:0 0 0"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-wakelockindicator *ngIf="screenXs" class="ricontrols dark" style="flex:0 0 0" [screenLocked]="screenLocked"></app-wakelockindicator>
+        <app-readystateindicator *ngIf="screenXs" class="ricontrols dark" style="flex:0 0 0"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+    <div #controlpanel class="controlpanel">
+      <app-sprstatusdisplay *ngIf="!screenXs" style="flex:0 1 30%;" [statusMsg]="statusMsg" [statusAlertType]="statusAlertType"
+                            [statusWaiting]="statusWaiting"
+                            class="hidden-xs"></app-sprstatusdisplay>
+      <div [class.startstop]="!screenXs" [class.startstopscreenxs]="screenXs">
+        <div style="align-content: center">
+          <button (click)="startStopPerform()" [disabled]="startDisabled() && stopDisabled()" mat-raised-button class="bigbutton">
+            <mat-icon class="bigbuttonicon" [style.color]="startStopNextIconColor()">{{startStopNextIconName()}}</mat-icon>
+            <span class="bigbuttontext">{{startStopNextName()}}</span>
+          </button>
+        </div>
+      </div>
+      <div style="flex:0 1 30%;display:flex;justify-items: flex-end;justify-content:flex-end" >
+        <app-uploadstatus *ngIf="!screenXs && enableUploadRecordings" class="ricontrols"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-wakelockindicator  *ngIf="!screenXs" class="ricontrols" [screenLocked]="screenLocked"></app-wakelockindicator>
+        <app-readystateindicator *ngIf="!screenXs" class="ricontrols"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{flex:2;background:lightgrey;display:flex;flex-direction:column;margin:0;padding:0;height:100%;min-height:0px;overflow:hidden}\n", ".ricontrols{padding:4px;box-sizing:border-box;height:100%}\n", ".dark{background:darkgray}\n", ".controlpanel{display:flex;flex-direction:row;align-content:center;align-items:center;margin:0;padding:20px;min-height:min-content}\n", ".startstop{width:100%;flex:1 0 30%;align-items:center;text-align:center;align-content:center}\n", ".startstopscreenxs{width:100%;flex:1 0 100%;align-items:center;text-align:center;align-content:center}\n", ".bigbutton{vertical-align:middle;overflow:hidden;text-overflow:clip;white-space:nowrap;letter-spacing:normal;min-width:70px;min-height:50px;border-radius:20px}\n", ".bigbuttonicon{min-width:50px;min-height:50px;font-size:50px}\n", ".bigbuttontext{font-weight:bolder;font-size:14px;vertical-align:middle}\n", ".audioStatusDisplay{display:flex;flex-direction:row;height:100px;min-height:100px}\n", ".audioStatusDisplayXs{display:flex;flex-direction:column;height:125px;min-height:125px}\n"], dependencies: [{ kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i8.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i9.LevelBar, selector: "audio-levelbar", inputs: ["streamingMode", "displayLevelInfos", "state"] }, { kind: "component", type: i10.StatusDisplay, selector: "app-sprstatusdisplay", inputs: ["statusAlertType", "statusMsg", "statusWaiting"] }, { kind: "component", type: i11.RecordingItemControls, selector: "spr-recordingitemcontrols", inputs: ["audioSignalCollapsed", "enableDownload", "peakDbLvl", "agc", "disableAudioDetails", "audioLoaded", "playStartAction", "playStopAction", "displayLevelInfos"], outputs: ["onShowRecordingDetails", "onDownloadRecording"] }, { kind: "component", type: i10.UploadStatus, selector: "app-uploadstatus", inputs: ["value", "awaitNewUpload", "status"] }, { kind: "component", type: i10.WakeLockIndicator, selector: "app-wakelockindicator", inputs: ["screenLocked"] }, { kind: "component", type: i10.ReadyStateIndicator, selector: "app-readystateindicator", inputs: ["ready"] }, { kind: "component", type: i12.WarningBar, selector: "app-warningbar", inputs: ["warningText", "show"] }, { kind: "component", type: i13.RecorderCombiPane, selector: "app-recordercombipane", inputs: ["selectDisabled", "selectedRecordingFile", "audioSignalCollapsed", "displayAudioClip", "playStartAction", "playSelectionAction", "autoPlayOnSelectToggleAction", "playStopAction"], outputs: ["selectedRecordingFileChanged"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", 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 [class]="{audioStatusDisplay:!screenXs,audioStatusDisplayXs:screenXs}">
+      <audio-levelbar style="flex:1 0 1%" [streamingMode]="isRecording() || keepLiveLevel" [state]="liveLevelDisplayState"
+                      [displayLevelInfos]="displayAudioClip?.levelInfos"></audio-levelbar>
+      <div style="display:flex;flex-direction: row">
+        <spr-recordingitemcontrols style="flex:10 0 1px"
+                                   [disableAudioDetails]="disableAudioDetails"
+                                   [audioLoaded]="audioLoaded"
+                                   [playStartAction]="controlAudioPlayer?.startAction"
+                                   [playStopAction]="controlAudioPlayer?.stopAction"
+                                   [peakDbLvl]="peakLevelInDb"
+                                   [agc]="this.ac?.agcStatus"
+                                   (onShowRecordingDetails)="audioSignalCollapsed=!audioSignalCollapsed">
+        </spr-recordingitemcontrols>
+
+        <app-uploadstatus *ngIf="screenXs && enableUploadRecordings" class="ricontrols dark" style="flex:0 0 0"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-wakelockindicator *ngIf="screenXs" class="ricontrols dark" style="flex:0 0 0" [screenLocked]="screenLocked"></app-wakelockindicator>
+        <app-readystateindicator *ngIf="screenXs" class="ricontrols dark" style="flex:0 0 0"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+    <div #controlpanel class="controlpanel">
+      <app-sprstatusdisplay *ngIf="!screenXs" style="flex:0 1 30%;" [statusMsg]="statusMsg" [statusAlertType]="statusAlertType"
+                            [statusWaiting]="statusWaiting"
+                            class="hidden-xs"></app-sprstatusdisplay>
+      <div [class.startstop]="!screenXs" [class.startstopscreenxs]="screenXs">
+        <div style="align-content: center">
+          <button (click)="startStopPerform()" [disabled]="startDisabled() && stopDisabled()" mat-raised-button class="bigbutton">
+            <mat-icon class="bigbuttonicon" [style.color]="startStopNextIconColor()">{{startStopNextIconName()}}</mat-icon>
+            <span class="bigbuttontext">{{startStopNextName()}}</span>
+          </button>
+        </div>
+      </div>
+      <div style="flex:0 1 30%;display:flex;justify-items: flex-end;justify-content:flex-end" >
+        <app-uploadstatus *ngIf="!screenXs && enableUploadRecordings" class="ricontrols"
+                          [value]="uploadProgress"
+                          [status]="uploadStatus" [awaitNewUpload]="processingRecording"></app-uploadstatus>
+        <app-wakelockindicator  *ngIf="!screenXs" class="ricontrols" [screenLocked]="screenLocked"></app-wakelockindicator>
+        <app-readystateindicator *ngIf="!screenXs" class="ricontrols"
+                                 [ready]="dataSaved && !isActive()"></app-readystateindicator>
+      </div>
+    </div>
+  `, styles: [":host{flex:2;background:lightgrey;display:flex;flex-direction:column;margin:0;padding:0;height:100%;min-height:0px;overflow:hidden}\n", ".ricontrols{padding:4px;box-sizing:border-box;height:100%}\n", ".dark{background:darkgray}\n", ".controlpanel{display:flex;flex-direction:row;align-content:center;align-items:center;margin:0;padding:20px;min-height:min-content}\n", ".startstop{width:100%;flex:1 0 30%;align-items:center;text-align:center;align-content:center}\n", ".startstopscreenxs{width:100%;flex:1 0 100%;align-items:center;text-align:center;align-content:center}\n", ".bigbutton{vertical-align:middle;overflow:hidden;text-overflow:clip;white-space:nowrap;letter-spacing:normal;min-width:70px;min-height:50px;border-radius:20px}\n", ".bigbuttonicon{min-width:50px;min-height:50px;font-size:50px}\n", ".bigbuttontext{font-weight:bolder;font-size:14px;vertical-align:middle}\n", ".audioStatusDisplay{display:flex;flex-direction:row;height:100px;min-height:100px}\n", ".audioStatusDisplayXs{display:flex;flex-direction:column;height:125px;min-height:125px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.BreakpointObserver }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i2.MatDialog }, { type: i3.SessionService }, { type: i4.RecordingService }, { type: i5.SpeechRecorderUploader }, { type: i14.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']]
+            }] } });
+export class AudioRecorderComponent extends RecorderComponent {
+    constructor(route, router, changeDetectorRef, sessionService, projectService, uploader) {
+        super(uploader);
+        this.route = route;
+        this.router = router;
+        this.changeDetectorRef = changeDetectorRef;
+        this.sessionService = sessionService;
+        this.projectService = projectService;
+        this.uploader = uploader;
+    }
+    ngOnInit() {
+        this.controlAudioPlayer = new AudioPlayer(this.ar);
+        this.ar.controlAudioPlayer = this.controlAudioPlayer;
+        //TODO Duplicate code in SpeechRecorderComponent
+        window.addEventListener('beforeunload', (e) => {
+            console.debug("Before page unload event");
+            if (this.ready()) {
+                return;
+            }
+            else {
+                // all this attempts to customize the message do not work anymore (for security reasons)!!
+                const message = "Please do not leave the page, until all recordings are uploaded!";
+                alert(message);
+                e = e || window.event;
+                if (e) {
+                    e.returnValue = message;
+                    e.cancelBubble = true;
+                    if (e.stopPropagation) {
+                        e.stopPropagation();
+                    }
+                    if (e.preventDefault) {
+                        e.preventDefault();
+                    }
+                }
+                return message;
+            }
+        });
+    }
+    ngAfterViewInit() {
+        // TODO call prepare !!
+        this.uploader.listener = (ue) => {
+            this.uploadUpdate(ue);
+        };
+        this.route.queryParams.subscribe((params) => {
+            if (params['sessionId']) {
+                this.fetchSession(params['sessionId']);
+            }
+        });
+        this.route.params.subscribe((params) => {
+            let routeParamsId = params['id'];
+            if (routeParamsId) {
+                this.fetchSession(routeParamsId);
+            }
+        });
+    }
+    ngOnDestroy() {
+        //super.ngOnDestroy();
+    }
+    get screenLocked() {
+        return this.ar.screenLocked;
+    }
+    fetchSession(sessionId) {
+        let sessObs = this.sessionService.sessionObserver(sessionId);
+        if (sessObs) {
+            sessObs.subscribe({
+                next: (sess) => {
+                    this.ar.statusAlertType = 'info';
+                    this.ar.statusMsg = 'Received session info.';
+                    this.ar.statusWaiting = false;
+                    this.session = sess;
+                    this.ar.session = sess;
+                    if (sess.project) {
+                        //console.debug("Session associated project: "+sess.project)
+                        this.projectService.projectObservable(sess.project).subscribe({
+                            next: (project) => {
+                                this.ar.project = project;
+                                this.ar.fetchRecordings(sess);
+                            }, error: (reason) => {
+                                this.ar.statusMsg = reason;
+                                this.ar.statusAlertType = 'error';
+                                this.ar.statusWaiting = false;
+                                console.error("Error fetching project config: " + reason);
+                            }
+                        });
+                    }
+                    else {
+                        console.info("Session has no associated project. Using default configuration.");
+                    }
+                },
+                error: (reason) => {
+                    this.ar.statusMsg = reason;
+                    this.ar.statusAlertType = 'error';
+                    this.ar.statusWaiting = false;
+                    console.error("Error fetching session " + reason);
+                }
+            });
+        }
+    }
+    uploadUpdate(ue) {
+        let upStatus = ue.status;
+        this.dataSaved = (UploaderStatus.DONE === upStatus);
+        let percentUpl = ue.percentDone();
+        if (UploaderStatus.ERR === upStatus) {
+            this.ar.uploadStatus = 'warn';
+        }
+        else {
+            if (percentUpl < 50) {
+                this.ar.uploadStatus = 'accent';
+            }
+            else {
+                this.ar.uploadStatus = 'success';
+            }
+            this.ar.uploadProgress = percentUpl;
+        }
+        this.ar.updateWakeLock(this.dataSaved);
+        this.changeDetectorRef.detectChanges();
+    }
+    ready() {
+        return this.dataSaved && !this.ar.isActive();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AudioRecorderComponent, deps: [{ token: i15.ActivatedRoute }, { token: i15.Router }, { token: i0.ChangeDetectorRef }, { token: i3.SessionService }, { token: i16.ProjectService }, { token: i5.SpeechRecorderUploader }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.6", type: AudioRecorderComponent, selector: "app-audiorecorder-comp", providers: [SessionService], viewQueries: [{ propertyName: "ar", first: true, predicate: AudioRecorder, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+    <app-audiorecorder [projectName]="_project?.name" [dataSaved]="dataSaved"></app-audiorecorder>
+  `, isInline: true, styles: [":host{flex:2;display:flex;height:100%;flex-direction:column;min-height:0}\n"], dependencies: [{ kind: "component", type: AudioRecorder, selector: "app-audiorecorder", inputs: ["projectName", "dataSaved"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AudioRecorderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-audiorecorder-comp', providers: [SessionService], template: `
+    <app-audiorecorder [projectName]="_project?.name" [dataSaved]="dataSaved"></app-audiorecorder>
+  `, styles: [":host{flex:2;display:flex;height:100%;flex-direction:column;min-height:0}\n"] }]
+        }], ctorParameters: () => [{ type: i15.ActivatedRoute }, { type: i15.Router }, { type: i0.ChangeDetectorRef }, { type: i3.SessionService }, { type: i16.ProjectService }, { type: i5.SpeechRecorderUploader }], propDecorators: { ar: [{
+                type: ViewChild,
+                args: [AudioRecorder, { static: true }]
+            }] } });
+//# 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 {AudioCapture, AudioCaptureListener} from '../../audio/capture/capture';\r\nimport {AudioPlayer, AudioPlayerEvent, EventType} from '../../audio/playback/player'\r\nimport {WavWriter} from '../../audio/impl/wavwriter'\r\nimport {RecordingFile, RecordingFileUtils} from '../recording'\r\nimport {\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  HostListener,\r\n  Inject,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Renderer2,\r\n  ViewChild\r\n} from \"@angular/core\";\r\nimport {SessionService} from \"./session.service\";\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 {AudioStorageType, Project, ProjectUtil} from \"../project/project\";\r\nimport {MessageDialog} from \"../../ui/message_dialog\";\r\nimport {RecordingService} from \"../recordings/recordings.service\";\r\n\r\nimport {AudioContextProvider} from \"../../audio/context\";\r\nimport {AudioClip} from \"../../audio/persistor\";\r\n\r\nimport {Upload, UploaderStatus, UploaderStatusChangeEvent, UploadHolder} from \"../../net/uploader\";\r\nimport {ActivatedRoute, Params, Router} from \"@angular/router\";\r\nimport {ProjectService} from \"../project/project.service\";\r\nimport {LevelBar, State as LiveLevelState} from \"../../audio/ui/livelevel\";\r\nimport {RecorderCombiPane} from \"./recorder_combi_pane\";\r\nimport {BasicRecorder, ChunkAudioBufferReceiver, MAX_RECORDING_TIME_MS, RECFILE_API_CTX} from \"./basicrecorder\";\r\nimport {ReadyStateProvider, RecorderComponent} from \"../../recorder_component\";\r\nimport {Mode} from \"../../speechrecorderng.component\";\r\nimport {AudioBufferSource, AudioDataHolder, AudioSource} from \"../../audio/audio_data_holder\";\r\nimport {ArrayAudioBuffer} from \"../../audio/array_audio_buffer\";\r\nimport {NetAudioBuffer} from \"../../audio/net_audio_buffer\";\r\nimport {IndexedDbAudioBuffer} from \"../../audio/inddb_audio_buffer\";\r\nimport {BreakpointObserver} from \"@angular/cdk/layout\";\r\n\r\nexport const enum Status {\r\n  BLOCKED, IDLE,STARTING, RECORDING,  STOPPING_STOP, ERROR\r\n}\r\n\r\n\r\n@Component({\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 [class]=\"{audioStatusDisplay:!screenXs,audioStatusDisplayXs:screenXs}\">\r\n      <audio-levelbar style=\"flex:1 0 1%\" [streamingMode]=\"isRecording() || keepLiveLevel\" [state]=\"liveLevelDisplayState\"\r\n                      [displayLevelInfos]=\"displayAudioClip?.levelInfos\"></audio-levelbar>\r\n      <div style=\"display:flex;flex-direction: row\">\r\n        <spr-recordingitemcontrols style=\"flex:10 0 1px\"\r\n                                   [disableAudioDetails]=\"disableAudioDetails\"\r\n                                   [audioLoaded]=\"audioLoaded\"\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\r\n        <app-uploadstatus *ngIf=\"screenXs && enableUploadRecordings\" class=\"ricontrols dark\" style=\"flex:0 0 0\"\r\n                          [value]=\"uploadProgress\"\r\n                          [status]=\"uploadStatus\" [awaitNewUpload]=\"processingRecording\"></app-uploadstatus>\r\n        <app-wakelockindicator *ngIf=\"screenXs\" class=\"ricontrols dark\" style=\"flex:0 0 0\" [screenLocked]=\"screenLocked\"></app-wakelockindicator>\r\n        <app-readystateindicator *ngIf=\"screenXs\" class=\"ricontrols dark\" style=\"flex:0 0 0\"\r\n                                 [ready]=\"dataSaved && !isActive()\"></app-readystateindicator>\r\n      </div>\r\n    </div>\r\n    <div #controlpanel class=\"controlpanel\">\r\n      <app-sprstatusdisplay *ngIf=\"!screenXs\" style=\"flex:0 1 30%;\" [statusMsg]=\"statusMsg\" [statusAlertType]=\"statusAlertType\"\r\n                            [statusWaiting]=\"statusWaiting\"\r\n                            class=\"hidden-xs\"></app-sprstatusdisplay>\r\n      <div [class.startstop]=\"!screenXs\" [class.startstopscreenxs]=\"screenXs\">\r\n        <div style=\"align-content: center\">\r\n          <button (click)=\"startStopPerform()\" [disabled]=\"startDisabled() && stopDisabled()\" mat-raised-button class=\"bigbutton\">\r\n            <mat-icon class=\"bigbuttonicon\" [style.color]=\"startStopNextIconColor()\">{{startStopNextIconName()}}</mat-icon>\r\n            <span class=\"bigbuttontext\">{{startStopNextName()}}</span>\r\n          </button>\r\n        </div>\r\n      </div>\r\n      <div style=\"flex:0 1 30%;display:flex;justify-items: flex-end;justify-content:flex-end\" >\r\n        <app-uploadstatus *ngIf=\"!screenXs && enableUploadRecordings\" class=\"ricontrols\"\r\n                          [value]=\"uploadProgress\"\r\n                          [status]=\"uploadStatus\" [awaitNewUpload]=\"processingRecording\"></app-uploadstatus>\r\n        <app-wakelockindicator  *ngIf=\"!screenXs\" class=\"ricontrols\" [screenLocked]=\"screenLocked\"></app-wakelockindicator>\r\n        <app-readystateindicator *ngIf=\"!screenXs\" class=\"ricontrols\"\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    height: 100%;\r\n    min-height: 0px;\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    display:flex;\r\n    flex-direction: row;\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    flex:1 0 30%;\r\n    align-items: center;\r\n    text-align: center;\r\n    align-content: center;\r\n  }`,`.startstopscreenxs {\r\n    width: 100%;\r\n    flex:1 0 100%;\r\n    align-items: center;\r\n    text-align: center;\r\n    align-content: center;\r\n  }`,`.bigbutton {\r\n    vertical-align: middle;\r\n    overflow: hidden;\r\n    text-overflow: clip;\r\n    white-space: nowrap;\r\n    letter-spacing: normal;\r\n    min-width: 70px;\r\n    min-height: 50px;\r\n    border-radius: 20px;\r\n  }`,`.bigbuttonicon {\r\n    min-width: 50px;\r\n    min-height: 50px;\r\n    font-size: 50px;\r\n  }`,`.bigbuttontext {\r\n      font-weight: bolder;\r\n      font-size: 14px;\r\n      vertical-align: middle;\r\n  }\r\n  `,`.audioStatusDisplay{\r\n    display:flex;\r\n    flex-direction: row;\r\n    height:100px;\r\n    min-height: 100px;\r\n  }`,`.audioStatusDisplayXs{\r\n    display:flex;\r\n    flex-direction: column;\r\n    height:125px;\r\n    min-height: 125px;\r\n  }`\r\n   ]\r\n})\r\nexport class AudioRecorder extends BasicRecorder implements OnInit,AfterViewInit,OnDestroy, AudioCaptureListener,ReadyStateProvider,ChunkAudioBufferReceiver {\r\n\r\n  _project:Project|undefined| null=null;\r\n  @Input() projectName:string|undefined|null=null;\r\n  enableUploadRecordings: boolean = true;\r\n  enableDownloadRecordings: boolean = false;\r\n  status: Status = Status.BLOCKED;\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\r\n\r\n\r\n  startStopNextButtonName!:string;\r\n  startStopNextButtonIconName!:string;\r\n\r\n  audio: any;\r\n\r\n  private _displayRecFile: RecordingFile | null=null;\r\n  private displayRecFileVersion: number=0;\r\n\r\n\r\n  constructor(protected bpo:BreakpointObserver,changeDetectorRef: ChangeDetectorRef,\r\n              private renderer: Renderer2,\r\n              dialog: MatDialog,\r\n              sessionService:SessionService,\r\n              private recFileService:RecordingService,\r\n              protected uploader: SpeechRecorderUploader,\r\n              @Inject(SPEECHRECORDER_CONFIG) config?: SpeechRecorderConfig) {\r\n    super(bpo,changeDetectorRef,dialog,sessionService,uploader,config);\r\n\r\n    //super(injector);\r\n    this.status = Status.IDLE;\r\n\r\n    this.audio = document.getElementById('audio');\r\n\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\r\n  ngAfterViewInit() {\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    //let wakeLockSupp=('wakeLock' in navigator);\r\n    //alert('Wake lock API supported: '+wakeLockSupp);\r\n  }\r\n\r\n  ready():boolean{\r\n    return this.dataSaved && !this.isActive()\r\n  }\r\n    ngOnDestroy() {\r\n      this.disableWakeLockCond();\r\n       this.destroyed=true;\r\n       // TODO stop capture /playback\r\n    }\r\n\r\n  ngOnInit() {\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      this.ac = new AudioCapture();\r\n      if (this.ac) {\r\n        this.transportActions.startAction.onAction = () => this.startItem();\r\n        this.ac.listener = this;\r\n        this.configureStreamCaptureStream();\r\n\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            advice: '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    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 == ' ') {\r\n      if(!this.transportActions.startAction.disabled){\r\n        this.transportActions.startAction.perform();\r\n      }else if(!this.transportActions.stopAction.disabled) {\r\n        this.transportActions.stopAction.perform();\r\n      }\r\n    }\r\n    if (ke.key == 'p') {\r\n      this.transportActions.pauseAction.perform();\r\n    }\r\n    if (ke.key == 'Escape') {\r\n      if (!this.audioSignalCollapsed) {\r\n        this.audioSignalCollapsed = true;\r\n      }\r\n      this.transportActions.stopAction.perform();\r\n      this.transportActions.pauseAction.perform();\r\n    }\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\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({next:(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              // the list comes from the server, asssuem all recording files as server persisted\r\n              rf.serverPersisted=true;\r\n              if(rf.startedDate){\r\n                rf._startedAsDateObj=new Date(rf.startedDate);\r\n              }\r\n              if(rf.date){\r\n                rf._dateAsDateObj=new Date(rf.date);\r\n              }\r\n              this.recorderCombiPane.addRecFile(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      }, error:(err) => {\r\n        // Failed fetching existing, but we start the session anyway\r\n        this.start()\r\n      }, complete:() => {\r\n        // Normal start\r\n        this.start()\r\n      }\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|undefined|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      if (project.recordingDeviceWakeLock === true) {\r\n        this.wakeLock = true;\r\n      }\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      if(project.allowEchoCancellation!==undefined) {\r\n        this.allowEchoCancellation = project.allowEchoCancellation;\r\n      }\r\n      if (project.chunkedRecording === true) {\r\n        this.uploadChunkSizeSeconds = BasicRecorder.DEFAULT_CHUNK_SIZE_SECONDS;\r\n      } else {\r\n        this.uploadChunkSizeSeconds = null;\r\n      }\r\n      if (project.clientAudioStorageType) {\r\n        this.clientAudioStorageType = project.clientAudioStorageType;\r\n      }\r\n    } else {\r\n      console.error(\"Empty project configuration!\")\r\n    }\r\n    this.channelCount = chCnt;\r\n  }\r\n\r\n\r\n  get project():Project|undefined|null{\r\n    return this._project;\r\n  }\r\n\r\n  selectRecordingFile(rf:RecordingFile){\r\n    this.liveLevelDisplayState=LiveLevelState.READY;\r\n    this.keepLiveLevel=false;\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|null) {\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|null {\r\n    return this._controlAudioPlayer;\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      //console.debug(\"Enable play start action (by player events stopped or ended): \"+(!(this.displayRecFile)));\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.status=Status.STARTING;\r\n    super.startItem();\r\n    if (this.readonly) {\r\n      this.status=Status.IDLE;\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.liveLevelDisplay.reset(true);\r\n    this.liveLevelDisplayState=LiveLevelState.READY;\r\n    this.showRecording();\r\n\r\n    this.startCapture();\r\n  }\r\n\r\n\r\n  downloadRecording() {\r\n    if (this.displayRecFile) {\r\n      let ab: AudioDataHolder | null = this.displayRecFile.audioDataHolder;\r\n      let ww = new WavWriter();\r\n      let as=ab?.audioSource;\r\n      if(as instanceof AudioBufferSource) {\r\n          ww.writeAsync(as.audioBuffer, (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.audioLoaded=false;\r\n    this._displayRecFile = displayRecFile;\r\n    if (this._displayRecFile) {\r\n      let adh: AudioDataHolder| null = this._displayRecFile.audioDataHolder;\r\n      if(adh) {\r\n        this.displayAudioClip = new AudioClip(adh);\r\n        //this.audioLoaded=true;\r\n        //console.debug(\" set recording file: display audio clip set\");\r\n        if(this._controlAudioPlayer) {\r\n          this._controlAudioPlayer.audioClip = this.displayAudioClip;\r\n        }\r\n        this.showRecording();\r\n      }else {\r\n        // clear for now ...\r\n        this.displayAudioClip = null;\r\n        //console.debug(\"set recording file: display audio clip null\");\r\n        if(this._controlAudioPlayer) {\r\n          this._controlAudioPlayer.audioClip = null;\r\n        }\r\n\r\n        if (this._controlAudioPlayer && this._session) {\r\n          //... and try to fetch from server\r\n          this.liveLevelDisplayState=LiveLevelState.LOADING;\r\n          const rf=this._displayRecFile;\r\n\r\n          let audioDownloadType=this._clientAudioStorageType;\r\n          if(AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED===this._clientAudioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED===this._clientAudioStorageType) {\r\n            // Default is network mode\r\n            audioDownloadType=AudioStorageType.NET_CHUNKED;\r\n            if (rf.channels && rf.frames) {\r\n              const samples = rf.channels * rf.frames;\r\n              if (samples <= this._maxAutoNetMemStoreSamples) {\r\n                // But if audio file is small, load in continuous resp. chunked mode\r\n                if(AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED===this._clientAudioStorageType){\r\n                  audioDownloadType=AudioStorageType.MEM_ENTIRE;\r\n                }else if(AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED===this._clientAudioStorageType) {\r\n                  audioDownloadType = AudioStorageType.MEM_CHUNKED;\r\n                }\r\n              }\r\n            }\r\n          }\r\n\r\n          if(AudioStorageType.DB_CHUNKED===this._clientAudioStorageType){\r\n            // Fetch chunked indexed db audio buffer\r\n            let nextIab: IndexedDbAudioBuffer | null = null;\r\n            if(!this._persistentAudioStorageTarget){\r\n              throw Error('Error: Persistent storage target not set.');\r\n            }else {\r\n              //console.debug(\"Fetch audio and store to indexed db...\");\r\n              this.audioFetchSubscription = this.recFileService.fetchRecordingFileIndDbAudioBuffer(this._persistentAudioStorageTarget, this._session.project, rf).subscribe({\r\n                next: (iab) => {\r\n                  //console.debug(\"Sessionmanager: Received inddb audio buffer: \"+iab);\r\n                  nextIab = iab;\r\n                },\r\n                complete: () => {\r\n                  this.liveLevelDisplayState = LiveLevelState.READY;\r\n                  let fabDh = null;\r\n                  if (nextIab) {\r\n                    if (rf ) {\r\n                      fabDh = new AudioDataHolder(nextIab);\r\n                      //this.audioLoaded=true;\r\n                      this.recorderCombiPane.setRecFileAudioData(rf, fabDh);\r\n                    }\r\n                  } else {\r\n                    // Should actually be handled by the error resolver\r\n                    this.statusMsg = 'Recording file could not be loaded.'\r\n                    this.statusAlertType = 'error'\r\n                  }\r\n                  if (fabDh) {\r\n                    // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item\r\n                    this.displayAudioClip = new AudioClip(fabDh);\r\n                  }\r\n                  if(this._controlAudioPlayer) {\r\n                    this._controlAudioPlayer.audioClip = this.displayAudioClip\r\n                  }\r\n                  this.showRecording();\r\n                },\r\n                error: err => {\r\n                  console.error(\"Could not load recording file from server: \" + err);\r\n                  this.liveLevelDisplayState = LiveLevelState.READY;\r\n                  this.statusMsg = 'Recording file could not be loaded: ' + err;\r\n                  this.statusAlertType = 'error';\r\n                  this.changeDetectorRef.detectChanges();\r\n                }\r\n              });\r\n            }\r\n          }else if(AudioStorageType.NET_CHUNKED===audioDownloadType){\r\n            // Fetch chunked audio buffer from network\r\n            let nextNetAb: NetAudioBuffer | null = null;\r\n\r\n            //console.debug(\"Fetch chunked audio from network\");\r\n            this.audioFetchSubscription = this.recFileService.fetchRecordingFileNetAudioBuffer( this._session.project, rf).subscribe({\r\n              next: (netAb) => {\r\n                //console.debug(\"Sessionmanager: Received net audio buffer: \"+netAb);\r\n                nextNetAb = netAb;\r\n              },\r\n              complete: () => {\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                let fabDh = null;\r\n                if (nextNetAb) {\r\n                  if (rf) {\r\n                    fabDh = new AudioDataHolder(nextNetAb);\r\n\r\n                    this.recorderCombiPane.setRecFileAudioData(rf, fabDh);\r\n                  }\r\n                } else {\r\n                  // Should actually be handled by the error resolver\r\n                  this.statusMsg = 'Recording file could not be loaded.'\r\n                  this.statusAlertType = 'error'\r\n                }\r\n                if (fabDh) {\r\n                  // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item\r\n                  //console.debug(\"set displayRecFile(): fetch net ab complete, set displayAudioClip.\")\r\n                  this.displayAudioClip = new AudioClip(fabDh);\r\n                  // fabDh.onReady=()=>{\r\n                  //   this.audioLoaded=true;\r\n                  // }\r\n                }\r\n                if(this._controlAudioPlayer) {\r\n                  this._controlAudioPlayer.audioClip = this.displayAudioClip;\r\n                }\r\n                this.showRecording();\r\n              },\r\n              error: err => {\r\n                console.error(\"Could not load recording file from server: \" + err);\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                this.statusMsg = 'Recording file could not be loaded: ' + err;\r\n                this.statusAlertType = 'error';\r\n                this.changeDetectorRef.detectChanges();\r\n              }\r\n            });\r\n\r\n          }else if(AudioStorageType.MEM_CHUNKED===audioDownloadType){\r\n            // Fetch chunked array audio buffer\r\n            let nextAab: ArrayAudioBuffer | null = null;\r\n            //console.debug(\"Fetch audio and store to (chunked) array buffer...\");\r\n            this.audioFetchSubscription = this.recFileService.fetchRecordingFileArrayAudioBuffer( this._session.project, rf).subscribe({\r\n              next: (aab) => {\r\n                nextAab = aab;\r\n              },\r\n              complete: () => {\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                let fabDh = null;\r\n                if (nextAab) {\r\n                  if (rf ) {\r\n                    fabDh = new AudioDataHolder(nextAab);\r\n                    this.recorderCombiPane.setRecFileAudioData(rf, fabDh);\r\n                  }\r\n                } else {\r\n                  // Should actually be handled by the error resolver\r\n                  this.statusMsg = 'Recording file could not be loaded.'\r\n                  this.statusAlertType = 'error'\r\n                }\r\n                if (fabDh) {\r\n                  // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item\r\n                  this.displayAudioClip = new AudioClip(fabDh);\r\n                  //this.audioLoaded=true;\r\n                }\r\n                if(this._controlAudioPlayer) {\r\n                  this._controlAudioPlayer.audioClip = this.displayAudioClip;\r\n                }\r\n                this.showRecording();\r\n              },\r\n              error: err => {\r\n                console.error(\"Could not load recording file from server: \" + err);\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                this.statusMsg = 'Recording file could not be loaded: ' + err;\r\n                this.statusAlertType = 'error';\r\n              }\r\n            });\r\n\r\n          } else {\r\n            this.audioFetchSubscription = this.recFileService.fetchRecordingFileAudioBuffer(this._session.project, rf).subscribe({\r\n              next: ab => {\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                let fabDh = null;\r\n                if (ab) {\r\n                  let abSrc=new AudioBufferSource(ab);\r\n                  if (rf) {\r\n                    fabDh = new AudioDataHolder(abSrc);\r\n                    this.recorderCombiPane.setRecFileAudioData(rf, fabDh);\r\n                  }\r\n                } else {\r\n                  console.error('Recording file could not be loaded.');\r\n                  this.statusMsg = 'Recording file could not be loaded.';\r\n                  this.statusAlertType = 'error';\r\n                }\r\n                if (fabDh) {\r\n                  // this.displayAudioClip could have been changed meanwhile, but the recorder unsubcribes before changing the item. Therefore, there should be no risk to set to wrong item\r\n                  this.displayAudioClip = new AudioClip(fabDh);\r\n                  //this.audioLoaded=true;\r\n                  //console.debug(\"set recording file: display audio clip from fetched audio buffer\");\r\n                }\r\n                if(this._controlAudioPlayer) {\r\n                  this._controlAudioPlayer.audioClip = this.displayAudioClip;\r\n                }\r\n                this.showRecording();\r\n              }, error: err => {\r\n                console.error(\"Could not load recording file from server: \" + err);\r\n                this.liveLevelDisplayState = LiveLevelState.READY;\r\n                this.statusMsg = 'Recording file could not be loaded: ' + err;\r\n                this.statusAlertType = 'error';\r\n              }\r\n            })\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      //console.debug(\"recording file null\");\r\n      this.displayAudioClip = null;\r\n      if(this._controlAudioPlayer) {\r\n        this._controlAudioPlayer.audioClip = null;\r\n      }\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  updateStartActionDisableState(){\r\n    this.transportActions.startAction.disabled=!(this.ac);\r\n  }\r\n\r\n  start() {\r\n    super.start();\r\n    this.recorderCombiPane.selectTop();\r\n    this.enableNavigation();\r\n    this.updateStartActionDisableState();\r\n\r\n  }\r\n\r\n  isRecording(): boolean {\r\n    return (this.status === Status.RECORDING || this.status===Status.STOPPING_STOP);\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\r\n  updateWakeLock(dataSaved:boolean=this.dataSaved){\r\n    //console.debug(\"Update wake lock: dataSaved: \"+dataSaved+\", not active: \"+! this.isActive())\r\n    if(dataSaved && ! this.isActive()){\r\n      this.disableWakeLockCond();\r\n    }\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  enableStartUserGesture() {\r\n    super.enableStartUserGesture();\r\n    this.transportActions.startAction.disabled=!(this.ac);\r\n  }\r\n\r\n  enableNavigation(){\r\n    this.navigationDisabled=false;\r\n    this.updateNavigationActions();\r\n  }\r\n\r\n  started() {\r\n    this.status = Status.RECORDING;\r\n    super.started();\r\n    this.statusAlertType = 'info';\r\n    this.statusMsg = 'Recording...';\r\n\r\n    let sessId: string | number = 0;\r\n    if(this._session){\r\n      sessId=this._session.sessionId;\r\n    }\r\n\r\n    if(this.rfUuid) {\r\n      let rf = new RecordingFile(this.rfUuid, sessId, null);\r\n      rf._startedAsDateObj = this.startedDate;\r\n      if (rf._startedAsDateObj) {\r\n        rf.startedDate = rf._startedAsDateObj.toString();\r\n      }\r\n      this._recordingFile = rf;\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    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  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\r\n    let ab:AudioBuffer|null=null;\r\n\r\n    if(this.ac) {\r\n      let adh:AudioDataHolder|null=null;\r\n      let as:AudioSource|null=null;\r\n      if(this.ac) {\r\n        if (AudioStorageType.NET_CHUNKED === this.ac.audioStorageType) {\r\n          this.playStartAction.disabled = true;\r\n          //this.audioLoaded=false;\r\n          this.keepLiveLevel=true;\r\n          let rUUID:string|null=null;\r\n            let burl:string|null=null;\r\n            if(this._session) {\r\n              if (this._recordingFile) {\r\n\r\n                let rf = this._recordingFile;\r\n                rf.frames=this.ac.framesRecorded;\r\n                rUUID=rf.uuid;\r\n                //console.debug(\"stopped(): Set frames: \"+rf.frames+\" on rfId: \"+this.displayRecFile?.recordingFileId);\r\n                burl = this.recFileService.audioFileUrl(this._session?.project, rf);\r\n              } else if (this.session?.project) {\r\n                if(this.ac.recUUID) {\r\n                  rUUID=this.ac.recUUID;\r\n                  burl = this.recFileService.audioFileUrlByUUID(this.session.project, this.session.sessionId, rUUID);\r\n                }\r\n              }else{\r\n                console.error(\"Could not create net audio buffer.\");\r\n              }\r\n              if (burl) {\r\n                const sr = this.ac.currentSampleRate;\r\n                const chFl=sr*RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n                //console.debug(\"stopped(): rfID: \"+this._recordingFile?.recordingFileId+\", net ab url: \" + burl+\", frames: \"+this.ac.framesRecorded+\", sample rate: \"+sr);\r\n                let netAs = new NetAudioBuffer(this.recFileService, burl, this.ac.channelCount, sr, chFl, this.ac.framesRecorded, rUUID, chFl);\r\n                as=netAs;\r\n                if(this.uploadSet){\r\n                  this.uploadSet.onDone=(uploadSet)=>{\r\n                    //console.debug(\"upload set on done: Call ready provider.ready\");\r\n                    netAs.ready();\r\n                  }\r\n                }\r\n\r\n              }\r\n            }\r\n\r\n        }else if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.ac.audioStorageType || AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.ac.audioStorageType) {\r\n          if (AudioStorageType.MEM_ENTIRE_AUTO_NET_CHUNKED === this.ac.audioStorageType){\r\n            const acAb=this.ac.audioBuffer();\r\n            if(acAb) {\r\n              as = new AudioBufferSource(acAb);\r\n            }\r\n          }\r\n          if(AudioStorageType.MEM_CHUNKED_AUTO_NET_CHUNKED === this.ac.audioStorageType){\r\n            as = this.ac.audioBufferArray();\r\n          }\r\n          if(!as){\r\n            this.playStartAction.disabled = true;\r\n            this.keepLiveLevel=true;\r\n            let rUUID:string|null=null;\r\n            let burl:string|null=null;\r\n            if(this._session) {\r\n              if (this._recordingFile) {\r\n                let rf = this._recordingFile;\r\n                rf.frames=this.ac.framesRecorded;\r\n                rUUID=rf.uuid;\r\n                //console.debug(\"stopped(): Set frames: \"+rf.frames+\" on rfId: \"+this.displayRecFile?.recordingFileId);\r\n                burl = this.recFileService.audioFileUrl(this._session?.project, rf);\r\n              } else if (this.session?.project) {\r\n                if(this.ac.recUUID) {\r\n                  rUUID=this.ac.recUUID;\r\n                  burl = this.recFileService.audioFileUrlByUUID(this.session.project, this.session.sessionId, rUUID);\r\n                }\r\n              }else{\r\n                console.error(\"Could not create net audio buffer.\");\r\n              }\r\n              if (burl) {\r\n                const sr = this.ac.currentSampleRate;\r\n                const chFl=sr*RecordingService.DEFAULT_CHUNKED_DOWNLOAD_SECONDS;\r\n                //console.debug(\"stopped(): rfID: \"+this._recordingFile?.recordingFileId+\", net ab url: \" + burl+\", frames: \"+this.ac.framesRecorded+\", sample rate: \"+sr);\r\n                let netAs = new NetAudioBuffer(this.recFileService, burl, this.ac.channelCount, sr, chFl, this.ac.framesRecorded, rUUID, chFl);\r\n                as = netAs;\r\n                if (this.uploadSet) {\r\n                  this.uploadSet.onDone = (uploadSet) => {\r\n                    //console.debug(\"upload set on done: Call ready provider.ready\");\r\n                    netAs.ready();\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        } else if (AudioStorageType.DB_CHUNKED === this.ac.audioStorageType) {\r\n          as = this.ac.inddbAudioBufferArray();\r\n        } else if (AudioStorageType.MEM_CHUNKED === this.ac.audioStorageType) {\r\n          as = this.ac.audioBufferArray();\r\n        } else {\r\n          ab = this.ac.audioBuffer();\r\n          if(ab) {\r\n            as = new AudioBufferSource(ab);\r\n          }\r\n        }\r\n        if (as) {\r\n          adh = new AudioDataHolder(as);\r\n        }\r\n      }\r\n\r\n      let sessId: string | number = 0;\r\n      if(this._session){\r\n        sessId=this._session.sessionId;\r\n      }\r\n\r\n      if(this._recordingFile) {\r\n        //this._recordingFile.samplerate=this.ac.currentSampleRate;\r\n        // Use an own reference since the writing of the wave file is asynchronous and this._recordingFile might already contain the next recording\r\n        let rf = this._recordingFile;\r\n        RecordingFileUtils.setAudioData(rf,adh);\r\n        this.recorderCombiPane.addRecFile(rf);\r\n\r\n        // Upload if upload enabled and not in chunked upload mode\r\n        if (this.enableUploadRecordings && this._uploadChunkSizeSeconds===null && AudioStorageType.MEM_ENTIRE===this._clientAudioStorageType && rf != null && ab != null) {\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          // 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\r\n          this.processingRecording = true\r\n          let ww = new WavWriter();\r\n          ww.writeAsync(ab, (wavFile) => {\r\n            this.postRecordingMultipart(wavFile,recUrl,rf);\r\n            this.processingRecording = false;\r\n            this.updateWakeLock();\r\n            this.changeDetectorRef.detectChanges();\r\n          });\r\n        }\r\n      }\r\n    }\r\n    this.displayRecFile = this._recordingFile;\r\n    this.status = Status.IDLE;\r\n    this.navigationDisabled = false;\r\n    this.updateNavigationActions();\r\n    this.updateWakeLock();\r\n    this.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  error(msg='An unknown error occured during recording.',advice:string='Please retry.') {\r\n    this.status=Status.ERROR;\r\n    super.error(msg,advice);\r\n    this.updateNavigationActions();\r\n    this.updateStartActionDisableState();\r\n  }\r\n\r\n  postRecordingMultipart(wavFile: Uint8Array,recUrl: string,rf:RecordingFile) {\r\n    let wavBlob = new Blob([wavFile], {type: 'audio/wav'});\r\n\r\n    let fd=new FormData();\r\n    if(rf.uuid) {\r\n      fd.set('uuid', rf.uuid);\r\n    }\r\n    if(rf.session!==null) {\r\n      fd.set('sessionId', rf.session.toString());\r\n    }\r\n    if(rf._startedAsDateObj){\r\n      fd.set('startedDate',rf._startedAsDateObj.toJSON());\r\n    }\r\n    fd.set('audio',wavBlob);\r\n    let ul = new Upload(fd, recUrl,rf);\r\n    this.uploader.queueUpload(ul);\r\n  }\r\n\r\n  postChunkAudioBuffer(audioBuffer: AudioBuffer, chunkIdx: number): void {\r\n    this.processingRecording = true;\r\n    let ww = new WavWriter();\r\n    let sessionsUrl = this.sessionsBaseUrl();\r\n    let recUrl: string = sessionsUrl + '/' + this.session?.sessionId + '/' + RECFILE_API_CTX + '/' + this.rfUuid+'/'+chunkIdx;\r\n    let rf=this._recordingFile;\r\n\r\n    // The upload holder is required to add the upload now to the upload set. The real upload is created async in postrecording and the upload set is already complete at that time.\r\n    let ulh=new UploadHolder();\r\n    if(this.uploadSet){\r\n      this.uploadSet.add(ulh);\r\n    }\r\n    ww.writeAsync(audioBuffer, (wavFile) => {\r\n      this.postRecording(wavFile, recUrl,rf,ulh);\r\n      this.processingRecording = false;\r\n    });\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){\r\n      const ppFrames=this._controlAudioPlayer.playPositionFrames;\r\n      if (ppFrames!==null) {\r\n        this.recorderCombiPane.audioDisplay.playFramePosition = ppFrames;\r\n        this.liveLevelDisplay.playFramePosition = ppFrames;\r\n      }\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    if(!this.destroyed) {\r\n        this.changeDetectorRef.detectChanges();\r\n    }\r\n  }\r\n}\r\n\r\n@Component({\r\n  selector: 'app-audiorecorder-comp',\r\n  providers: [SessionService],\r\n  template: `\r\n    <app-audiorecorder [projectName]=\"_project?.name\" [dataSaved]=\"dataSaved\"></app-audiorecorder>\r\n  `,\r\n  styles: [`:host{\r\n    flex: 2;\r\n    display: flex;\r\n      height: 100%;\r\n    flex-direction: column;\r\n    min-height:0;\r\n\r\n  }`]\r\n\r\n})\r\nexport class AudioRecorderComponent extends RecorderComponent  implements OnInit,OnDestroy,AfterViewInit,ReadyStateProvider {\r\n\r\n  mode!:Mode;\r\n  controlAudioPlayer!:AudioPlayer;\r\n  audio:any;\r\n\r\n  _project:Project|undefined;\r\n  sessionId!: string;\r\n  session!:Session;\r\n\r\n  @ViewChild(AudioRecorder, { static: true }) ar!:AudioRecorder;\r\n\r\n  constructor(private route: ActivatedRoute,\r\n              private router: Router,\r\n              private changeDetectorRef: ChangeDetectorRef,\r\n              private sessionService:SessionService,\r\n              private projectService:ProjectService,\r\n              protected uploader:SpeechRecorderUploader\r\n  ) {\r\n    super(uploader);\r\n  }\r\n\r\n  ngOnInit() {\r\n\r\n    this.controlAudioPlayer = new AudioPlayer(this.ar);\r\n\r\n    this.ar.controlAudioPlayer=this.controlAudioPlayer;\r\n\r\n    //TODO Duplicate code in SpeechRecorderComponent\r\n    window.addEventListener('beforeunload', (e) => {\r\n      console.debug(\"Before page unload event\");\r\n\r\n      if (this.ready()) {\r\n        return;\r\n      } else {\r\n        // all this attempts to customize the message do not work anymore (for security reasons)!!\r\n        const message = \"Please do not leave the page, until all recordings are uploaded!\";\r\n        alert(message);\r\n        e = e || window.event;\r\n\r\n        if (e) {\r\n          e.returnValue = message;\r\n          e.cancelBubble = true;\r\n          if (e.stopPropagation) {\r\n            e.stopPropagation();\r\n          }\r\n          if (e.preventDefault) {\r\n            e.preventDefault();\r\n          }\r\n        }\r\n\r\n        return message;\r\n      }\r\n    });\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n\r\n    // TODO call prepare !!\r\n\r\n    this.uploader.listener = (ue) => {\r\n      this.uploadUpdate(ue);\r\n    }\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.route.params.subscribe((params: Params) => {\r\n      let routeParamsId = params['id'];\r\n      if (routeParamsId) {\r\n        this.fetchSession(routeParamsId);\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    //super.ngOnDestroy();\r\n  }\r\n\r\n  get screenLocked():boolean{\r\n    return  this.ar.screenLocked;\r\n  }\r\n\r\n  fetchSession(sessionId:string){\r\n\r\n    let sessObs= this.sessionService.sessionObserver(sessionId);\r\n\r\n    if(sessObs) {\r\n      sessObs.subscribe({\r\n        next:(sess) => {\r\n          this.ar.statusAlertType='info';\r\n          this.ar.statusMsg = 'Received session info.';\r\n          this.ar.statusWaiting=false;\r\n          this.session=sess;\r\n          this.ar.session=sess;\r\n          if (sess.project) {\r\n            //console.debug(\"Session associated project: \"+sess.project)\r\n            this.projectService.projectObservable(sess.project).subscribe({\r\n              next:(project)=>{\r\n              this.ar.project=project;\r\n              this.ar.fetchRecordings(sess);\r\n            },error:(reason) =>{\r\n              this.ar.statusMsg=reason;\r\n              this.ar.statusAlertType='error';\r\n              this.ar.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        error:(reason) => {\r\n          this.ar.statusMsg = reason;\r\n          this.ar.statusAlertType = 'error';\r\n          this.ar.statusWaiting=false;\r\n          console.error(\"Error fetching session \" + reason)\r\n        }});\r\n    }\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.ar.uploadStatus = 'warn'\r\n    } else {\r\n      if (percentUpl < 50) {\r\n        this.ar.uploadStatus = 'accent'\r\n      } else {\r\n        this.ar.uploadStatus = 'success'\r\n      }\r\n      this.ar.uploadProgress = percentUpl;\r\n    }\r\n    this.ar.updateWakeLock(this.dataSaved);\r\n    this.changeDetectorRef.detectChanges()\r\n  }\r\n\r\n\r\n  ready():boolean{\r\n    return this.dataSaved && !this.ar.isActive()\r\n  }\r\n\r\n}\r\n"]}