Prise en main du point de serviceGetting started with Point of Service

Le point de service, le point de vente ou le point de service sont des périphériques informatiques utilisés pour faciliter les transactions de vente au détail.Point of service, point of sale, or Point of Service devices are computer peripherals used to facilitate retail transactions. Parmi les exemples de périphériques de point de service figurent les registres de trésorerie électronique, les scanneurs de codes-barres, les lecteurs de bandes magnétiques et les imprimantes de réception.Examples of Point of Service devices include electronic cash registers, barcode scanners, magnetic stripe readers, and receipt printers.

Vous découvrirez ici les principes fondamentaux de l’interfaçage avec les périphériques de point de service à l’aide des API de point de service Windows Runtime.Here you’ll learn the basics of interfacing with Point of Service devices by using the Windows Runtime Point of Service APIs. Nous allons aborder l’énumération des appareils, la vérification des fonctionnalités des appareils, la revendication des appareils et le partage des appareils.We’ll cover device enumeration, checking device capabilities, claiming devices, and device sharing. Nous utilisons un périphérique de scanneur de codes-barres comme exemple, mais presque tous les conseils ici s’appliquent à tous les appareils de point de service compatibles UWP.We use a barcode scanner device as an example, but almost all the guidance here applies to any UWP-compatible Point of Service device. (Pour obtenir la liste des appareils pris en charge, voir prise en charge des appareils de point de service).(For a list of supported devices, see Point of Service device support).

Recherche et connexion aux périphériques de point de serviceFinding and connecting to Point of Service peripherals

Avant qu’un point de service puisse être utilisé par une application, il doit être associé au PC sur lequel l’application s’exécute.Before a Point of Service device can be used by an app, it must be paired with the PC where the app is running. Il existe plusieurs façons de se connecter à des appareils de point de service, soit par programme, soit par le biais de l’application paramètres.There are several ways to connect to Point of Service devices, either programmatically or through the Settings app.

Connexion à des appareils à l’aide de l’application paramètresConnecting to devices by using the Settings app

Lorsque vous connectez un appareil de point de service comme un scanneur de codes-barres à un PC, il s’affiche comme n’importe quel autre appareil.When you plug a Point of Service device like a barcode scanner into a PC, it shows up just like any other device. Vous pouvez le trouver dans la section appareils > Bluetooth & autres appareils de l’application paramètres.You can find it in the Devices > Bluetooth & other devices section of the Settings app. Vous pouvez associer un appareil de point de service en sélectionnant Ajouter Bluetooth ou autre périphérique.There you can pair with a Point of Service device by selecting Add Bluetooth or other device.

Certains périphériques de point de service peuvent ne pas apparaître dans l’application paramètres jusqu’à ce qu’ils soient énumérés par programme à l’aide des API point of service.Some Point of Service devices may not appear in the Settings app until they are programmatically enumerated by using the Point of Service APIs.

Obtention d’un point de service unique avec GetDefaultAsyncGetting a single Point of Service device with GetDefaultAsync

Dans un cas d’utilisation simple, vous pouvez avoir un seul périphérique de point de service connecté au PC sur lequel l’application s’exécute et que vous souhaitez le configurer le plus rapidement possible.In a simple use case, you may have just one Point of Service peripheral connected to the PC where the app is running and want to set it up as quickly as possible. Pour ce faire, récupérez l’appareil « par défaut » avec la méthode GetDefaultAsync , comme illustré ici.To do that, retrieve the “default” device with the GetDefaultAsync method as shown here.

using Windows.Devices.PointOfService;

BarcodeScanner barcodeScanner = await BarcodeScanner.GetDefaultAsync();

Si le périphérique par défaut est trouvé, l’objet appareil récupéré est prêt à être réclamé.If the default device is found, the device object retrieved is ready to be claimed. « Revendiquer » un appareil donne à une application un accès exclusif à celui-ci, ce qui empêche les commandes conflictuelles à partir de plusieurs processus.“Claiming” a device gives an application exclusive access to it, preventing conflicting commands from multiple processes.

Notes

