@sumaris-net/ngx-components 1.2.7 → 1.2.14

package/esm2020/src/app/shared/alerts.mjs

@@ -0,0 +1,238 @@
+export class Alerts {
+    /**
+     * Ask the user to save before leaving. If return undefined: user has cancelled
+     *
+     * @param alertCtrl
+     * @param translate
+     * @param event
+     * @deprecated prefer ComponentDirtyGuard
+     */
+    static async askSaveBeforeLeave(alertCtrl, translate, event) {
+        let confirm = false;
+        let cancel = false;
+        const translations = translate.instant(['COMMON.BTN_SAVE', 'COMMON.BTN_CANCEL', 'COMMON.BTN_ABORT_CHANGES', 'CONFIRM.SAVE', 'CONFIRM.ALERT_HEADER']);
+        const alert = await alertCtrl.create({
+            header: translations['CONFIRM.ALERT_HEADER'],
+            message: translations['CONFIRM.SAVE'],
+            buttons: [
+                {
+                    text: translations['COMMON.BTN_CANCEL'],
+                    role: 'cancel',
+                    cssClass: 'secondary',
+                    handler: () => {
+                        cancel = true;
+                    }
+                },
+                {
+                    text: translations['COMMON.BTN_ABORT_CHANGES'],
+                    cssClass: 'secondary',
+                    handler: () => {
+                    }
+                },
+                {
+                    text: translations['COMMON.BTN_SAVE'],
+                    handler: () => {
+                        confirm = true; // update upper value
+                    }
+                }
+            ]
+        });
+        await alert.present();
+        await alert.onDidDismiss();
+        if (confirm)
+            return true; // = Do save and leave
+        if (cancel) {
+            // Stop the event
+            if (event)
+                event.preventDefault();
+            return undefined; // User cancelled
+        }
+        return false; // Leave without saving
+    }
+    /**
+     * Ask the user to conform an action. If return undefined: user has cancelled
+     *
+     * @param alertCtrl
+     * @param translate
+     * @param immediate is action has an immediate effect ?
+     * @param event
+     * @param interpolateParams
+     */
+    static async askActionConfirmation(alertCtrl, translate, immediate, event, interpolateParams) {
+        const messageKey = immediate === true ? 'CONFIRM.ACTION_IMMEDIATE' : 'CONFIRM.ACTION';
+        return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams);
+    }
+    /**
+     * Ask the user to confirm. If return undefined: user has cancelled
+     *
+     * @pram messageKey i18n message key
+     * @param messageKey
+     * @param alertCtrl
+     * @param translate
+     * @param event
+     * @param interpolateParams
+     */
+    static async askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams) {
+        if (!alertCtrl || !translate)
+            throw new Error('Missing required argument \'alertCtrl\' or \'translate\'');
+        let confirm = false;
+        let cancel = false;
+        const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], interpolateParams);
+        const alert = await alertCtrl.create({
+            header: translations['CONFIRM.ALERT_HEADER'],
+            message: translations[messageKey],
+            buttons: [
+                {
+                    text: translations['COMMON.BTN_CANCEL'],
+                    role: 'cancel',
+                    cssClass: 'secondary',
+                    handler: () => {
+                        cancel = true;
+                    }
+                },
+                {
+                    text: translations['COMMON.BTN_YES_CONTINUE'],
+                    handler: () => {
+                        confirm = true; // update upper value
+                    }
+                }
+            ]
+        });
+        await alert.present();
+        await alert.onDidDismiss();
+        if (confirm)
+            return true; // = Do save and leave
+        if (cancel) {
+            // Stop the event
+            if (event)
+                event.preventDefault();
+            return undefined; // User cancelled
+        }
+        return false; // Leave without saving
+    }
+    /**
+     * Ask the user to save before leaving. If return undefined: user has cancelled
+     *
+     * @param alertCtrl
+     * @param translate
+     * @param event
+     * @param interpolateParams
+     */
+    static async askDeleteConfirmation(alertCtrl, translate, event, interpolateParams) {
+        let confirm = false;
+        let cancel = false;
+        const translations = translate.instant(['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'], interpolateParams);
+        const alert = await alertCtrl.create({
+            header: translations['CONFIRM.ALERT_HEADER'],
+            message: translations['CONFIRM.DELETE'],
+            buttons: [
+                {
+                    text: translations['COMMON.BTN_CANCEL'],
+                    role: 'cancel',
+                    cssClass: 'secondary',
+                    handler: () => {
+                        cancel = true;
+                    }
+                },
+                {
+                    text: translations['COMMON.BTN_YES_DELETE'],
+                    handler: () => {
+                        confirm = true; // update upper value
+                    }
+                }
+            ]
+        });
+        await alert.present();
+        await alert.onDidDismiss();
+        if (confirm)
+            return true; // = Do save and leave
+        if (cancel) {
+            // Stop the event
+            if (event)
+                event.preventDefault();
+            return undefined; // User cancelled
+        }
+        return false; // Leave without saving
+    }
+    static async askSaveBeforeAction(alertCtrl, translate, event, interpolateParams) {
+        let save = false;
+        let confirm = false;
+        let alert;
+        // Ask user before save
+        if (event && event.valid) {
+            const translations = translate.instant(['COMMON.BTN_CANCEL', 'COMMON.BTN_SAVE', 'COMMON.BTN_ABORT_CHANGES',
+                'CONFIRM.SAVE_BEFORE_CONTINUE', 'CONFIRM.ALERT_HEADER'], interpolateParams);
+            alert = await alertCtrl.create({
+                header: translations['CONFIRM.ALERT_HEADER'],
+                message: translations['CONFIRM.SAVE_BEFORE_CONTINUE'],
+                buttons: [
+                    {
+                        text: translations['COMMON.BTN_CANCEL'],
+                        role: 'cancel',
+                        cssClass: 'secondary',
+                        handler: () => {
+                        }
+                    },
+                    {
+                        text: translations['COMMON.BTN_ABORT_CHANGES'],
+                        cssClass: 'secondary',
+                        handler: () => {
+                            confirm = true;
+                        }
+                    },
+                    {
+                        text: translations['COMMON.BTN_SAVE'],
+                        handler: () => {
+                            save = true;
+                            confirm = true;
+                        }
+                    }
+                ]
+            });
+        }
+        else {
+            const translations = translate.instant(['COMMON.BTN_ABORT_CHANGES', 'COMMON.BTN_CANCEL', 'CONFIRM.CANCEL_CHANGES', 'CONFIRM.ALERT_HEADER'], interpolateParams);
+            alert = await alertCtrl.create({
+                header: translations['CONFIRM.ALERT_HEADER'],
+                message: translations['CONFIRM.CANCEL_CHANGES'],
+                buttons: [
+                    {
+                        text: translations['COMMON.BTN_ABORT_CHANGES'],
+                        cssClass: 'secondary',
+                        handler: () => {
+                            confirm = true;
+                        }
+                    },
+                    {
+                        text: translations['COMMON.BTN_CANCEL'],
+                        role: 'cancel',
+                        handler: () => {
+                        }
+                    }
+                ]
+            });
+        }
+        await alert.present();
+        await alert.onDidDismiss();
+        return { confirmed: confirm, save };
+    }
+    static async showError(messageKey, alertCtrl, translate, opts, interpolateParams) {
+        if (!messageKey || !alertCtrl || !translate)
+            throw new Error('Missing a required argument (\'messageKey\', \'alertCtrl\' or \'translate\')');
+        const titleKey = opts && opts.titleKey || 'ERROR.ALERT_HEADER';
+        const translations = translate.instant(['COMMON.BTN_OK', messageKey, titleKey], interpolateParams);
+        const alert = await alertCtrl.create({
+            header: translations[titleKey],
+            message: translations[messageKey],
+            buttons: [
+                {
+                    text: translations['COMMON.BTN_OK'],
+                    role: 'cancel'
+                }
+            ]
+        });
+        await alert.present();
+        await alert.onDidDismiss();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alerts.js","sourceRoot":"","sources":["../../../../../src/app/shared/alerts.ts"],"names":[],"mappings":"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","sourcesContent":["import { AlertController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\n\nexport class Alerts {\n\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @deprecated prefer ComponentDirtyGuard\n   */\n  static async askSaveBeforeLeave(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event): Promise<boolean|undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_SAVE', 'COMMON.BTN_CANCEL', 'COMMON.BTN_ABORT_CHANGES', 'CONFIRM.SAVE', 'CONFIRM.ALERT_HEADER']);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.SAVE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          }\n        },\n        {\n          text: translations['COMMON.BTN_ABORT_CHANGES'],\n          cssClass: 'secondary',\n          handler: () => {\n          }\n        },\n        {\n          text: translations['COMMON.BTN_SAVE'],\n          handler: () => {\n            confirm = true; // update upper value\n          }\n        }\n      ]\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  /**\n   * Ask the user to conform an action. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param immediate is action has an immediate effect ?\n   * @param event\n   * @param interpolateParams\n   */\n  static async askActionConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    immediate?: boolean,\n    event?: Event,\n    interpolateParams?: any): Promise<boolean|undefined> {\n    const messageKey = immediate === true ? 'CONFIRM.ACTION_IMMEDIATE' : 'CONFIRM.ACTION';\n    return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams);\n  }\n\n\n\n  /**\n   * Ask the user to confirm. If return undefined: user has cancelled\n   *\n   * @pram messageKey i18n message key\n   * @param messageKey\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   */\n  static async askConfirmation(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    interpolateParams?: any): Promise<boolean|undefined> {\n    if (!alertCtrl || !translate) throw new Error('Missing required argument \\'alertCtrl\\' or \\'translate\\'');\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          }\n        },\n        {\n          text: translations['COMMON.BTN_YES_CONTINUE'],\n          handler: () => {\n            confirm = true; // update upper value\n          }\n        }\n      ]\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   */\n  static async askDeleteConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    interpolateParams?: any): Promise<boolean|undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.DELETE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          }\n        },\n        {\n          text: translations['COMMON.BTN_YES_DELETE'],\n          handler: () => {\n            confirm = true; // update upper value\n          }\n        }\n      ]\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n\n  static async askSaveBeforeAction(alertCtrl: AlertController,\n                                   translate: TranslateService,\n                                   event?: { valid: boolean },\n                                   interpolateParams?: any): Promise<{ confirmed: boolean; save: boolean } | undefined> {\n\n    let save = false;\n    let confirm = false;\n    let alert: HTMLIonAlertElement;\n\n    // Ask user before save\n    if (event && event.valid) {\n      const translations = translate.instant(['COMMON.BTN_CANCEL', 'COMMON.BTN_SAVE', 'COMMON.BTN_ABORT_CHANGES',\n        'CONFIRM.SAVE_BEFORE_CONTINUE', 'CONFIRM.ALERT_HEADER'], interpolateParams);\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations['CONFIRM.SAVE_BEFORE_CONTINUE'],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            cssClass: 'secondary',\n            handler: () => {\n            }\n          },\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirm = true;\n            }\n          },\n          {\n            text: translations['COMMON.BTN_SAVE'],\n            handler: () => {\n              save = true;\n              confirm = true;\n            }\n          }\n        ]\n      });\n    } else {\n      const translations = translate.instant(['COMMON.BTN_ABORT_CHANGES', 'COMMON.BTN_CANCEL', 'CONFIRM.CANCEL_CHANGES', 'CONFIRM.ALERT_HEADER'], interpolateParams);\n\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations['CONFIRM.CANCEL_CHANGES'],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirm = true;\n            }\n          },\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            handler: () => {\n            }\n          }\n        ]\n      });\n    }\n\n    await alert.present();\n    await alert.onDidDismiss();\n\n    return {confirmed: confirm, save};\n  }\n\n  static async showError(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService, opts?: {\n      titleKey?: string;\n    },\n    interpolateParams?: any) {\n    if (!messageKey || !alertCtrl || !translate) throw new Error('Missing a required argument (\\'messageKey\\', \\'alertCtrl\\' or \\'translate\\')');\n    const titleKey = opts && opts.titleKey || 'ERROR.ALERT_HEADER';\n    const translations = translate.instant(['COMMON.BTN_OK', messageKey, titleKey], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations[titleKey],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_OK'],\n          role: 'cancel'\n        }\n      ]\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n  }\n\n\n}\n\n\n\n\n"]}

