Langage: HTML | XAML

Démarrage rapide : énumération des périphériques couramment utilisés (HTML)

Applies to Windows and Windows Phone

L’espace de noms Windows.Devices.Enumeration propose deux méthodes d’énumération des périphériques : FindAllAsync et CreateWatcher. FindAllAsync effectue une recherche unique pour les périphériques disponibles. Cette méthode est recommandée pour les applications qui ne nécessitent pas de mises à jour lorsqu’un utilisateur ajoute, supprime ou change un périphérique. CreateWatcher énumère les périphériques et déclenche également des événements de notification lorsqu’un utilisateur ajoute, supprime ou change de périphérique une fois que le système d’exploitation a terminé l’énumération initiale. Voici comment effectuer une énumération unique de périphériques couramment utilisés à l’aide FindAllAsync.

Objectif: répertorier les périphériques disponibles en catégories de périphériques courants, en utilisant l’espace de noms Windows.Devices.Enumeration.

Prérequis

Nous partons du principe que vous êtes familiarisé avec JavaScript et HTML.

Durée de réalisation: 20 minutes.

Instructions

1. Ouvrir Microsoft Visual Studio

Ouvrez une instance de Visual Studio.

2. Créer un projet

Dans la boîte de dialogue Nouveau projet, à partir des types de projets JavaScript, sélectionnez une application vide.

3. Insérer le code HTML de l’application

Ouvrez votre fichier Default.html, puis copiez ce code dans le fichier à la place du contenu existant.

Ce code HTML fournit une interface utilisateur qui permet aux utilisateurs de sélectionner parmi sept types de périphériques celui à énumérer : microphones, lecture audio, webcams, stockage amovible, services de périphériques MTP, périphériques SMS et périphériques de proximité.


<!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. Insérer le code JavaScript de l’application

Ouvrez le fichier Default.js et insérez ce code.

Selon le type de périphérique sélectionné par l’utilisateur, la fonction onEnumerateDeviceInterface choisit une valeur DeviceClass ou obtient un sélecteur à partir d’une fonction getDeviceSelector. L’application passe alors cette valeur à FindAllAsync. La fonction successCallback imprime les informations de périphérique seulement si l’énumération réussit et la fonction errorCallback imprime un message d’erreur si l’énumération échoue.


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 />";
}


Remarque  

Dans les quatre premiers choix, vous pouvez passer une valeur d’énumération DeviceClass à FindAllAsync. Cela revient à obtenir une chaîne de sélecteur à partir de l’API Windows Runtime associée au type de périphérique, et à passer le sélecteur à FindAllAsync. Le code permettant d’utiliser la chaîne de sélecteur au lieu de l’énumération DeviceClass est commentée pour les cas pertinents dans l’instruction switch.

Dans les trois derniers choix, il n’y a aucune valeur d’énumération DeviceClass, ainsi seul est exposé l’appel de l’API permettant d’obtenir la chaîne de sélecteur appropriée.

5. Générer l’application

Dans le menu Générer, cliquez sur Générer la solution pour générer le projet.

6. Tester l’application

  1. Dans le menu Déboguer, cliquez sur Démarrer le débogage pour tester la solution.
  2. Sélectionnez la classe d’interface du périphérique à énumérer.
  3. Cliquez sur le bouton Énumérer pour démarrer une recherche des interfaces de périphérique qui appartiennent à la classe d’interface de périphérique spécifiée. L’application dresse la liste des interfaces de périphériques dans la partie inférieure de la page qu’elle a créée.

7. Ajouter votre propre fonctionnalité de périphérique (facultatif)

Pour commencer à accéder à la fonctionnalité de périphérique au lieu de se contenter d’écouter les périphériques, passez la propriété DeviceInformation.id d’un périphérique que vous avez énuméré à l’API Windows Runtime pour utiliser le périphérique. Par exemple, vous pouvez utiliser l’ID d’une webcam énumérée pour définir la propriété Windows.Media.Capture.MediaCaptureInitializationSettings.VideoDeviceId, afin de spécifier la webcam à utiliser pour la capture vidéo.

  1. Ajoutez les fonctionnalités nécessaires dans le fichier package.appxmanifest du projet.
  2. Commencez par passer l’ID de périphérique à une API que vous pouvez utiliser pour interagir avec le périphérique. Il existe certaines méthodes qui prennent l’ID d’un périphérique pour initialiser un objet afin d’utiliser un périphérique :

    Pour les périphériques WPD qui utilisent un service de périphérique MTP (énuméré à l’aide de Windows.Devices.Portable.ServiceDevice.GetDeviceSelector ou Windows.Devices.Portable.ServiceDevice.GetDeviceSelectorFromServiceId), vous pouvez créer un objet d’automatisation COM qui fonctionne avec le périphérique de la manière suivante :

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

    var device = deviceFactory.getDeviceFromId(deviceId);

Récapitulatif et étapes suivantes

Vous venez de découvrir comment énumérer des types courants de périphériques, en passant une valeur d’énumération Windows.Device.Enumeration.DeviceClass ou une chaîne de sélecteur à partir d’une méthode getDeviceSelector à findAllAsync.

Si la classe d’interface du périphérique voulue ne figure pas dans l’énumération Windows.Device.Enumeration.DeviceClass, et qu’il n’existe aucune API Windows Runtime pour obtenir un sélecteur à votre place, vous devez créer vous-même une chaîne de syntaxe de recherche avancée (AQS, Advanced Query Syntax) et la passer à findAllAsync.

Pour créer une requête pour un type spécifique de périphérique, vous devez connaître le GUID de la classe de périphérique. Le code suivant inclut une requête pour les périphériques disponibles appartenant à une classe d’interface de périphérique qui est spécifiée par un GUID que l’utilisateur a tapé dans une zone de saisie. Le GUID doit être au format « {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} ».

Remarque  Veillez à ce que le GUID soit entouré de guillemets à l’intérieur de la chaîne de sélecteur. Par exemple, 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.
}



Remarque  Cet exemple a effectué une énumération unique, mais cela ne sera pas suffisant pour une application qui doit mettre à jour son interface utilisateur lorsqu’un utilisateur ajoute, supprime ou change de périphérique. La rubrique suivante vous montre comment utiliser CreateWatcher afin que vous puissiez énumérer des périphériques et obtenir des notifications de périphérique.

Comment énumérer de manière dynamique

Rubriques associées

API Windows Runtime qui fournissent des chaînes de sélecteur pour l’énumération
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
Syntaxe de recherche avancée (AQS) pour créer des chaînes de sélecteur
Utilisation de la syntaxe de recherche avancée par programmation

 

 

Afficher:
© 2014 Microsoft