Aplicaciones de Windows
Contraer la tabla de contenido
Expandir la tabla de contenido

Inicio rápido: enumeración de dispositivos usados habitualmente (aplicaciones de la Tienda Windows con JavaScript y HTML)

El espacio de nombres Windows.Devices.Enumeration proporciona dos métodos para enumerar dispositivos: FindAllAsync y CreateWatcher. FindAllAsync realiza una búsqueda única de los dispositivos disponibles y se recomienda para aplicaciones que no necesitan actualizaciones si un usuario agrega, elimina o cambia un dispositivo. CreateWatcher enumera los dispositivos y genera eventos de notificación cuando un usuario agrega, elimina o cambia un dispositivo después de que el sistema operativo finalice la enumeración inicial. A continuación te mostramos cómo realizar una enumeración única de los dispositivos usados habitualmente con FindAllAsync.

Objetivo: Enumerar los dispositivos disponibles en categorías habituales de dispositivos mediante el espacio de nombres Windows.Devices.Enumeration.

Requisitos previos

Suponemos que estás familiarizado con JavaScript y HTML.

Tiempo para finalizar: 20 minutos.

Instrucciones

1. Abrir Visual Studio 11 Express

Abre una instancia de Microsoft Visual Studio Express 2012 for Windows 8.

2. Crear un nuevo proyecto

En el cuadro de diálogo Nuevo proyecto, elige una aplicación vacía en los tipos de proyecto de JavaScript.

3. Insertar la aplicación HTML

Abre el archivo Default.html y copia este código en él, sustituyendo su contenido.

Este código HTML proporciona una interfaz de usuario que permite a los usuarios seleccionar entre siete tipos de dispositivos para enumerarlos: micrófonos, reproducción de audio, cámaras web, almacenamiento extraíble, servicios de dispositivos MTP, dispositivos SMS y dispositivos de proximidad.


<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <script src="/js/default.js"></script>
</head>
<body data-design-activate="defaultPage.activated">
    <h1>Device Enumeration Sample</h1>

    <h2 >Input</h2>

    <div>            

        <div id="Input">
           <p>This scenario demonstrates using the device enumeration API
              to look for specific device interfaces. A device interface
              is the programmatic entry point for a device.</p>
           <p>Select a device interface class</p>
                <select id="SelectInterfaceClass" size="7" >
                    <option value="audioCapture">Audio Capture</option>
                    <option value="audioRender">Audio Playback</option>
                    <option value="videoCapture">Webcams</option>
                    <option value="portableStorageDevice">Portable Storage</option>
                    <option value="mtpService">MTP Device Service</option>
                    <option value="sms">SMS Device</option>
                    <option value="proximity">Proxmity Device</option>
                </select>
                <br />
                <p>Clicking the enumerate button will start a search for 
                 device interfaces that belong to the specified device interface class. 
                 The device interfaces will be listed below.</p>
          <input onclick="onEnumerateDeviceInterfaces()" type="button" value="Enumerate" />
                <br /><br />
            </div>
    </div>


    <h2> Output</h2>

            <div id="statusMessage"></div>

            <!-- Device Enumeration results are displayed in this element -->
            <div  id="Output"></div>
</body>
</html>


4. Insertar la aplicación JavaScript

Abre el archivo Default.js e inserta el código siguiente.

En función del tipo de dispositivo seleccionado por el usuario, la función onEnumerateDeviceInterface elige un valor de DeviceClass u obtiene una cadena de selector de una función getDeviceSelector. A continuación, la aplicación pasa este valor a FindAllAsync. La función successCallback imprime la información de los dispositivos si la enumeración se realiza correctamente y, en caso contrario, la función errorCallback imprime un mensaje de error.