package/esm2020/src/app/shared/audio/audio.mjs

@@ -0,0 +1,201 @@
+import { Injectable, Optional } from '@angular/core';
+import { AudioManagement } from '@ionic-native/audio-management/ngx';
+import { isNil, sleep, toBoolean } from '../functions';
+import { StartableService } from '../services/startable-service.class';
+import { Haptics } from '@capacitor/haptics';
+import { NativeAudio } from '@capacitor-community/native-audio';
+import { Capacitor } from '@capacitor/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@ionic-native/audio-management/ngx";
+const SYSTEM_SOUNDS = [
+    { assetId: 'startup', assetPath: 'assets/audio/unfa-ping.mp3', vibration: [300, 250, 750] },
+    { assetId: 'beep-confirm', assetPath: 'assets/audio/beep-confirm.mp3', vibration: 250 },
+    { assetId: 'beep-error', assetPath: 'assets/audio/beep-error.mp3', vibration: 1000 },
+    { assetId: 'beep-notification', assetPath: 'assets/audio/beep-notification.mp3', vibration: [450, 150, 450] }
+];
+export class AudioProvider extends StartableService {
+    constructor(platform, audioManagement) {
+        super(platform);
+        this.platform = platform;
+        this.audioManagement = audioManagement;
+        this._audioMode = AudioManagement.AudioMode.NORMAL;
+        this._assetPathPrefix = '';
+        this._preloadedSounds = {};
+        this._htmlAudioCache = {};
+        this.start();
+    }
+    async ngOnStart() {
+        const cordova = this.platform.is('cordova');
+        this._assetPathPrefix = cordova ? 'public/' : '';
+        this._audioType = cordova && Capacitor.isPluginAvailable('NativeAudio') ? 'native' : 'html5';
+        console.info(`[audio] Starting audio provider {${this._audioType}}...`);
+        // Listen audio mode changed
+        if (this.platform.is('cordova') && this.audioManagement) {
+            await this.readAudioMode();
+        }
+        // Pre-loading system sounds
+        console.debug('[audio] Preloading audio sounds...');
+        await Promise.all(SYSTEM_SOUNDS.map(s => {
+            // Disable vibration in HTML 5 mode
+            if (this._audioType === 'html5')
+                s.vibration = undefined;
+            return this.preload(s);
+        }));
+    }
+    playBeepConfirm() {
+        return this.play('beep-confirm', {
+            // Vibrate only if in vibration mode
+            vibrate: this._audioMode === AudioManagement.AudioMode.VIBRATE
+        });
+    }
+    playBeepError() {
+        return this.play('beep-error', {
+            // Always vibrate (will skip vibration if silent mode)
+            vibrate: true
+        });
+    }
+    async playBeepNotification() {
+        await this.play('beep-notification', {
+            vibrate: this._audioMode === AudioManagement.AudioMode.VIBRATE
+        });
+    }
+    async playStartupSound() {
+        return this.play('startup');
+    }
+    async preload(sound) {
+        if (isNil(this._audioType))
+            await this.ready();
+        const assetPath = (this._assetPathPrefix || '') + sound.assetPath;
+        console.info(`[audio] Preloading audio file '${assetPath}'...`);
+        try {
+            if (this._audioType === 'native') {
+                await NativeAudio.preload({
+                    audioChannelNum: 1,
+                    isUrl: false,
+                    ...sound,
+                    assetPath
+                });
+            }
+            else {
+                this._htmlAudioCache[sound.assetId] = new Audio(assetPath);
+            }
+            // Add to map
+            this._preloadedSounds[sound.assetId] = sound;
+            console.info(`[audio] Preloading audio file '${assetPath}' [OK]`);
+        }
+        catch (err) {
+            console.error(`[audio] Unable to preload audio file '${assetPath}': ${err && err.message || err}\n${err?.originalStack}`);
+        }
+    }
+    async play(assetId, opts) {
+        // Make sure provider is ready
+        if (!this.started)
+            await this.ready();
+        const sound = this._preloadedSounds[assetId];
+        if (!sound) {
+            throw Error(`Unable to find audio with id '${assetId}'. Please call preload() before playing a sound.`);
+        }
+        // If silent: skip
+        if (this._audioMode === AudioManagement.AudioMode.SILENT)
+            return;
+        const promises = [];
+        // Normal mode = can play the sound
+        if (this._audioMode === AudioManagement.AudioMode.NORMAL) {
+            // Use native audio
+            if (this._audioType === 'native') {
+                promises.push(NativeAudio.play({
+                    assetId: sound.assetId,
+                    time: (sound.time || 0)
+                }));
+            }
+            // Or HTML 5 audio
+            else {
+                const audio = this._htmlAudioCache[assetId] || new Audio(sound.assetPath);
+                promises.push(audio.play());
+            }
+        }
+        // Vibrate mode: by default make vibration is enable
+        else if (isNil(sound.vibration) && isNil(opts && opts.vibrate)) {
+            opts = opts || {};
+            opts.vibrate = true;
+        }
+        // Do vibration (if sound as default vibration, or if user ask for it)
+        if (toBoolean(opts?.vibrate, !!sound.vibration)) {
+            promises.push(this.vibrate(opts && opts.vibration || sound.vibration));
+        }
+        return (promises.length === 1 ? promises[0] : Promise.all(promises))
+            .catch(err => {
+            console.error(`[audio] Error while playing audio sound '${assetId}': ${err && err.message || err}`, err);
+        });
+    }
+    async unload(assetId) {
+        if (isNil(this._audioType))
+            await this.ready();
+        // Remove from map
+        this._preloadedSounds[assetId] = undefined;
+        // Native unload
+        if (this._audioType === 'native') {
+            try {
+                await NativeAudio.unload({ assetId });
+            }
+            catch (err) {
+                console.error(`[audio] Unable to unload audio '${assetId}': ${err && err.message || err}`, err);
+            }
+        }
+        // HTML5 audio unload
+        else {
+            this._htmlAudioCache[assetId].remove();
+            this._htmlAudioCache[assetId] = undefined;
+        }
+    }
+    /**
+     *
+     * @param duration Duration of the vibration in milliseconds.
+     */
+    async vibrate(duration) {
+        if (!this.started)
+            await this.ready();
+        if (Array.isArray(duration)) {
+            if (this._debug)
+                console.debug("[audio] Vibrate: " + JSON.stringify(duration));
+            for (let i = 0; i < duration.length; i++) {
+                const time = duration[i];
+                const silent = i % 2 !== 0;
+                if (silent) {
+                    if (this._debug)
+                        console.debug("[audio] silent during " + time);
+                    await sleep(time);
+                }
+                else {
+                    if (this._debug)
+                        console.debug("[audio] vibrate during " + time);
+                    await Promise.all([
+                        Haptics.vibrate({ duration: time }),
+                        sleep(time)
+                    ]);
+                }
+            }
+        }
+        else {
+            if (this._debug)
+                console.debug("[audio] vibrate during " + duration);
+            await Haptics.vibrate({ duration });
+        }
+    }
+    /* -- protected methods  -- */
+    async readAudioMode() {
+        const value = await this.audioManagement.getAudioMode();
+        this._audioMode = value && value.audioMode || AudioManagement.AudioMode.NORMAL;
+        console.debug(`[audio] Detected device audio mode {${value.label}} (${this._audioMode})`);
+    }
+}
+AudioProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioProvider, deps: [{ token: i1.Platform }, { token: i2.AudioManagement, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AudioProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.AudioManagement, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audio.js","sourceRoot":"","sources":["../../../../../../src/app/shared/audio/audio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAC,eAAe,EAAC,MAAM,oCAAoC,CAAC;AACnE,OAAO,EAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;;;;AAa1C,MAAM,aAAa,GAAY;IAC7B,EAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,4BAA4B,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAC;IACzF,EAAC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,+BAA+B,EAAE,SAAS,EAAE,GAAG,EAAC;IACrF,EAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,6BAA6B,EAAE,SAAS,EAAE,IAAI,EAAC;IAClF,EAAC,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,oCAAoC,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAC;CAC5G,CAAC;AAGF,MAAM,OAAO,aAAc,SAAQ,gBAAsB;IASvD,YACY,QAAkB,EACR,eAAgC;QAEpD,KAAK,CAAC,QAAQ,CAAC,CAAC;QAHN,aAAQ,GAAR,QAAQ,CAAU;QACR,oBAAe,GAAf,eAAe,CAAiB;QAR9C,eAAU,GAA8B,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC;QACzE,qBAAgB,GAAG,EAAE,CAAC;QAEtB,qBAAgB,GAA0B,EAAE,CAAC;QAC7C,oBAAe,GAAqC,EAAE,CAAC;QAQ7D,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAES,KAAK,CAAC,SAAS;QAEvB,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,OAAO,IAAI,SAAS,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;QAC7F,OAAO,CAAC,IAAI,CAAC,oCAAoC,IAAI,CAAC,UAAU,MAAM,CAAC,CAAC;QAExE,4BAA4B;QAC5B,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,eAAe,EAAE;YACvD,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;SAC5B;QAED,4BAA4B;QAC5B,OAAO,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACpD,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YACtC,mCAAmC;YACnC,IAAI,IAAI,CAAC,UAAU,KAAK,OAAO;gBAAE,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC;YACzD,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YAC/B,oCAAoC;YACpC,OAAO,EAAE,IAAI,CAAC,UAAU,KAAK,eAAe,CAAC,SAAS,CAAC,OAAO;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YAC7B,sDAAsD;YACtD,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,oBAAoB;QACxB,MAAM,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAC;YAClC,OAAO,EAAE,IAAI,CAAC,UAAU,KAAK,eAAe,CAAC,SAAS,CAAC,OAAO;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC;IAGD,KAAK,CAAC,OAAO,CAAC,KAAY;QACxB,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QAE/C,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;QAClE,OAAO,CAAC,IAAI,CAAC,kCAAkC,SAAS,MAAM,CAAC,CAAC;QAEhE,IAAI;YACF,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE;gBAChC,MAAM,WAAW,CAAC,OAAO,CAAC;oBACxB,eAAe,EAAE,CAAC;oBAClB,KAAK,EAAE,KAAK;oBACZ,GAAG,KAAK;oBACR,SAAS;iBACV,CAAC,CAAC;aACJ;iBACI;gBACH,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,GAAI,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;aAC7D;YAED,aAAa;YACb,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;YAC7C,OAAO,CAAC,IAAI,CAAC,kCAAkC,SAAS,QAAQ,CAAC,CAAC;SACnE;QACD,OAAO,GAAG,EAAE;YACV,OAAO,CAAC,KAAK,CAAC,yCAAyC,SAAS,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,KAAK,GAAG,EAAE,aAAa,EAAE,CAAC,CAAC;SAC3H;IACH,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,OAAe,EAAE,IAAuD;QAEjF,8BAA8B;QAC9B,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QAEtC,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,EAAE;YACV,MAAM,KAAK,CAAC,iCAAiC,OAAO,kDAAkD,CAAC,CAAC;SACzG;QAED,kBAAkB;QAClB,IAAI,IAAI,CAAC,UAAU,KAAK,eAAe,CAAC,SAAS,CAAC,MAAM;YAAE,OAAO;QAEjE,MAAM,QAAQ,GAAmB,EAAE,CAAC;QAEpC,mCAAmC;QACnC,IAAI,IAAI,CAAC,UAAU,KAAK,eAAe,CAAC,SAAS,CAAC,MAAM,EAAE;YACxD,mBAAmB;YACnB,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE;gBAChC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;oBAC7B,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC;iBACxB,CAAC,CAAC,CAAC;aACL;YACD,kBAAkB;iBACb;gBACH,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC1E,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;aAC7B;SACF;QAED,oDAAoD;aAC/C,IAAI,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,EAAE;YAC9D,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;YAClB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;SACrB;QAED,sEAAsE;QACtE,IAAI,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;YAC/C,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;SACxE;QAED,OAAO,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;aACjE,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,OAAO,CAAC,KAAK,CAAC,4CAA4C,OAAO,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC;QAC3G,CAAC,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,OAAe;QAC1B,IAAI,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QAE/C,kBAAkB;QAClB,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;QAE3C,gBAAgB;QAChB,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,EAAE;YAChC,IAAI;gBACF,MAAM,WAAW,CAAC,MAAM,CAAC,EAAC,OAAO,EAAC,CAAC,CAAC;aACrC;YACD,OAAO,GAAG,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,mCAAmC,OAAO,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC;aACjG;SACF;QACD,qBAAqB;aAChB;YACH,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;SAC3C;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,QAA0B;QACtC,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACtC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC3B,IAAI,IAAI,CAAC,MAAM;gBAAE,OAAO,CAAC,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC/E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACxC,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACzB,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAC3B,IAAI,MAAM,EAAE;oBACV,IAAI,IAAI,CAAC,MAAM;wBAAE,OAAO,CAAC,KAAK,CAAC,wBAAwB,GAAG,IAAI,CAAC,CAAC;oBAChE,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC;iBACnB;qBACI;oBACH,IAAI,IAAI,CAAC,MAAM;wBAAE,OAAO,CAAC,KAAK,CAAC,yBAAyB,GAAG,IAAI,CAAC,CAAC;oBACjE,MAAM,OAAO,CAAC,GAAG,CAAC;wBAChB,OAAO,CAAC,OAAO,CAAC,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC;wBACjC,KAAK,CAAC,IAAI,CAAC;qBACZ,CAAC,CAAC;iBACJ;aACF;SACF;aACI;YACH,IAAI,IAAI,CAAC,MAAM;gBAAE,OAAO,CAAC,KAAK,CAAC,yBAAyB,GAAG,QAAQ,CAAC,CAAC;YACrE,MAAM,OAAO,CAAC,OAAO,CAAC,EAAC,QAAQ,EAAC,CAAC,CAAC;SACnC;IACH,CAAC;IAED,8BAA8B;IAEpB,KAAK,CAAC,aAAa;QAC3B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;QACxD,IAAI,CAAC,UAAU,GAAG,KAAK,IAAI,KAAK,CAAC,SAAS,IAAI,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC;QAC/E,OAAO,CAAC,KAAK,CAAC,uCAAuC,KAAK,CAAC,KAAK,MAAM,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;IAC5F,CAAC;;2GAtMU,aAAa;+GAAb,aAAa,cADD,MAAM;4FAClB,aAAa;kBADzB,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;0BAY3B,QAAQ","sourcesContent":["import {Injectable, Optional} from '@angular/core';\nimport {Platform} from '@ionic/angular';\nimport {AudioManagement} from '@ionic-native/audio-management/ngx';\nimport {isNil, sleep, toBoolean} from '../functions';\nimport {StartableService} from '../services/startable-service.class';\nimport {Haptics} from '@capacitor/haptics';\nimport {NativeAudio} from '@capacitor-community/native-audio';\nimport {Capacitor} from '@capacitor/core';\n\nexport type AudioType = 'html5' | 'native';\nexport interface Sound {\n  assetId: string; // unique identifier of the file\n  assetPath: string; //  relative path of the file or absolute url (file://)\n  volume?: number; // Sound volume\n  isUrl?: boolean; // pass true if assetPath is a `file://` url\n  time?: number; // sound seek time\n  audioChannelNum?: number; // number of audio channels\n  vibration?: number|number[]; // Should vibrate ? set duration\n}\n\nconst SYSTEM_SOUNDS: Sound[] = [\n  {assetId: 'startup', assetPath: 'assets/audio/unfa-ping.mp3', vibration: [300, 250, 750]},\n  {assetId: 'beep-confirm', assetPath: 'assets/audio/beep-confirm.mp3', vibration: 250},\n  {assetId: 'beep-error', assetPath: 'assets/audio/beep-error.mp3', vibration: 1000},\n  {assetId: 'beep-notification', assetPath: 'assets/audio/beep-notification.mp3', vibration: [450, 150, 450]}\n];\n\n@Injectable({providedIn: 'root'})\nexport class AudioProvider extends StartableService<void> {\n\n  private _audioType: AudioType;\n  private _audioMode: AudioManagement.AudioMode = AudioManagement.AudioMode.NORMAL;\n  private _assetPathPrefix = '';\n\n  private _preloadedSounds: {[id: string]: Sound} = {};\n  private _htmlAudioCache: {[id: string]: HTMLAudioElement} = {};\n\n  constructor(\n    protected platform: Platform,\n    @Optional() private audioManagement: AudioManagement\n  ) {\n    super(platform);\n\n    this.start();\n  }\n\n  protected async ngOnStart(): Promise<void> {\n\n    const cordova = this.platform.is('cordova');\n    this._assetPathPrefix = cordova ? 'public/' : '';\n    this._audioType = cordova && Capacitor.isPluginAvailable('NativeAudio') ? 'native' : 'html5';\n    console.info(`[audio] Starting audio provider {${this._audioType}}...`);\n\n    // Listen audio mode changed\n    if (this.platform.is('cordova') && this.audioManagement) {\n      await this.readAudioMode();\n    }\n\n    // Pre-loading system sounds\n    console.debug('[audio] Preloading audio sounds...');\n    await Promise.all(SYSTEM_SOUNDS.map(s => {\n      // Disable vibration in HTML 5 mode\n      if (this._audioType === 'html5') s.vibration = undefined;\n      return this.preload(s);\n    }));\n  }\n\n  playBeepConfirm(): Promise<any> {\n    return this.play('beep-confirm', {\n      // Vibrate only if in vibration mode\n      vibrate: this._audioMode === AudioManagement.AudioMode.VIBRATE\n    });\n  }\n\n  playBeepError(): Promise<any> {\n    return this.play('beep-error', {\n      // Always vibrate (will skip vibration if silent mode)\n      vibrate: true\n    });\n  }\n\n  async playBeepNotification(): Promise<any> {\n    await this.play('beep-notification',{\n      vibrate: this._audioMode === AudioManagement.AudioMode.VIBRATE\n    });\n  }\n\n  async playStartupSound(): Promise<any> {\n    return this.play('startup');\n  }\n\n\n  async preload(sound: Sound) {\n    if (isNil(this._audioType)) await this.ready();\n\n    const assetPath = (this._assetPathPrefix || '') + sound.assetPath;\n    console.info(`[audio] Preloading audio file '${assetPath}'...`);\n\n    try {\n      if (this._audioType === 'native') {\n        await NativeAudio.preload({\n          audioChannelNum: 1,\n          isUrl: false,\n          ...sound,\n          assetPath\n        });\n      }\n      else {\n        this._htmlAudioCache[sound.assetId] =  new Audio(assetPath);\n      }\n\n      // Add to map\n      this._preloadedSounds[sound.assetId] = sound;\n      console.info(`[audio] Preloading audio file '${assetPath}' [OK]`);\n    }\n    catch (err) {\n      console.error(`[audio] Unable to preload audio file '${assetPath}': ${err && err.message || err}\\n${err?.originalStack}`);\n    }\n  }\n\n  async play(assetId: string, opts?: {vibrate?: boolean; vibration?: number|number[]}) {\n\n    // Make sure provider is ready\n    if (!this.started) await this.ready();\n\n    const sound = this._preloadedSounds[assetId];\n    if (!sound) {\n      throw Error(`Unable to find audio with id '${assetId}'. Please call preload() before playing a sound.`);\n    }\n\n    // If silent: skip\n    if (this._audioMode === AudioManagement.AudioMode.SILENT) return;\n\n    const promises: Promise<any>[] = [];\n\n    // Normal mode = can play the sound\n    if (this._audioMode === AudioManagement.AudioMode.NORMAL) {\n      // Use native audio\n      if (this._audioType === 'native') {\n        promises.push(NativeAudio.play({\n          assetId: sound.assetId,\n          time: (sound.time || 0)\n        }));\n      }\n      // Or HTML 5 audio\n      else {\n        const audio = this._htmlAudioCache[assetId] || new Audio(sound.assetPath);\n        promises.push(audio.play());\n      }\n    }\n\n    // Vibrate mode: by default make vibration is enable\n    else if (isNil(sound.vibration) && isNil(opts && opts.vibrate)) {\n      opts = opts || {};\n      opts.vibrate = true;\n    }\n\n    // Do vibration (if sound as default vibration, or if user ask for it)\n    if (toBoolean(opts?.vibrate, !!sound.vibration)) {\n      promises.push(this.vibrate(opts && opts.vibration || sound.vibration));\n    }\n\n    return (promises.length === 1 ? promises[0] : Promise.all(promises))\n      .catch(err => {\n        console.error(`[audio] Error while playing audio sound '${assetId}': ${err && err.message || err}`, err);\n      });\n  }\n\n  async unload(assetId: string) {\n    if (isNil(this._audioType)) await this.ready();\n\n    // Remove from map\n    this._preloadedSounds[assetId] = undefined;\n\n    // Native unload\n    if (this._audioType === 'native') {\n      try {\n        await NativeAudio.unload({assetId});\n      }\n      catch (err) {\n        console.error(`[audio] Unable to unload audio '${assetId}': ${err && err.message || err}`, err);\n      }\n    }\n    // HTML5 audio unload\n    else {\n      this._htmlAudioCache[assetId].remove();\n      this._htmlAudioCache[assetId] = undefined;\n    }\n  }\n\n  /**\n   *\n   * @param duration Duration of the vibration in milliseconds.\n   */\n  async vibrate(duration?: number|number[]) {\n    if (!this.started) await this.ready();\n    if (Array.isArray(duration)) {\n      if (this._debug) console.debug(\"[audio] Vibrate: \" + JSON.stringify(duration));\n      for (let i = 0; i < duration.length; i++) {\n        const time = duration[i];\n        const silent = i % 2 !== 0;\n        if (silent) {\n          if (this._debug) console.debug(\"[audio] silent during \" + time);\n          await sleep(time);\n        }\n        else {\n          if (this._debug) console.debug(\"[audio] vibrate during \" + time);\n          await Promise.all([\n            Haptics.vibrate({duration: time}),\n            sleep(time)\n          ]);\n        }\n      }\n    }\n    else {\n      if (this._debug) console.debug(\"[audio] vibrate during \" + duration);\n      await Haptics.vibrate({duration});\n    }\n  }\n\n  /* -- protected methods  -- */\n\n  protected async readAudioMode() {\n    const value = await this.audioManagement.getAudioMode();\n    this._audioMode = value && value.audioMode || AudioManagement.AudioMode.NORMAL;\n    console.debug(`[audio] Detected device audio mode {${value.label}} (${this._audioMode})`);\n  }\n\n}\n"]}

package/esm2020/src/app/shared/audio/audio.testing.mjs

@@ -0,0 +1,31 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./audio";
+import * as i2 from "@ionic/angular";
+export class AudioTestingPage {
+    constructor(audio) {
+        this.audio = audio;
+    }
+    playBeepConfirm() {
+        return this.audio.playBeepConfirm();
+    }
+    playBeepError() {
+        return this.audio.playBeepError();
+    }
+    playStartupSound() {
+        return this.audio.playStartupSound();
+    }
+    playBeepNotification() {
+        return this.audio.playBeepNotification();
+    }
+    vibrate(duration) {
+        return this.audio.vibrate(duration || [1000, 500, 1000, 500, 1000]);
+    }
+}
+AudioTestingPage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingPage, deps: [{ token: i1.AudioProvider }], target: i0.ɵɵFactoryTarget.Component });
+AudioTestingPage.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: AudioTestingPage, selector: "audio-testing", ngImport: i0, template: "<ion-toolbar color=\"primary\">\n  <ion-title>Toasts</ion-title>\n</ion-toolbar>\n\n<ion-content class=\"ion-padding\">\n\n  <p>Toast examples:</p>\n\n  <ion-button (click)=\"playStartupSound()\" color=\"dark\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Startup\n  </ion-button>\n\n  <ion-button (click)=\"playBeepConfirm()\" color=\"success\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Confirmation\n  </ion-button>\n\n  <ion-button (click)=\"playBeepNotification()\" color=\"tertiary\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Notification\n  </ion-button>\n\n  <ion-button (click)=\"playBeepError()\" color=\"accent\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Error\n  </ion-button>\n\n  <ion-button (click)=\"vibrate()\" color=\"accent\">\n    Vibrate (many time)\n  </ion-button>\n\n</ion-content>\n", dependencies: [{ kind: "component", type: i2.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i2.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i2.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i2.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i2.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'audio-testing', template: "<ion-toolbar color=\"primary\">\n  <ion-title>Toasts</ion-title>\n</ion-toolbar>\n\n<ion-content class=\"ion-padding\">\n\n  <p>Toast examples:</p>\n\n  <ion-button (click)=\"playStartupSound()\" color=\"dark\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Startup\n  </ion-button>\n\n  <ion-button (click)=\"playBeepConfirm()\" color=\"success\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Confirmation\n  </ion-button>\n\n  <ion-button (click)=\"playBeepNotification()\" color=\"tertiary\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Notification\n  </ion-button>\n\n  <ion-button (click)=\"playBeepError()\" color=\"accent\">\n    <ion-icon name=\"play\" slot=\"start\"></ion-icon>\n    Error\n  </ion-button>\n\n  <ion-button (click)=\"vibrate()\" color=\"accent\">\n    Vibrate (many time)\n  </ion-button>\n\n</ion-content>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.AudioProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/audio/audio.testing.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { IonicModule } from '@ionic/angular';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { AudioTestingPage } from './audio.testing';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/router";
+const routes = [
+    {
+        path: 'audio',
+        pathMatch: 'full',
+        component: AudioTestingPage
+    }
+];
+export class AudioTestingModule {
+}
+AudioTestingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AudioTestingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingModule, declarations: [AudioTestingPage], imports: [CommonModule,
+        IonicModule, i1.TranslateModule, i2.RouterModule], exports: [RouterModule,
+        AudioTestingPage] });
+AudioTestingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingModule, imports: [CommonModule,
+        IonicModule,
+        TranslateModule.forChild(),
+        RouterModule.forChild(routes), RouterModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AudioTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        IonicModule,
+                        TranslateModule.forChild(),
+                        RouterModule.forChild(routes)
+                    ],
+                    declarations: [
+                        AudioTestingPage
+                    ],
+                    exports: [
+                        RouterModule,
+                        AudioTestingPage
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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