Delen via

PosKeyboard-implementatie (POS voor .NET v1.14 SDK-documentatie)

Een PosKeyboard-serviceobject leest sleutels van een POS-toetsenbord. Een POS-toetsenbord kan een hulptoetsenbord zijn of een virtueel toetsenbord dat bestaat uit enkele of alle toetsen op het systeemtoetsenbord. In Microsoft Point of Service voor .NET (POS voor .NET) is de POS-toetsenbord Basisklasse PosKeyboardBase.

Een PosKeyboard-serviceobject volgt het algemene invoerapparaatmodel:

  • Wanneer invoer wordt ontvangen van het POS-toetsenbord, wordt een DataEvent in de wachtrij geplaatst.
  • Als de eigenschap AutoDisablewaar is, schakelt het apparaat zichzelf automatisch uit wanneer een DataEvent-gebeurtenis in de wachtrij wordt geplaatst. Dit wordt automatisch gedaan door de klasse PosKeyboardBase .
  • Een DataEvent-gebeurtenis in de wachtrij wordt aan de toepassing geleverd wanneer de eigenschap DataEventEnabledwaar is en aan andere vereisten voor levering van gebeurtenissen wordt voldaan. De PosKeyboardBase-klasse beheert de levering van gebeurtenissen automatisch.
  • Een ErrorEvent-gebeurtenis wordt in de wachtrij geplaatst als er een fout optreedt tijdens het verzamelen of verwerken van invoer en aan de toepassing wordt geleverd wanneer DataEventEnabledwaar is en aan andere vereisten voor levering van gebeurtenissen wordt voldaan.
  • De eigenschap DataCount , die wordt onderhouden door de Klasse PosKeyboardBase , kan worden gelezen om het aantal gebeurtenissen in de wachtrij te verkrijgen.
  • Alle invoer in de wachtrij kan worden verwijderd door aan te roepen ClearInput().

Het POS-toetsenbord is een exclusief apparaat:

  • De toepassing moet het apparaat claimen voordat het wordt ingeschakeld.
  • De toepassing moet het apparaat claimen en inschakelen voordat het apparaat begint met het lezen van invoer.

Deze sectie bevat een voorbeeld van een PosKeyboard-serviceobject waarmee gesimuleerde toetsaanslagen worden gegenereerd die met behulp van DataEvents naar de toepassing worden verzonden. Dit voorbeeld is afhankelijk van het thread-helper-object zoals geïntroduceerd in Introductie van Service Object Reader Threads. Als u dit voorbeeld wilt compileren, moet u de code uit dat onderwerp opnemen.

Een serviceobject schrijven

  1. Voeg using-instructies toe voor Microsoft.PointofService, Microsoft.PointOfService.BaseServiceObjects en System.Threading.

  2. Voeg het globale kenmerk PosAssembly toe.

  3. Kies een geschikte naamruimtenaam voor uw project.

  4. Maak een serviceobjectklasse die is afgeleid van PosKeyboardBase.

  5. Voeg het ServiceObject kenmerk toe aan uw serviceobjectklasse, met behulp van de waarde DeviceType.PosKeyboard als apparaattype.

Functies toevoegen aan het voorbeeldtoetsenbordserviceobject

  1. Maak een thread-helperklasse, KeyboardThreadingObject, afgeleid van ServiceObjectThreadHelper uit de sectie ServiceObject Read Threads .

  2. Implementeer de methode ServiceObjectThreadProcedure in de klasse KeyboardThreadingObject . Dit is de procedure die wordt uitgevoerd op een afzonderlijke thread. In de onderstaande voorbeeldcode simuleert deze methode toetsenbordinvoer.

  3. Deze voorbeeldklasse implementeert een methode met de naam SendKey en een andere met de naam ChangePowerState. Deze methoden zijn wrappers rond beveiligde leden. Omdat ze zijn beveiligd, kunnen ze niet rechtstreeks vanuit het threading-object worden aangeroepen.

  4. Overschrijf de methode PosCommon.Open om mogelijkheden op te geven die door dit serviceobject worden ondersteund en maak een nieuw thread-helper-object.

  5. Overschrijf PosCommon.DeviceEnable specifiek om de thread-helper te openen en te sluiten.

  6. Implementeer de abstracte virtuele methoden van PosCommon, met minimale functionaliteit.

