Partager via

Prise en main de la technologie de point de service

  • Article

Les appareils de point de service, de point de vente ou de point de service sont des périphériques informatiques utilisés pour faciliter les transactions de vente au détail. Les caisses enregistreuses électroniques, les scanneurs de codes-barres, les lecteurs de bandes magnétiques et les imprimantes de reçus sont des exemples d’appareils de point de service.

Ici, vous allez découvrir les bases de l’interface avec les appareils de point de service à l’aide des API de point de service Windows Runtime. Nous aborderons l’énumération des appareils, la vérification des fonctionnalités de l’appareil, la revendication d’appareils et le partage d’appareils. Nous utilisons un appareil de scanneur de codes-barres comme exemple, mais presque tous les conseils ici s’appliquent à n’importe quel appareil de point de service compatible UWP. (Pour obtenir la liste des appareils pris en charge, consultez Prise en charge des appareils de point de service).

Recherche et connexion à des périphériques de point de service

Pour qu’un appareil point de service puisse être utilisé par une application, il doit être associé au PC sur lequel l’application est en cours d’exécution. Il existe plusieurs façons de se connecter à des appareils de point de service, par programmation ou via l’application Paramètres.

Connexion à des appareils à l’aide de l’application Paramètres

Lorsque vous branchez un appareil de point de service comme un scanneur de codes-barres dans un PC, il s’affiche comme n’importe quel autre appareil. Vous pouvez le trouver dans la section Appareils > Bluetooth & autres appareils de l’application Paramètres. Vous pouvez y associer un appareil de point de service en sélectionnant Ajouter un appareil Bluetooth ou un autre appareil.

Certains appareils point de service peuvent ne pas apparaître dans l’application Paramètres tant qu’ils ne sont pas énumérés par programmation à l’aide des API de point de service.

Obtention d’un seul appareil de point de service avec GetDefaultAsync

Dans un cas d’usage simple, vous pouvez avoir un seul périphérique de point de service connecté au PC sur lequel l’application est en cours d’exécution et que vous souhaitez la configurer aussi rapidement que possible. Pour ce faire, récupérez l’appareil « par défaut » avec la méthode GetDefaultAsync , comme illustré ici.

using Windows.Devices.PointOfService;

BarcodeScanner barcodeScanner = await BarcodeScanner.GetDefaultAsync();

Si l’appareil par défaut est trouvé, l’objet d’appareil récupéré est prêt à être revendiqué. La « revendication » d’un appareil donne à une application un accès exclusif à celui-ci, ce qui empêche les commandes en conflit de plusieurs processus.

Note

Si plusieurs appareils de point de service sont connectés au PC, GetDefaultAsync retourne le premier appareil qu’il trouve. Pour cette raison, utilisez FindAllAsync , sauf si vous êtes sûr qu’un seul appareil de point de service est visible par l’application.

Énumération d’une collection d’appareils avec FindAllAsync

Lorsque vous êtes connecté à plusieurs appareils, vous devez énumérer la collection d’objets d’appareil PointOfService pour trouver celui que vous souhaitez revendiquer. Par exemple, le code suivant crée une collection de tous les scanneurs de codes-barres actuellement connectés, puis recherche dans la collection un scanneur portant un nom spécifique.

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

Étendue de la sélection de l’appareil

Lorsque vous vous connectez à un appareil, vous pouvez limiter votre recherche à un sous-ensemble de périphériques de point de service auxquels votre application a accès. À l’aide de la méthode GetDeviceSelector , vous pouvez définir l’étendue de la sélection pour récupérer des appareils connectés uniquement par une certaine méthode (Bluetooth, USB, etc.). Vous pouvez créer un sélecteur qui recherche des appareils via Bluetooth, IP, Local ou Tous les types de connexion. Cela peut être utile, car la découverte d’appareils sans fil prend beaucoup de temps par rapport à la découverte locale (câblée). Vous pouvez garantir un temps d’attente déterministe pour la connexion d’appareil local en limitant FindAllAsync aux types de connexion locale. Par exemple, ce code récupère tous les scanneurs de codes-barres accessibles via une connexion locale.

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

Réaction aux modifications de connexion d’appareil avec DeviceWatcher

À mesure que votre application s’exécute, des appareils sont parfois déconnectés ou mis à jour, ou de nouveaux appareils doivent être ajoutés. 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. Voici un exemple d’utilisation de DeviceWatcher, avec des stubs de méthode à appeler si un appareil est ajouté, supprimé ou mis à jour.

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 service

Même au sein d’une classe d’appareil, comme les scanneurs de codes-barres, les attributs de chaque appareil peuvent varier considérablement d’un modèle à l’autre. 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. Par exemple, votre entreprise exige peut-être que les étiquettes soient créées à l’aide d’un modèle d’impression de code-barres spécifique. Voici comment vous pouvez case activée pour voir si un scanneur de codes-barres connecté prend en charge une symbologie.

Note

Une symbologie est le mappage de langage utilisé par un code-barres pour encoder les 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.Capabilities

La classe Device.Capabilities est un attribut de toutes les classes d’appareils Point de Service et peut être utilisée pour obtenir des informations générales sur chaque appareil. Par exemple, cet exemple détermine si un appareil prend en charge la création de rapports de statistiques et, le cas échéant, récupère des statistiques pour tous les types pris en charge.

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 appareil de point de service

Avant de pouvoir utiliser un appareil de point de service pour l’entrée ou la sortie active, vous devez le revendiquer, en accordant à l’application un accès exclusif à un grand nombre de ses fonctions. Ce code montre comment revendiquer un appareil 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.

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

Conservation de l’appareil

Lorsque vous utilisez un appareil point de service via un réseau ou une connexion Bluetooth, vous pouvez partager l’appareil avec d’autres applications sur le réseau. (Pour plus d’informations sur ce problème, consultez Partage d’appareils.) Dans d’autres cas, vous pouvez conserver l’appareil pour une utilisation prolongée. 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é.

claimedBarcodeScanner.ReleaseDeviceRequested += claimedBarcodeScanner_ReleaseDeviceRequested;

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

Entrée et sortie

Une fois que vous avez revendiqué un appareil, vous êtes presque prêt à l’utiliser. Pour recevoir des entrées de l’appareil, vous devez configurer et activer un délégué pour recevoir des données. Dans l’exemple ci-dessous, nous réclamons un appareil scanneur de codes-barres, définissons sa propriété de décodage, puis appelons EnableAsync pour activer l’entrée décodée à partir de l’appareil. Ce processus varie d’une classe d’appareil à l’autre. Pour obtenir des conseils sur la configuration d’un délégué pour les appareils sans code-barres, reportez-vous à l’exemple d’application UWP approprié.

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 des applications

Les appareils de point de service sont souvent utilisés dans les cas où plusieurs applications doivent y accéder pendant une courte période. 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. Selon les besoins de chaque application, un processus peut avoir besoin de supprimer sa revendication sur l’appareil. Ce code supprime notre appareil de scanneur de codes-barres revendiqué, ce qui permet à d’autres applications de le revendiquer et de l’utiliser.

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

Note

Les classes d’appareils point de service revendiquées et non réclamées implémentent l’interface IClosable. Si un appareil est connecté à une application via un réseau ou bluetooth, les objets revendiqués et non réclamés doivent être supprimés avant qu’une autre application puisse se connecter.

Voir aussi