Cómo Crear un Escáner de Códigos de Barras y Lector de Códigos QR en C# .NET¶

using VisioForge.Core;
using VisioForge.Core.MediaBlocks;
using VisioForge.Core.MediaBlocks.Sources;
using VisioForge.Core.MediaBlocks.Special;
using VisioForge.Core.MediaBlocks.VideoRendering;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Events;
using VisioForge.Core.Types.X;
using VisioForge.Core.Types.X.Sources;

// Inicializar el SDK (requerido en el primer uso)
await VisioForgeX.InitSDKAsync();

// Iniciar monitoreo de fuentes de video
await DeviceEnumerator.Shared.StartVideoSourceMonitorAsync();

// Obtener lista de cámaras disponibles
var cameras = await DeviceEnumerator.Shared.VideoSourcesAsync();

// Mostrar cámaras disponibles
foreach (var camera in cameras)
{
    Console.WriteLine($"Cámara: {camera.DisplayName}");

    // Listar formatos soportados
    foreach (var format in camera.VideoFormats)
    {
        Console.WriteLine($"  Formato: {format.Name}");
    }
}

// Crear el pipeline
var pipeline = new MediaBlocksPipeline();
pipeline.OnError += Pipeline_OnError;

// Configurar fuente de video
var device = cameras.First();
var formatItem = device.GetHDOrAnyVideoFormatAndFrameRate(out var frameRate);

var videoSourceSettings = new VideoCaptureDeviceSourceSettings(device)
{
    Format = formatItem.ToFormat()
};
videoSourceSettings.Format.FrameRate = frameRate;

// Crear bloque de fuente de video
var videoSource = new SystemVideoSourceBlock(videoSourceSettings);

// Crear bloque detector de códigos de barras
var barcodeDetector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOutput);
barcodeDetector.OnBarcodeDetected += BarcodeDetector_OnBarcodeDetected;

// Crear bloque renderizador de video (para vista previa)
var videoRenderer = new VideoRendererBlock(pipeline, videoView);

// Conectar los bloques
pipeline.Connect(videoSource.Output, barcodeDetector.Input);
pipeline.Connect(barcodeDetector.Output, videoRenderer.Input);

private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    // Este evento se llama cuando se detecta un código de barras
    Console.WriteLine($"Detectado: {e.BarcodeType} = {e.Value}");

    // Actualizar UI (usar dispatcher para seguridad de hilos)
    Dispatcher.Invoke(() =>
    {
        BarcodeTypeLabel.Text = e.BarcodeType;
        BarcodeValueLabel.Text = e.Value;
        LastDetectionTime.Text = DateTime.Now.ToString("HH:mm:ss.fff");
    });
}

// Iniciar escaneo
await pipeline.StartAsync();

// Detener escaneo
await pipeline.StopAsync();

// Pausar escaneo
await pipeline.PauseAsync();

// Reanudar escaneo
await pipeline.ResumeAsync();

// Eliminar manejadores de eventos
barcodeDetector.OnBarcodeDetected -= BarcodeDetector_OnBarcodeDetected;
pipeline.OnError -= Pipeline_OnError;

// Detener y limpiar
await pipeline.StopAsync();
pipeline.ClearBlocks();
pipeline.Dispose();

// Destruir SDK (al salir de la aplicación)
VisioForgeX.DestroySDK();

private Dictionary<string, DateTime> _recentDetections = new();
private TimeSpan _deduplicationWindow = TimeSpan.FromSeconds(2);

private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    string key = $"{e.BarcodeType}:{e.Value}";

    // Verificar si este código de barras fue detectado recientemente
    if (_recentDetections.TryGetValue(key, out var lastTime))
    {
        if (DateTime.Now - lastTime < _deduplicationWindow)
        {
            return; // Omitir duplicado
        }
    }

    // Registrar esta detección
    _recentDetections[key] = DateTime.Now;

    // Procesar el código de barras
    ProcessBarcode(e.BarcodeType, e.Value);
}

var fileSettings = await UniversalSourceSettings.CreateAsync(
    new Uri(@"C:\Videos\barcode-video.mp4"));
var fileSource = new UniversalSourceBlock(fileSettings);

pipeline.Connect(fileSource.VideoOutput, barcodeDetector.Input);

var screenSource = new ScreenSourceBlock(
    new ScreenCaptureSourceSettings()
    {
        DisplayIndex = 0, // Monitor principal
        FrameRate = new VideoFrameRate(10) // 10 FPS
    });

pipeline.Connect(screenSource.Output, barcodeDetector.Input);

var streamSettings = await UniversalSourceSettings.CreateAsync(
    new Uri("rtsp://camera-ip:554/stream"));
var streamSource = new UniversalSourceBlock(streamSettings);

pipeline.Connect(streamSource.VideoOutput, barcodeDetector.Input);