De toepassing uitvoeren

Dit voorbeeldserviceobject kan worden uitgevoerd in combinatie met de testtoepassing die wordt geleverd met de POS voor .NET Software Development Kit (SDK).

Het serviceobject testen

  1. Start de testtoepassing en selecteer SamplePosKeyboard in de vervolgkeuzelijst Toetsenbord .

  2. Open en Claim het apparaat, en selecteer vervolgens het apparaat met het selectievakje DeviceEnabled om het in te schakelen.

  3. Als u het selectievakje DataEventEnabled uitschakelt, kan het serviceobject één gesimuleerde sleutel naar de toepassing verzenden. DataEvent wordt automatisch in de wachtrij geplaatst door PosKeyboardBase wanneer KeyDown wordt aangeroepen.

  4. Als u het vak Gegevens gebeurtenissen automatisch inschakelen selecteert, kan het Service Object tekens met tussenpozen van twee seconden blijven leveren.

  5. Het serviceobject verzendt gesimuleerde toetsstreken voor tekens 'a' tot en met 'z'. Daarna wordt een StatusUpdateEvent-gebeurtenis verzonden die aangeeft dat het apparaat nu offline is. Deze gebeurtenis wordt automatisch verzonden door de klasse PosKeyboardBase wanneer Properties.PowerState wordt gewijzigd.

Example

In dit voorbeeld ziet u hoe u een eenvoudig PosKeyboard-serviceobject ontwikkelt. Het ondersteunt een afzonderlijke lezerthread om DataEvents asynchroon naar de toepassing te verzenden. Zodra het is gecompileerd, kunt u het serviceobject uitvoeren in combinatie met de testtoepassing die is opgenomen in de POS voor .NET SDK.

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

using Microsoft.PointOfService;
using Microsoft.PointOfService.BaseServiceObjects;

[assembly: PosAssembly("Service Object Contractors, Inc.")]

namespace SOSamples.Keyboard
{
    [ServiceObject(
            DeviceType.PosKeyboard,
            "SamplePosKeyboard",
            "Sample PosKeyboard Service Object",
            1,
            9)]

    public class SampleKeyboard : PosKeyboardBase
    {
        KeyboardThreadingObject ReadThread = null;

        public SampleKeyboard()
        {
            // DevicePath must be set before Open() is called.
            // In the case of Play and Plug hardware, the
            // POS for .NET Base class will set this value.
            DevicePath = "Sample Keyboard";

            // NOTE: You can test the power notification events
            // sent from this Service Object by selecting the
            // "Power Notify" check box.

            // Let the application know advanced power
            // reporting is supported.
            Properties.CapPowerReporting = PowerReporting.Advanced;
            Properties.CapKeyUp = false;
        }

        ~SampleKeyboard()
        {
            // Code added from previous sections to terminate
            // the read thread started by the thread-helper
            // object.
            if (ReadThread != null)
            {
                ReadThread.CloseThread();
            }

            Dispose(false);
        }

        // Expose the protected KeyDown() method so that it can be
        // called from our threading helper.
        public void SendKey(int key)
        {
            KeyDown(key);
        }

        // Expose the protected PowerState property so it can be
        // changed from the threading helper.
        public void ChangePowerState(PowerState state)
        {
            Properties.PowerState = state;
        }

        #region Override Virtual PosCommon Members
        public override void Open()
        {
            base.Open();

            // Create the reader-thread object.
            ReadThread = new KeyboardThreadingObject(this);
        }

        public override bool DeviceEnabled
        {
            get
            {
                return base.DeviceEnabled;
            }
            set
            {
                if (value != base.DeviceEnabled)
                {
                    base.DeviceEnabled = value;

                    if (value == false)
                    {
                        // Stop the reader thread when the device
                        // is disabled.
                        ReadThread.CloseThread();
                    }
                    else
                    {
                        try
                        {
                            // By enabling the device, start the
                            // reader thread.
                            ReadThread.OpenThread();
                        }
                        catch (Exception e)
                        {
                            base.DeviceEnabled = false;

                            if (e is PosControlException)
                                throw;

                            throw new PosControlException(
                                    "Unable to Enable Device",
                                    ErrorCode.Failure, e);
                        }
                    }
                }
            }
        }
        #endregion Override Virtual PosCommon Members