function onEnumerateDeviceInterfaces() {
    document.getElementById("Output").innerHTML = ""; // clear output
    try {
        var selection = document.getElementById("SelectInterfaceClass");
        var selectedDeviceClass = 
            selection.options[selection.selectedIndex].value;
        var deviceClass;
        var Enumeration = Windows.Devices.Enumeration;
        var selectorString = "";

        var mtpServiceDevice = Windows.Devices.Portable.ServiceDevice;
        var smsDevice = Windows.Devices.Sms.SmsDevice;
        var proximityDevice = Windows.Networking.Proximity.ProximityDevice;
        switch (selectedDeviceClass) {
            case "audioCapture":
                // same as:
                // var mediaDevice = Windows.Media.Devices.MediaDevice;
                // selectorString =  mediaDevice.getAudioCaptureSelector();
                deviceClass = Enumeration.DeviceClass.audioCapture;
                break;
            case "audioRender":
                // same as:
                // var mediaDevice = Windows.Media.Devices.MediaDevice;
                // selectorString =  mediaDevice.getAudioRenderSelector();
                deviceClass = Enumeration.DeviceClass.audioRender;
                break;
            case "portableStorageDevice":
                // same as: 
                // var storageDevice = Windows.Devices.Portable.StorageDevice;
                // selectorString = storageDevice.getDeviceSelector();
                deviceClass = Enumeration.DeviceClass.portableStorageDevice;
                break;
            case "videoCapture":
                // same as:
                // var mediaDevice = Windows.Media.Devices.MediaDevice;
                // selectorString =  mediaDevice.getVideoCaptureSelector();
                deviceClass = Enumeration.DeviceClass.videoCapture;
                break;
            case "mtpService":
            // Windows.Devices.Portable.ServiceDevice.GetDeviceSelector
                selectorString = mtpServiceDevice.GetDeviceSelector();
                break;
            case "sms":
            // Windows.Devices.Sms.SmsDevice.GetDeviceSelector
                selectorString = smsDevice.GetDeviceSelector();
                break;
            case "proximity":
            // Windows.Networking.Proximity.ProximityDevice.GetDeviceSelector
                selectorString = proximityDevice.GetDeviceSelector();
                break;
            default: deviceClass = Enumeration.DeviceClass.all;
        }

        var DeviceInformation = Enumeration.DeviceInformation;
        if (selectorString == "") {
            DeviceInformation.findAllAsync(deviceClass).then(
                successCallback, 
                errorCallback
            );
        } else {
            DeviceInformation.findAllAsync(selectorString, null).then(
                successCallback, 
                errorCallback
            );
        }
    } catch (e) {
        document.getElementById("statusMessage").innerHTML = 
            "Failed to enumerate devices, error: " + e.message;
    }
}

// Handles successful completion of the findAllAsync method.
function successCallback(deviceInformationCollection) {
    var numDevices = deviceInformationCollection.length;
    document.getElementById("statusMessage").innerHTML = 
        numDevices + " device interface(s) found";
    if (numDevices) {
        for (var i = 0; i < numDevices; i++) {
            printFriendlyNameAndID(deviceInformationCollection[i], 
                document.getElementById("Output"));
        }
    } else {
        document.getElementById("statusMessage").innerHTML = "No devices found";
    }
}

// Handles an error completion of the findAllAsync method.
function errorCallback(e) {
    document.getElementById("statusMessage").innerHTML = 
        "Failed to find devices, error: " + e.message;
}

// Prints the friendly name of the device interface and its ID 
// The ID is the device interface path.
function printFriendlyNameAndID(deviceInterface, log) {

    // The name property is equivalent to System.ItemNameDisplay property
    log.innerHTML += "<h3>" + 
            deviceInterface.name + "<h3/>";
    log.innerHTML += "<p>Interface ID: " + deviceInterface.id;    
    log.innerHTML += "<p>Enabled: " + deviceInterface.isEnabled;
    
    log.innerHTML += "<br />";
}


Nota  

Para las primeras cuatro opciones puedes pasar un valor de la enumeración DeviceClass a FindAllAsync. Esto equivale a obtener una cadena de selector de la API de Windows en tiempo de ejecución asociada con el tipo de dispositivo y pasar el selector a FindAllAsync. El código para usar la cadena de selector en lugar de la enumeración DeviceClass se comenta en los casos relevantes en la instrucción switch.

Para las últimas tres opciones, no hay ningún valor de la enumeración DeviceClass, por lo que solo se muestra la llamada API para obtener la cadena de selección apropiada.

5. Generar la aplicación

En el menú Generar, haz clic en Generar solución para generar el proyecto.

6. Probar la aplicación

  1. En el menú Depurar, haz clic en Iniciar depuración para probar la solución.
  2. Elige la clase de interfaz de dispositivo que quieres enumerar.
  3. Haz clic en el botón Enumerar para iniciar una búsqueda de las interfaces de dispositivo que pertenezcan a la clase de interfaz de dispositivo especificada. La aplicación enumera las interfaces de dispositivo en la mitad inferior de la página que crea.

7. Agregar tus propias funciones de dispositivo (opcional)

