@sumaris-net/ngx-components 2.6.26 → 2.7.0-rc10

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

@@ -0,0 +1,239 @@
+export class Alerts {
+    /**
+     * Ask the user to save before leaving. If return undefined: user has cancelled
+     * <p>
+     *   from a routed page, prefer using ComponentDirtyGuard
+     *
+     * @param alertCtrl
+     * @param translate
+     * @param event
+     */
+    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   * <p>\n   *   from a routed page, prefer using ComponentDirtyGuard\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\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/esm2022/src/app/shared/audio/audio.mjs

@@ -0,0 +1,251 @@
+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] }
+];
+const DEFAULT_AUDIO_MODE_RETURN = {
+    audioMode: AudioManagement.AudioMode.NORMAL,
+    label: 'Normal'
+};
+function audioModeToString(mode) {
+    switch (mode) {
+        case AudioManagement.AudioMode.SILENT: return 'Silent';
+        case AudioManagement.AudioMode.NORMAL: return 'Normal';
+        case AudioManagement.AudioMode.VIBRATE: return 'Vibrate';
+    }
+}
+export class AudioProvider extends StartableService {
+    platform;
+    audioManagement;
+    _audioType;
+    _audioMode = AudioManagement.AudioMode.NORMAL;
+    _assetPathPrefix = '';
+    _preloadedSounds = {};
+    _htmlAudioCache = {};
+    constructor(platform, audioManagement) {
+        super(platform);
+        this.platform = platform;
+        this.audioManagement = audioManagement;
+        console.info(`[audio] Create audio provider`);
+    }
+    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 (cordova && this.audioManagement) {
+            await this.readAudioMode();
+        }
+        // Pre-loading system sounds
+        console.debug('[audio] Preloading audio sounds...');
+        let errorCount = 0;
+        await Promise.all(SYSTEM_SOUNDS.map(s => {
+            // Disable vibration in HTML 5 mode
+            if (this._audioType === 'html5')
+                s.vibration = undefined;
+            return this.preload(s)
+                .catch(_ => errorCount++);
+        }));
+        if (errorCount > 0) {
+            console.warn('[audio] Preloading audio sounds [OK] with ${errorCount} errors during preload.');
+        }
+        else {
+            console.debug('[audio] Preloading audio sounds [OK]');
+        }
+    }
+    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 (!sound?.assetId)
+            return; // Skip
+        if (this._preloadedSounds[sound.assetId])
+            return; // Already preloaded
+        if (isNil(this._audioType))
+            await this.ready();
+        const assetPath = (this._assetPathPrefix || '') + sound.assetPath;
+        console.info(`[audio] Preloading sound '${sound.assetId}', from file '${assetPath}'...`);
+        try {
+            if (this._audioType === 'native') {
+                this._preloadedSounds[sound.assetId] = sound;
+                await NativeAudio.preload({
+                    audioChannelNum: 1,
+                    isUrl: false,
+                    ...sound,
+                    assetPath
+                });
+            }
+            else {
+                this._htmlAudioCache[sound.assetId] = new Audio(assetPath);
+                this._preloadedSounds[sound.assetId] = sound;
+            }
+            // Add to map
+            console.info(`[audio] Preloading sound '${sound.assetId}' [OK]`);
+        }
+        catch (err) {
+            const errorMsg = err?.message || err;
+            if (errorMsg === 'Audio Asset already exists') {
+                console.info(`[audio] Preloading sound '${sound.assetId}': Skipped (${errorMsg})`);
+            }
+            else {
+                this._preloadedSounds[sound.assetId] = null;
+                console.error(`[audio] Unable to preload sound '${sound.assetId}', from file '${assetPath}': ${errorMsg}\n${err?.originalStack || ''}`);
+                throw err;
+            }
+        }
+    }
+    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 sound '${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 });
+        }
+    }
+    async setAudioMode(mode) {
+        try {
+            console.info(`[audio] Changing audio mode to {${audioModeToString(mode)}}`);
+            await this.audioManagement.setAudioMode(mode);
+            this._audioMode = mode;
+        }
+        catch (err) {
+            console.error(`[audio] Error while changing audio mode to {${audioModeToString(mode)}}: ${err?.message || err}`, err);
+            // Continue
+        }
+    }
+    /* -- protected methods  -- */
+    async readAudioMode() {
+        let value = await this.audioManagement.getAudioMode();
+        value = {
+            ...DEFAULT_AUDIO_MODE_RETURN,
+            ...value
+        };
+        console.debug(`[audio] Detected audio mode {label: '${value.label}', audioMode: ${value.audioMode}}`);
+        this._audioMode = value.audioMode;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: AudioProvider, deps: [{ token: i1.Platform }, { token: i2.AudioManagement, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: AudioProvider, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: AudioProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ 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":"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","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\nconst DEFAULT_AUDIO_MODE_RETURN: AudioManagement.AudioModeReturn = {\n  audioMode:  AudioManagement.AudioMode.NORMAL,\n  label: 'Normal'\n};\n\nfunction audioModeToString(mode: AudioManagement.AudioMode) {\n  switch (mode) {\n    case AudioManagement.AudioMode.SILENT: return 'Silent';\n    case AudioManagement.AudioMode.NORMAL: return 'Normal';\n    case AudioManagement.AudioMode.VIBRATE: return 'Vibrate';\n  }\n}\n\n@Injectable({providedIn: 'root'})\nexport class AudioProvider extends StartableService<void> {\n\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    console.info(`[audio] Create audio provider`);\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 (cordova && this.audioManagement) {\n      await this.readAudioMode();\n    }\n\n    // Pre-loading system sounds\n    console.debug('[audio] Preloading audio sounds...');\n    let errorCount = 0;\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        .catch(_ => errorCount++);\n    }));\n\n    if (errorCount > 0) {\n      console.warn('[audio] Preloading audio sounds [OK] with ${errorCount} errors during preload.');\n    }\n    else {\n      console.debug('[audio] Preloading audio sounds [OK]');\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 (!sound?.assetId) return; // Skip\n    if (this._preloadedSounds[sound.assetId]) return; // Already preloaded\n    if (isNil(this._audioType)) await this.ready();\n\n    const assetPath = (this._assetPathPrefix || '') + sound.assetPath;\n    console.info(`[audio] Preloading sound '${sound.assetId}', from file '${assetPath}'...`);\n\n    try {\n      if (this._audioType === 'native') {\n        this._preloadedSounds[sound.assetId] = sound;\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        this._preloadedSounds[sound.assetId] = sound;\n      }\n\n      // Add to map\n      console.info(`[audio] Preloading sound '${sound.assetId}' [OK]`);\n    }\n    catch (err) {\n      const errorMsg = err?.message || err;\n      if (errorMsg === 'Audio Asset already exists') {\n        console.info(`[audio] Preloading sound '${sound.assetId}': Skipped (${errorMsg})`);\n      }\n      else {\n        this._preloadedSounds[sound.assetId] = null;\n        console.error(`[audio] Unable to preload sound '${sound.assetId}', from file '${assetPath}': ${errorMsg}\\n${err?.originalStack||''}`);\n        throw err;\n      }\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 sound '${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  async setAudioMode(mode: AudioManagement.AudioMode): Promise<void> {\n    try {\n      console.info(`[audio] Changing audio mode to {${audioModeToString(mode)}}`);\n      await this.audioManagement.setAudioMode(mode);\n      this._audioMode = mode;\n    }\n    catch(err) {\n      console.error(`[audio] Error while changing audio mode to {${audioModeToString(mode)}}: ${err?.message || err}`, err);\n      // Continue\n    }\n  }\n\n  /* -- protected methods  -- */\n\n  protected async readAudioMode() {\n    let value = await this.audioManagement.getAudioMode();\n    value = {\n      ...DEFAULT_AUDIO_MODE_RETURN,\n      ...value\n    };\n    console.debug(`[audio] Detected audio mode {label: '${value.label}', audioMode: ${value.audioMode}}`);\n    this._audioMode = value.audioMode;\n  }\n\n}\n"]}

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

@@ -0,0 +1,32 @@
+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 {
+    audio;
+    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]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: AudioTestingPage, deps: [{ token: i1.AudioProvider }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.1", 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: "17.1.1", 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: () => [{ type: i1.AudioProvider }] });
+//# sourceMappingURL=data:application/json;base64,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