Schnellstart: Enumerieren häufig verwendeter Geräte
Language: HTML | XAML

Schnellstart: Enumerieren häufig verwendeter Geräte (HTML)

[ Dieser Artikel richtet sich an Windows 8.x- und Windows Phone 8.x-Entwickler, die Windows-Runtime-Apps schreiben. Wenn Sie für Windows 10 entwickeln, finden Sie weitere Informationen unter neueste Dokumentation]

Vom Windows.Devices.Enumeration-Namespace werden zwei Methoden zum Enumerieren von Geräten bereitgestellt: FindAllAsync und CreateWatcher. Mit FindAllAsync wird eine einmalige Suche nach verfügbaren Geräten durchgeführt. Diese Methode eignet sich besonders gut für Apps, die nicht aktualisiert werden müssen, wenn ein Benutzer Geräte hinzufügt, entfernt oder ändert. CreateWatcher listet Geräte auf und löst Benachrichtigungsereignisse aus, wenn ein Benutzer ein Gerät hinzufügt, löscht oder ändert, nachdem die erstmalige Enumeration vom Betriebssystem abgeschlossen wurde. Im Folgenden wird dargestellt, wie eine einmalige Enumeration häufig verwendeter Geräte mit FindAllAsync ausgeführt wird.

Ziel: Enumerieren von verfügbaren Geräten in der Kategorie der häufig verwendeten Geräte mit dem Windows.Devices.Enumeration-Namespace

Voraussetzungen

Hierfür wird davon ausgegangen, dass Sie mit JavaScript und HTML vertraut sind.

Zeitaufwand: 20 Minuten.

Anweisungen

1. Öffnen von Microsoft Visual Studio

Öffnen Sie eine Instanz von Visual Studio.

2. Erstellen eines neuen Projekts

Wählen Sie im Dialogfeld Neues Projekt unter den JavaScript-Projekttypen eine leere App aus.

3. Einfügen des HTML-Codes

Öffnen Sie Default.html, und kopieren Sie diesen Code in die Datei. Ersetzen Sie dabei den Inhalt der Datei.

Von diesem HTML-Code wird eine Benutzeroberfläche bereitgestellt, mit deren Hilfe Benutzer sieben Gerätetypen zum Enumerieren auswählen können: Mikrofone, Audiowiedergabe, Webcams, Wechselspeichergeräte, MTP-Gerätedienste, SMS-Geräte und Näherungsgeräte.


<!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. Einfügen des JavaScript-Codes für die App

Öffnen Sie die Datei Default.js, und fügen Sie den folgenden Code ein.

Je nachdem, welcher Gerätetyp vom Benutzer ausgewählt wurde, wird von der "onEnumerateDeviceInterface"-Funktion ein DeviceClass-Wert ausgewählt oder aus einer "getDeviceSelector"-Funktion eine Auswahlzeichenfolge abgerufen. Dieser Wert wird anschließend an FindAllAsync übergeben. Von der "successCallback"-Funktion werden Geräteinformationen gedruckt, wenn das Enumerieren erfolgreich war. Wenn sie nicht erfolgreich war, wird von der "errorCallback"-Funktion eine Fehlermeldung gedruckt.


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(Windows.Devices.Portable.ServiceDeviceType.calendarService);
                break;
            case "sms":
            // Windows.Devices.Sms.SmsDevice.getDeviceSelector
                selectorString = smsDevice.getDeviceSelector();
                break;
            case "proximity":
            // Windows.Networking.Proximity.ProximityDevice.getDeviceSelector
                selectorString = proximityDevice.getDeviceSelector();
                break;
            case "imageScanner":
            // same as:
            // var scannerDevice = Windows.Devices.Scanners.ImageScanner;
            // selectorString = scannerDevice.getDeviceSelector();
                deviceClass = Enumeration.DeviceClass.imageScanner;
                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 />";
}


Hinweis  

Bei den ersten vier Optionen können Sie einen DeviceClass-Enumerationswert an FindAllAsync übergeben. Dieser Vorgang entspricht dem Abrufen einer Auswahlzeichenfolge von der dem Gerätetyp zugeordneten Windows-Runtime-API und der Übergabe der Auswahl an FindAllAsync. Der Code für die Verwendung der Auswahlzeichenfolge anstelle der DeviceClass-Enumeration ist an den entsprechenden Stellen in der switch-Anweisung auskommentiert.