Si plusieurs appareils de point de service sont connectés au PC, GetDefaultAsync retourne le premier périphérique qu’il trouve.If more than one Point of Service device is connected to the PC, GetDefaultAsync returns the first device it finds. Pour cette raison, utilisez FindAllAsync , sauf si vous êtes certain qu’un seul appareil de point de service est visible pour l’application.For this reason, use FindAllAsync unless you’re sure that only one Point of Service device is visible to the application.

Énumération d’une collection d’appareils avec FindAllAsyncEnumerating a collection of devices with FindAllAsync

Quand vous êtes connecté à plusieurs appareils, vous devez énumérer la collection d’objets d’appareil PointOfService pour trouver celui que vous souhaitez revendiquer.When connected to more than one device, you must enumerate the collection of PointOfService device objects to find the one you want to claim. Par exemple, le code suivant crée une collection de tous les scanneurs de codes-barres actuellement connectés, puis recherche un scanneur portant un nom spécifique dans la collection.For example, the following code creates a collection of all the barcode scanners currently connected, and then searches the collection for a scanner with a specific name.

using Windows.Devices.Enumeration;
using Windows.Devices.PointOfService;

string selector = BarcodeScanner.GetDeviceSelector();       
DeviceInformationCollection deviceCollection = await DeviceInformation.FindAllAsync(selector);

foreach (DeviceInformation devInfo in deviceCollection)
{
    Debug.WriteLine("{0} {1}", devInfo.Name, devInfo.Id);
    if (devInfo.Name.Contains("1200G"))
    {
        Debug.WriteLine(" Found one");
    }
}

Définition de la portée de la sélection des appareilsScoping the device selection

Quand vous vous connectez à un appareil, vous souhaiterez peut-être limiter votre recherche à un sous-ensemble de périphériques de point de service auxquels votre application a accès.When connecting to a device, you may want to limit your search to a subset of Point of Service peripherals that your app has access to. À l’aide de la méthode GetDeviceSelector , vous pouvez étendre la sélection pour récupérer des appareils connectés uniquement par une certaine méthode (Bluetooth, USB, etc.).Using the GetDeviceSelector method, you can scope the selection to retrieve devices connected only by a certain method (Bluetooth, USB, etc.). Vous pouvez créer un sélecteur qui recherche des appareils sur les types de connexion Bluetooth, IP, localou All.You can create a selector that searches for devices over Bluetooth, IP, Local, or All connection types. Cela peut être utile, car la détection des périphériques sans fil prend beaucoup de temps par rapport à la découverte locale (filaire).This can be useful, as wireless device discovery takes a long time compared to local (wired) discovery. Vous pouvez garantir un temps d’attente déterministe pour la connexion de l’appareil local en limitant FindAllAsync aux types de connexion locaux .You can ensure a deterministic wait time for local device connection by limiting FindAllAsync to Local connection types. Par exemple, ce code récupère tous les scanneurs de codes-barres accessibles via une connexion locale.For example, this code retrieves all barcode scanners accessible via a local connection.

string selector = BarcodeScanner.GetDeviceSelector(PosConnectionTypes.Local);
DeviceInformationCollection deviceCollection = await DeviceInformation.FindAllAsync(selector);

Réaction aux modifications des connexions des appareils avec DeviceWatcherReacting to device connection changes with DeviceWatcher

Lorsque votre application s’exécute, les appareils sont parfois déconnectés ou mis à jour, ou de nouveaux appareils doivent être ajoutés.As your app runs, sometimes devices will be disconnected or updated, or new devices will need to be added. Vous pouvez utiliser la classe DeviceWatcher pour accéder aux événements liés à l’appareil, afin que votre application puisse répondre en conséquence.You can use the DeviceWatcher class to access device-related events, so your app can respond accordingly. Voici un exemple d’utilisation de DeviceWatcher, avec des stubs de méthode à appeler si un appareil est ajouté, supprimé ou mis à jour.Here’s example of how to use DeviceWatcher, with method stubs to be called if a device is added, removed, or updated.

DeviceWatcher deviceWatcher = DeviceInformation.CreateWatcher(selector);
deviceWatcher.Added += DeviceWatcher_Added;
deviceWatcher.Removed += DeviceWatcher_Removed;
deviceWatcher.Updated += DeviceWatcher_Updated;

