react-native-urovo-scanner/lib/useUrovoScanner.js

React Native package for Urovo Scanner SDK integration - Official SDK implementation

/**
 * Hook personalizado para usar el scanner Urovo con la API oficial
 */
import { useState, useEffect, useCallback } from 'react';
import { urovoScanner, SCAN_MODES, TRIGGER_MODES, } from './UrovoScanner';
export const useUrovoScanner = ({ onScanResult, onScanError, autoOpen = true, } = {}) => {
    const [isOpened, setIsOpened] = useState(false);
    const [isScanning, setIsScanning] = useState(false);
    const [error, setError] = useState(null);
    // Abrir scanner
    const openScanner = useCallback(async () => {
        try {
            setError(null);
            const success = await urovoScanner.openScanner();
            if (success) {
                // Configurar el scanner con los valores por defecto
                await urovoScanner.setOutputMode(SCAN_MODES.SCAN_MODE_BROADCAST);
                await urovoScanner.setTriggerMode(TRIGGER_MODES.SCAN_TRIGGER_MODE_ONESHOT);
                setIsOpened(true);
                console.log('Scanner abierto exitosamente');
                return true;
            }
            else {
                setError('No se pudo abrir el scanner');
                console.error('Error abriendo scanner');
                return false;
            }
        }
        catch (err) {
            const errorMessage = err instanceof Error ? err.message : 'Error desconocido';
            setError(errorMessage);
            console.error('Excepción abriendo scanner:', errorMessage);
            return false;
        }
    }, []);
    // Cerrar scanner
    const closeScanner = useCallback(async () => {
        try {
            setError(null);
            const success = await urovoScanner.closeScanner();
            if (success) {
                setIsOpened(false);
                setIsScanning(false);
                console.log('Scanner cerrado exitosamente');
                return true;
            }
            else {
                setError('No se pudo cerrar el scanner');
                console.error('Error cerrando scanner');
                return false;
            }
        }
        catch (err) {
            const errorMessage = err instanceof Error ? err.message : 'Error desconocido';
            setError(errorMessage);
            console.error('Excepción cerrando scanner:', errorMessage);
            return false;
        }
    }, []);
    // Iniciar escaneo
    const startScan = useCallback(async () => {
        try {
            setError(null);
            const success = await urovoScanner.startScan();
            if (success) {
                setIsScanning(true);
                console.log('Escaneo iniciado exitosamente');
                return true;
            }
            else {
                setError('No se pudo iniciar el escaneo');
                console.error('Error iniciando escaneo');
                return false;
            }
        }
        catch (err) {
            const errorMessage = err instanceof Error ? err.message : 'Error desconocido';
            setError(errorMessage);
            console.error('Excepción iniciando escaneo:', errorMessage);
            return false;
        }
    }, []);
    // Detener escaneo
    const stopScan = useCallback(async () => {
        try {
            setError(null);
            const success = await urovoScanner.stopScan();
            if (success) {
                setIsScanning(false);
                console.log('Escaneo detenido exitosamente');
                return true;
            }
            else {
                setError('No se pudo detener el escaneo');
                console.error('Error deteniendo escaneo');
                return false;
            }
        }
        catch (err) {
            const errorMessage = err instanceof Error ? err.message : 'Error desconocido';
            setError(errorMessage);
            console.error('Excepción deteniendo escaneo:', errorMessage);
            return false;
        }
    }, []);
    // Manejar resultado de escaneo
    const handleScanResult = useCallback((result) => {
        console.log('Resultado de escaneo:', result);
        setIsScanning(false); // El escaneo se detiene automáticamente después de un resultado
        if (onScanResult) {
            onScanResult(result);
        }
    }, [onScanResult]);
    // Manejar error de escaneo
    const handleScanError = useCallback((scanError) => {
        console.error('Error de escaneo:', scanError);
        setError(scanError.error);
        setIsScanning(false);
        if (onScanError) {
            onScanError(scanError);
        }
    }, [onScanError]);
    // Efecto para configurar listeners y auto-abrir
    useEffect(() => {
        let scanResultSubscription = null;
        let scanErrorSubscription = null;
        // Configurar listeners
        scanResultSubscription = urovoScanner.onScanResult(handleScanResult);
        scanErrorSubscription = urovoScanner.onScanError(handleScanError);
        // Auto-abrir si está habilitado
        if (autoOpen) {
            openScanner();
        }
        // Cleanup
        return () => {
            if (scanResultSubscription) {
                scanResultSubscription.remove();
            }
            if (scanErrorSubscription) {
                scanErrorSubscription.remove();
            }
            // Cerrar scanner al desmontar
            closeScanner();
        };
    }, [autoOpen, handleScanResult, handleScanError, openScanner, closeScanner]);
    return {
        isOpened,
        isScanning,
        openScanner,
        closeScanner,
        startScan,
        stopScan,
        error,
    };
};
export default useUrovoScanner;