        #region Implement Abstract PosCommon Members
        private string MyHealthText = "";

        // PosCommon.CheckHealthText.
        public override string CheckHealthText
        {
            get
            {
                // VerifyState(mustBeClaimed,
                // mustBeEnabled).
                VerifyState(false, false);
                return MyHealthText;
            }
        }

        //  PosCommon.CheckHealth.
        public override string CheckHealth(
                        HealthCheckLevel level)
        {
            // Verify that device is open, claimed and enabled.
            VerifyState(true, true);

            // Your code here:
            // Check the health of the device and return a
            // descriptive string.

            // Cache result in the CheckHealthText property.
            MyHealthText = "Ok";
            return MyHealthText;
        }

        // PosCommon.DirectIOData.
        public override DirectIOData DirectIO(
                                int command,
                                int data,
                                object obj)
        {
            // Verify that the device is open.
            VerifyState(false, false);

            return new DirectIOData(data, obj);
        }
        #endregion  Implement Abstract PosCommon Members
    }

    #region Thread Helper Class
    public class KeyboardThreadingObject :
        ServiceObjectThreadHelper, IDisposable
    {
        // This is a helper class which will depend on
        // being able to call back into the actual Service
        // Object to pass along data. However, you cannot
        // keep a strong reference to the Service Object,
        // since that may prevent clean disposal, leaving
        // hardware resources unavailable to other processes.
        // Therefore, you create a weak reference. From this
        // reference, you can get a temporary strong reference,
        // which you can act on and then release.
        WeakReference ServiceObjectReference;

        // The name of the Service Object.
        string ObjectName;

        public KeyboardThreadingObject(SampleKeyboard so)
        {
            ObjectName = GetType().Name;
            ServiceObjectReference = new WeakReference(so);
        }

        // This method will be called during initialization.
        public override void ServiceObjectThreadOpen()
        {
            Logger.Info(ObjectName, "Keyboard Thread Open");
        }

        // This method will be called curing shutdown.
        public override void ServiceObjectThreadClose()
        {
            Logger.Info(ObjectName, "Keyboard Thread Open");
        }

        // Your code used to monitor your device for input should
        // go here. The implementation below generates simulated
        // input as an example.
        public override void ServiceObjectThreadProcedure(
                            AutoResetEvent ThreadStopEvent)
        {
            Logger.Info(ObjectName,
                            "Keyboard Thread Procedure Entered");
            int KeyValue = (int)'a';

            while (true)
            {
                // When this method is called by the
                // ServiceObjectThreadHelper, it is obligated to
                // exit when the event ThreadStopEvent has been
                // set.
                if (ThreadStopEvent.WaitOne(2000, false))
                {
                    break;
                }

                if (KeyValue <= (int) 'z')
                {
                    Logger.Info(ObjectName, "Reader Thread cycling");

                    // Try to get a strong reference to the Service
                    // Object using the weak reference saved when
                    // this helper object was created.
                    SampleKeyboard Keyboard =
                        ServiceObjectReference.Target
                        as SampleKeyboard;

                    // If this fails, that means the Service Object
                    // has already been disposed of - exit the thread.
                    if (Keyboard == null)
                    {
                        break;
                    }

                    if (Keyboard.DataEventEnabled == true)
                    {
                        // Call a method implemented in our Keyboard
                        // class to queue the key stroke.
                        Keyboard.SendKey(KeyValue);

                        // Simulate input by moving through the
                        // alphabet, sending one character at a time.
                        KeyValue++;
                        if (KeyValue >= (int)'z')
                        {
                            // Once you run out of input, simulate a
                            // power state change. Setting the SO's
                            // PowerState property to
                            // PowerState.Offline will cause a
                            // StatusUpdateEvent to be sent to the
                            // application.
                            Keyboard.ChangePowerState(
                                            PowerState.Offline);

                            // Release the strong reference.
                            Keyboard = null;

                            // There is no more work, so exit the
                            // loop.
                            break;
                        }
                    }

                    // Release the strong reference.
                    Keyboard = null;
                }
            }
        }
    }
    #endregion Thread Helper Class
}

De code compileren

Zie ook

Tasks

Andere hulpbronnen

  • Last updated on