Para iniciar el acceso a las funciones de dispositivo en lugar de solo enumerarlos, pasa la propiedad DeviceInformation.id de un dispositivo que hayas enumerado a la API de Windows en tiempo de ejecución para usar el dispositivo. Por ejemplo, puedes usar el identificador de una cámara web enumerada para establecer la propiedad Windows.Media.Capture.MediaCaptureInitializationSettings.VideoDeviceId con el fin de especificar la cámara web que se usará para la captura de vídeo.

  1. Agrega las funcionalidades que necesites al archivo package.appxmanifest del proyecto.
  2. Para empezar, pasa el identificador del dispositivo a una API que puedas usar para interactuar con el dispositivo. Estos son algunos de los métodos que toman un identificador de dispositivo para inicializar un objeto a fin de usar un dispositivo:

    Para los dispositivos WPD que usen un servicio de dispositivos MTP (enumerados con Windows.Devices.Portable.ServiceDevice.GetDeviceSelector o Windows.Devices.Portable.ServiceDevice.GetDeviceSelectorFromServiceId), puedes crear un objeto de automatización COM para que funcione con el dispositivo de la siguiente manera:

    deviceFactory = new ActiveXObject("PortableDeviceAutomation.Factory");

    var device = deviceFactory.getDeviceFromId(deviceId);

Resumen y next steps

Acabas de aprender a enumerar tipos habituales de dispositivos con el paso de un valor de la enumeración Windows.Device.Enumeration.DeviceClass o una cadena de selector desde un método getDeviceSelector a findAllAsync.

Si la clase de interfaz de dispositivo que quieres no está en la enumeración Windows.Device.Enumeration.DeviceClass y no hay ninguna API de Windows en tiempo de ejecución para obtener un selector, tendrás que generar una cadena de Sintaxis de consulta avanzada (AQS) tú mismo y pasarla a findAllAsync.

Para crear una consulta sobre dispositivos disponibles de un tipo especificado, tienes que conocer el GUID de clase de dispositivo. El código siguiente incluye una consulta de los dispositivos disponibles que pertenecen a una clase de interfaz de dispositivo especificada por un GUID escrito por el usuario en un cuadro de entrada. El GUID debe tener el formato "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}".

Nota  Asegúrate de que el GUID esté incluido entre comillas en la cadena de selector. Por ejemplo, var selectorString = "System.Devices.InterfaceClassGuid:=\"{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\"";.


        if (textinput.value != ""){
            var textDeviceInterfaceClassGUID = textinput.value;
            var selectorString = "System.Devices.InterfaceClassGuid:=\"" + 
                textDeviceInterfaceClassGUID + 
                "\" AND System.Devices.InterfaceEnabled:=true";
            var Enum = Windows.Devices.Enumeration;
            Enum.DeviceInformation.findAllAsync(selectorString, null).then(
                    successCallback, 
                    errorCallback
                );

// Handles successful completion of the findAllAsync method.
function successCallback(deviceInformationCollection) {
    // Add your code here for processing the enumerated device collection.
}

// Handles an error completion of the findAllAsync method.
function errorCallback(e) {
    // Add your error-handling code here.
}



Nota  En este ejemplo se ha realizado una enumeración única, pero esto no será suficiente para una aplicación que deba actualizar su interfaz de usuario cuando un usuario agregue, quite o cambie un dispositivo. En el tema siguiente verás cómo usar CreateWatcher para enumerar los dispositivos y obtener notificaciones sobre ellos.

Cómo enumerar de manera dinámica

Temas relacionados

API de Windows en tiempo de ejecución que proporcionan cadenas de selector para la enumeración
Windows.Media.Devices.MediaDevice.getAudioCaptureSelector
Windows.Media.Devices.MediaDevice.getAudioRenderSelector
Windows.Media.Devices.MediaDevice.getVideoCaptureSelector
Windows.Media.Devices.MediaDevice.getDefaultAudioRenderId
Windows.Media.Devices.MediaDevice.getDefaultAudioCaptureId
Windows.Devices.Portable.StorageDevice.GetDeviceSelector
Windows.Devices.Portable.ServiceDevice.GetDeviceSelector
Windows.Devices.Portable.ServiceDevice.GetDeviceSelectorFromServiceId
Windows.Devices.Sms.SmsDevice.GetDeviceSelector
Windows.Networking.Proximity.ProximityDevice.GetDeviceSelector
Sintaxis de consulta avanzada (AQS) para generar cadenas de selector
Uso de la sintaxis de consulta avanzada mediante programación

 

 

Mostrar:
© 2018 Microsoft