public class BarcodeDetection
{
    public string Type { get; set; }
    public string Value { get; set; }
    public DateTime Timestamp { get; set; }
}

private ObservableCollection<BarcodeDetection> _detectionHistory = new();
private int _maxHistorySize = 100;

private void BarcodeDetector_OnBarcodeDetected(object sender, BarcodeDetectorEventArgs e)
{
    var detection = new BarcodeDetection
    {
        Type = e.BarcodeType,
        Value = e.Value,
        Timestamp = DateTime.Now
    };

    // Agregar al inicio de la lista
    _detectionHistory.Insert(0, detection);

    // Mantener tamaño máximo
    while (_detectionHistory.Count > _maxHistorySize)
    {
        _detectionHistory.RemoveAt(_detectionHistory.Count - 1);
    }
}

private void Pipeline_OnError(object sender, ErrorsEventArgs e)
{
    Debug.WriteLine($"Error del Pipeline: {e.Message}");

    // Mostrar mensaje amigable al usuario
    Dispatcher.Invoke(() =>
    {
        mmLog.Text += e.Message + Environment.NewLine;
    });
}

private async Task<bool> RequestCameraPermissionAsync()
{
    var status = await Permissions.CheckStatusAsync<Permissions.Camera>();

    if (status != PermissionStatus.Granted)
    {
        status = await Permissions.RequestAsync<Permissions.Camera>();
    }

    return status == PermissionStatus.Granted;
}

// Tasa de fotogramas más baja para mejor rendimiento
videoSourceSettings.Format.FrameRate = new VideoFrameRate(15); // 15 FPS en lugar de 30

// Para captura de pantalla, usar tasas de fotogramas aún más bajas
screenSourceSettings.FrameRate = new VideoFrameRate(5); // 5 FPS

// Elegir un formato de menor resolución
var format = device.VideoFormats
    .Where(f => f.Width <= 1280 && f.Height <= 720)
    .OrderByDescending(f => f.Width * f.Height)
    .FirstOrDefault();

// Modo InputOutput: Pasa el video a través para vista previa (predeterminado)
var detector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOutput);

// Modo InputOnly: Sin salida de video, mejor rendimiento
var detector = new BarcodeDetectorBlock(BarcodeDetectorMode.InputOnly);

public partial class MainPage : ContentPage
{
    private MediaBlocksPipeline _pipeline;
    private BarcodeDetectorBlock _barcodeDetector;

    public MainPage()
    {
        InitializeComponent();
        Loaded += MainPage_Loaded;
    }

    private async void MainPage_Loaded(object sender, EventArgs e)
    {
        await VisioForgeX.InitSDKAsync();

        #if __ANDROID__ || __IOS__ || __MACCATALYST__
        await RequestCameraPermissionAsync();
        #endif

        _pipeline = new MediaBlocksPipeline();
        // ... configurar pipeline
    }
}

public partial class MainWindow : Window
{
    private MediaBlocksPipeline _pipeline;
    private BarcodeDetectorBlock _barcodeDetector;

    public MainWindow()
    {
        InitializeComponent();
        Loaded += MainWindow_Loaded;
    }

    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        await VisioForgeX.InitSDKAsync();

        _pipeline = new MediaBlocksPipeline();
        // ... configurar pipeline
    }
}

private async void ProcessInventoryBarcode(string barcodeValue)
{
    // Buscar producto en la base de datos
    var product = await _database.GetProductByBarcodeAsync(barcodeValue);

    if (product != null)
    {
        // Actualizar cantidad de inventario
        product.Quantity++;
        await _database.SaveChangesAsync();

        // Mostrar confirmación
        StatusLabel.Text = $"Agregado: {product.Name}";
    }
    else
    {
        StatusLabel.Text = "Producto no encontrado";
    }
}

private async void ProcessTicketBarcode(string ticketCode)
{
    var ticket = await _ticketService.ValidateTicketAsync(ticketCode);

    if (ticket.IsValid && !ticket.IsUsed)
    {
        await _ticketService.MarkAsUsedAsync(ticketCode);
        PlaySuccessSound();
        ShowGreenLight();
    }
    else
    {
        PlayErrorSound();
        ShowRedLight();
        StatusLabel.Text = ticket.IsUsed ? "Ya utilizado" : "Boleto inválido";
    }
}

private async void ProcessPaymentQRCode(string qrData)
{
    if (IsPaymentQRCode(qrData))
    {
        var paymentInfo = ParsePaymentData(qrData);

        // Mostrar diálogo de confirmación de pago
        var result = await DisplayAlert(
            "Confirmar Pago",
            $"¿Pagar ${paymentInfo.Amount} a {paymentInfo.Recipient}?",
            "Pagar",
            "Cancelar");

        if (result)
        {
            await ProcessPaymentAsync(paymentInfo);
        }
    }
}