void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
{
    // TODO: Add the DeviceInformation object to your collection
}

void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
{
    // TODO: Remove the item in your collection associated with DeviceInformationUpdate
}

void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args)
{
    // TODO: Update your collection with information from DeviceInformationUpdate
}

Vérification des fonctionnalités d’un appareil de point de serviceChecking the capabilities of a Point of Service device

Même dans une classe d’appareils, comme les scanneurs de codes-barres, les attributs de chaque périphérique peuvent varier considérablement d’un modèle à l’autre.Even within a device class, such as barcode scanners, the attributes of each device may vary considerably between models. Si votre application nécessite un attribut d’appareil spécifique, vous devrez peut-être inspecter chaque objet d’appareil connecté pour déterminer si l’attribut est pris en charge.If your app requires a specific device attribute, you may need to inspect each connected device object to determine whether the attribute is supported. Par exemple, votre entreprise a peut-être besoin de créer des étiquettes à l’aide d’un modèle d’impression de codes-barres spécifique.For example, perhaps your business requires that labels be created using a specific barcode printing pattern. Voici comment vérifier si un scanneur de codes-barres connecté prend en charge un symbolisme.Here’s how you could check to see whether a connected barcode scanner supports a symbology.

Notes

Un symbolisme est le mappage de langage utilisé par un code-barres pour encoder les messages.A symbology is the language mapping that a barcode uses to encode messages.

try
{
    BarcodeScanner barcodeScanner = await BarcodeScanner.FromIdAsync(deviceId);
    if (await barcodeScanner.IsSymbologySupportedAsync(BarcodeSymbologies.Code32))
    {
        Debug.WriteLine("Has symbology");
    }
}
catch (Exception ex)
{
    Debug.WriteLine("FromIdAsync() - " + ex.Message);
}

Utilisation de la classe Device. CapabilitiesUsing the Device.Capabilities class

La classe Device. Capabilities est un attribut de toutes les classes de périphérique de service et peut être utilisée pour obtenir des informations générales sur chaque appareil.The Device.Capabilities class is an attribute of all Point of Service device classes and can be used to get general information about each device. Par exemple, cet exemple détermine si un appareil prend en charge les rapports de statistiques et, le cas échéant, récupère des statistiques pour tous les types pris en charge.For example, this example determines whether a device supports statistics reporting and, if it does, retrieves statistics for any types supported.

try
{
    if (barcodeScanner.Capabilities.IsStatisticsReportingSupported)
    {
        Debug.WriteLine("Statistics reporting is supported");

        string[] statTypes = new string[] {""};
        IBuffer ibuffer = await barcodeScanner.RetrieveStatisticsAsync(statTypes);
    }
}
catch (Exception ex)
{
    Debug.WriteLine("EX: RetrieveStatisticsAsync() - " + ex.Message);
}

Revendication d’un point de serviceClaiming a Point of Service device

Avant de pouvoir utiliser un appareil de point de service pour une entrée ou une sortie active, vous devez le réclamer, en accordant à l’application un accès exclusif à la plupart de ses fonctions.Before you can use a Point of Service device for active input or output, you must claim it, granting the application exclusive access to many of its functions. Ce code montre comment revendiquer un périphérique de scanneur de codes-barres, une fois que vous avez trouvé l’appareil à l’aide de l’une des méthodes décrites précédemment.This code shows how to claim a barcode scanner device, after you’ve found the device by using one of the methods described earlier.

try
{
    claimedBarcodeScanner = await barcodeScanner.ClaimScannerAsync();
}
catch (Exception ex)
{
    Debug.WriteLine("EX: ClaimScannerAsync() - " + ex.Message);
}

Conservation de l’appareilRetaining the device

Lorsque vous utilisez un appareil de point de service sur un réseau ou une connexion Bluetooth, vous souhaiterez peut-être partager l’appareil avec d’autres applications sur le réseau.When using a Point of Service device over a network or Bluetooth connection, you may wish to share the device with other apps on the network. (Pour plus d’informations à ce sujet, consultez partage d’appareils.) Dans d’autres cas, vous pouvez souhaiter conserver l’appareil pour une utilisation prolongée.(For more info about this, see Sharing Devices.) In other cases, you may want to hold on to the device for prolonged use. Cet exemple montre comment conserver un scanneur de codes-barres revendiqué après qu’une autre application a demandé que l’appareil soit libéré.This example shows how to retain a claimed barcode scanner after another app has requested that the device be released.

