react-mic-cam-permissions/dist/PermissionManager.js

Managing camera and microphone permissions with React

// src/PermissionManager.ts
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
export class PermissionManager {
    constructor() {
        this.cameraState = 'prompt';
        this.microphoneState = 'prompt';
        this.cameraListeners = [];
        this.microphoneListeners = [];
        this.init();
    }
    // Méthode pour obtenir l'instance unique (Singleton)
    static getInstance() {
        if (!PermissionManager.instance) {
            PermissionManager.instance = new PermissionManager();
        }
        return PermissionManager.instance;
    }
    // Initialisation des permissions
    init() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.checkCameraPermission();
            yield this.checkMicrophonePermission();
        });
    }
    // Obtenir l'état actuel de la permission caméra
    getCameraState() {
        return this.cameraState;
    }
    // Obtenir l'état actuel de la permission microphone
    getMicrophoneState() {
        return this.microphoneState;
    }
    // Ajouter un écouteur pour les changements de permission caméra
    addCameraListener(listener) {
        this.cameraListeners.push(listener);
    }
    // Ajouter un écouteur pour les changements de permission microphone
    addMicrophoneListener(listener) {
        this.microphoneListeners.push(listener);
    }
    // Notifier les écouteurs du changement de permission caméra
    notifyCameraListeners() {
        this.cameraListeners.forEach((listener) => listener(this.cameraState));
    }
    // Notifier les écouteurs du changement de permission microphone
    notifyMicrophoneListeners() {
        this.microphoneListeners.forEach((listener) => listener(this.microphoneState));
    }
    // Vérifier l'état de la permission caméra
    checkCameraPermission() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!navigator.permissions) {
                this.cameraState = 'unavailable';
                this.notifyCameraListeners();
                return;
            }
            try {
                const status = yield navigator.permissions.query({ name: 'camera' });
                this.cameraState = status.state;
                this.notifyCameraListeners();
                status.onchange = () => {
                    this.cameraState = status.state;
                    this.notifyCameraListeners();
                };
            }
            catch (error) {
                console.error('Error checking camera permission:', error);
                this.cameraState = 'unavailable';
                this.notifyCameraListeners();
            }
        });
    }
    // Vérifier l'état de la permission microphone
    checkMicrophonePermission() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!navigator.permissions) {
                this.microphoneState = 'unavailable';
                this.notifyMicrophoneListeners();
                return;
            }
            try {
                const status = yield navigator.permissions.query({ name: 'microphone' });
                this.microphoneState = status.state;
                this.notifyMicrophoneListeners();
                status.onchange = () => {
                    this.microphoneState = status.state;
                    this.notifyMicrophoneListeners();
                };
            }
            catch (error) {
                console.error('Error checking microphone permission:', error);
                this.microphoneState = 'unavailable';
                this.notifyMicrophoneListeners();
            }
        });
    }
    // Demander la permission caméra
    requestCameraPermission() {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const stream = yield navigator.mediaDevices.getUserMedia({ video: true });
                stream.getTracks().forEach((track) => track.stop()); // Libérer les ressources après la demande
                this.cameraState = 'granted'; // Permission accordée
            }
            catch (error) {
                console.error('Error requesting camera permission:', error);
                if (error instanceof Error && error.name === 'NotAllowedError') {
                    this.cameraState = 'denied'; // Permission refusée
                    // Optionnel : informer l'utilisateur qu'il doit réinitialiser la permission manuellement
                    alert('Permission denied. Please enable camera permission in your browser settings.');
                }
                else {
                    this.cameraState = 'unavailable'; // Permission non disponible
                    alert('Camera permission is not available.');
                }
            }
            this.notifyCameraListeners(); // Notifier les écouteurs après la mise à jour
            return this.cameraState; // Retourner l'état actuel
        });
    }
    // Demander la permission microphone
    requestMicrophonePermission() {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                // Essayer de redemander la permission microphone
                const stream = yield navigator.mediaDevices.getUserMedia({ audio: true });
                stream.getTracks().forEach((track) => track.stop()); // Libérer les ressources après la demande
                this.microphoneState = 'granted'; // Permission accordée
            }
            catch (error) {
                console.error('Error requesting microphone permission:', error);
                // Gérer les cas où la permission est refusée
                if (error instanceof Error && error.name === 'NotAllowedError') {
                    this.microphoneState = 'denied'; // Permission refusée
                    alert('Permission denied. Please enable microphone permission in your browser settings.');
                }
                else {
                    this.microphoneState = 'unavailable'; // Permission non disponible
                    alert('Microphone permission is not available.');
                }
            }
            this.notifyMicrophoneListeners(); // Notifier les écouteurs après la mise à jour
            return this.microphoneState; // Retourner l'état actuel
        });
    }
}