Bei den letzten drei Optionen ist kein DeviceClass-Enumerationswert vorhanden. Daher wird nur der API-Aufruf zum Abrufen der entsprechenden Auswahlzeichenfolge dargestellt.

 

5. Erstellen der App

Klicken Sie im Menü Erstellen auf Projektmappe erstellen, um das Projekt zu erstellen.

6. Testen der App

  1. Klicken Sie im Menü Debuggen auf Debugging starten, um die Projektmappe zu testen.
  2. Wählen Sie die Geräteschnittstellenklasse aus, die enumeriert werden soll.
  3. Klicken Sie auf die Schaltfläche Enumerieren, um eine Suche nach Geräteschnittstellen zu starten, die der angegebenen Geräteschnittstellenklasse angehören. Die App listet die Geräteschnittstellen in der unteren Hälfte der erstellten Seite auf.

7. Hinzufügen einer eigenen Gerätefunktion (optional)

Wenn Sie auf Gerätefunktionen zugreifen und nicht nur Geräte auflisten möchten, übergeben Sie die DeviceInformation.id-Eigenschaft eines enumerierten Geräts an die Windows-Runtime-API, um das Gerät zu verwenden. Sie können beispielsweise die ID einer enumerierten Webcam verwenden, um die Windows.Media.Capture.MediaCaptureInitializationSettings.VideoDeviceId-Eigenschaft festzulegen und so die für die Videoaufnahme zu verwendende Webcam festzulegen.

  1. Fügen Sie der Datei package.appxmanifest des Projekts die erforderlichen Funktionen hinzu.
  2. Beginnen Sie damit, dass Sie die Geräte-ID einer API übergeben, die für die Interaktion mit dem Gerät verwendet werden kann. Von den folgenden Methoden kann eine Geräte-ID angenommen werden, um ein Objekt für die Verwendung eines Geräts zu initialisieren:

    Bei WPD-Geräten, für die ein MTP-Gerätedienst verwendet wird (mithilfe von Windows.Devices.Portable.ServiceDevice.GetDeviceSelector oder Windows.Devices.Portable.ServiceDevice.GetDeviceSelectorFromServiceId enumeriert), können Sie für die Verwendung des Geräts wie folgt ein COM-Automatisierungsobjekt erstellen:

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

    var device = deviceFactory.getDeviceFromId(deviceId);

Zusammenfassung und nächste Schritte

Sie haben nun gelernt, wie häufig verwendete Gerätetypen durch die Übergabe eines Windows.Device.Enumeration.DeviceClass-Enumerationswerts oder einer Auswahlzeichenfolge aus einer "getDeviceSelector"-Methode an findAllAsync enumeriert werden.

Wenn die gewünschte Geräteschnittstellenklasse in der Windows.Device.Enumeration.DeviceClass-Enumeration nicht vorhanden und auch keine Windows-Runtime-API vorhanden ist, um eine Auswahl abzurufen, müssen Sie eine AQS-Zeichenfolge (Advanced Query Syntax, erweiterte Abfragesyntax) erstellen und an findAllAsync übergeben.

Wenn Sie eine Abfrage für verfügbare Geräte eines bestimmten Typs erstellen möchten, müssen Sie die GUID der Geräteklasse kennen. Der folgende Code enthält eine Abfrage für verfügbare Geräte, die einer Geräteschnittstellenklasse zugeordnet sind, die durch eine vom Benutzer in ein Eingabefeld eingegebene GUID festgelegt ist. Die GUID muss das folgende Format aufweisen: "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}".

Hinweis  Achten Sie darauf, dass Sie die GUID in der Auswahlzeichenfolge in Anführungszeichen setzen. Beispiel: 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.
}



Hinweis  Bei diesem Beispiel wurde eine einmalige Enumeration durchgeführt. Für eine App, die die Benutzeroberfläche aktualisieren muss, wenn ein Benutzer ein Gerät hinzugefügt, entfernt oder ändert, reicht das jedoch nicht aus. Im nächsten Thema wird erläutert, wie mithilfe von CreateWatcher Geräte enumeriert und Gerätebenachrichtigungen abgerufen werden.
 

Dynamisches Enumerieren

Verwandte Themen

Windows-Runtime-APIs, die Auswahlzeichenfolgen für die Enumeration bereitstellen
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
Erweiterte Abfragesyntax (Advanced Query Syntax, AQS) zum Erstellen von Auswahlzeichenfolgen
Programmgesteuerte Verwendung der erweiterten Abfragesyntax

 

 

Anzeigen:
© 2017 Microsoft