claimedBarcodeScanner.ReleaseDeviceRequested += claimedBarcodeScanner_ReleaseDeviceRequested;

void claimedBarcodeScanner_ReleaseDeviceRequested(object sender, ClaimedBarcodeScanner e)
{
    e.RetainDevice();  // Retain exclusive access to the device
}

Entrée et sortieInput and output

Une fois que vous avez demandé un appareil, vous êtes presque prêt à l’utiliser.After you’ve claimed a device, you’re almost ready to use it. Pour recevoir l’entrée de l’appareil, vous devez configurer et permettre à un délégué de recevoir des données.To receive input from the device, you must set up and enable a delegate to receive data. Dans l’exemple ci-dessous, nous revendiquons un périphérique de scanneur de codes-barres, nous définissons sa propriété Decode, puis nous appelons EnableAsync pour activer l’entrée décodée à partir de l’appareil.In the example below, we claim a barcode scanner device, set its decode property, and then call EnableAsync to enable decoded input from the device. Ce processus varie selon les classes d’appareils. ainsi, pour obtenir des conseils sur la configuration d’un délégué pour les appareils non-code-barres, reportez-vous à l' exemple d’application UWPappropriée.This process varies between device classes, so for guidance about how to set up a delegate for non-barcode devices, refer to the relevant UWP app sample.

try
{
    claimedBarcodeScanner = await barcodeScanner.ClaimScannerAsync();
    if (claimedBarcodeScanner != null)
    {
        claimedBarcodeScanner.DataReceived += claimedBarcodeScanner_DataReceived;
        claimedBarcodeScanner.IsDecodeDataEnabled = true;
        await claimedBarcodeScanner.EnableAsync();
    }
}
catch (Exception ex)
{
    Debug.WriteLine("EX: ClaimScannerAsync() - " + ex.Message);
}


void claimedBarcodeScanner_DataReceived(ClaimedBarcodeScanner sender, BarcodeScannerDataReceivedEventArgs args)
{
    string symbologyName = BarcodeSymbologies.GetName(args.Report.ScanDataType);
    var scanDataLabelReader = DataReader.FromBuffer(args.Report.ScanDataLabel);
    string barcode = scanDataLabelReader.ReadString(args.Report.ScanDataLabel.Length);
}

Partage d’un appareil entre les applicationsSharing a device between apps

Les appareils de point de service sont souvent utilisés dans les cas où plusieurs applications devront y accéder sur une courte période.Point of Service devices are often used in cases where more than one app will need to access them in a brief period. Un appareil peut être partagé lorsqu’il est connecté à plusieurs applications localement (USB ou autre connexion câblée), ou via un réseau Bluetooth ou IP.A device can be shared when connected to multiple apps locally (USB or other wired connection), or through a Bluetooth or IP network. En fonction des besoins de chaque application, un processus peut avoir besoin de supprimer sa revendication sur l’appareil.Depending on the needs of each app, one process may need to dispose of its claim on the device. Ce code supprime notre périphérique de scanneur de codes-barres demandé, ce qui permet à d’autres applications de les revendiquer et de les utiliser.This code disposes of our claimed barcode scanner device, allowing other apps to claim and use it.

if (claimedBarcodeScanner != null)
{
    claimedBarcodeScanner.Dispose();
    claimedBarcodeScanner = null;
}

Notes

Les classes d’appareils de point de service réclamées et non revendiquées implémentent l' interface IClosable.Both the claimed and unclaimed Point of Service device classes implement the IClosable interface. Si un appareil est connecté à une application via réseau ou Bluetooth, les objets revendiqués et non revendiqués doivent être supprimés avant qu’une autre application puisse se connecter.If a device is connected to an app via network or Bluetooth, both the claimed and unclaimed objects must be disposed of before another app can connect.

Voir aussiSee also