jpos.PINPad Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javapos-controls Show documentation
Show all versions of javapos-controls Show documentation
JavaPOS Device Controls Library
//////////////////////////////////////////////////////////////////////
//
// The JavaPOS library source code is now under the CPL license, which
// is an OSS Apache-like license. The complete license is located at:
// http://www.ibm.com/developerworks/library/os-cpl.html
//
//////////////////////////////////////////////////////////////////////
//------------------------------------------------------------------------------
//
// This software is provided "AS IS". The JavaPOS working group (including
// each of the Corporate members, contributors and individuals) MAKES NO
// REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NON-INFRINGEMENT. The JavaPOS working group shall not be liable for
// any damages suffered as a result of using, modifying or distributing this
// software or its derivatives.Permission to use, copy, modify, and distribute
// the software and its documentation for any purpose is hereby granted.
//
// PINPad.java - A JavaPOS 1.6.0 device control
//
//------------------------------------------------------------------------------
package jpos;
import jpos.events.*;
import jpos.services.*;
import java.util.Vector;
import jpos.loader.*;
public class PINPad
implements PINPadControl16, JposConst
{
//--------------------------------------------------------------------------
// Variables
//--------------------------------------------------------------------------
// Static Data
protected static final String deviceControlDescription =
"JavaPOS PINPad Device Control";
protected static final int deviceControlVersion = 1006000; // 1.6.0
protected static final int deviceVersion13 = 1003000; // 1.3.0
protected static final int deviceVersion14 = 1004000; // 1.4.0
protected static final int deviceVersion15 = 1005000; // 1.5.0
protected static final int deviceVersion16 = 1006000; // 1.6.0
// Instance Data
protected JposServiceConnection serviceConnection;
protected int serviceVersion;
protected PINPadService13 service13;
protected PINPadService14 service14;
protected PINPadService15 service15;
protected PINPadService16 service16;
protected Vector dataListeners;
protected Vector directIOListeners;
protected Vector errorListeners;
protected Vector statusUpdateListeners;
//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
public PINPad()
{
serviceConnection = null;
service13 = null;
service14 = null;
service15 = null;
service16 = null;
dataListeners = new Vector();
directIOListeners = new Vector();
errorListeners = new Vector();
statusUpdateListeners = new Vector();
}
//--------------------------------------------------------------------------
// Capabilities
//--------------------------------------------------------------------------
public int getCapDisplay()
throws JposException
{
try
{
return service13.getCapDisplay();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getCapLanguage()
throws JposException
{
try
{
return service13.getCapLanguage();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getCapKeyboard()
throws JposException
{
try
{
return service13.getCapKeyboard();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getCapMACCalculation()
throws JposException
{
try
{
return service13.getCapMACCalculation();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getCapPowerReporting()
throws JposException
{
try
{
return service13.getCapPowerReporting();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getCapTone()
throws JposException
{
try
{
return service13.getCapTone();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
//--------------------------------------------------------------------------
// Properties
//--------------------------------------------------------------------------
public String getCheckHealthText()
throws JposException
{
try
{
return service13.getCheckHealthText();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getClaimed()
throws JposException
{
try
{
return service13.getClaimed();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getDeviceControlDescription()
{
return deviceControlDescription;
}
public int getDeviceControlVersion()
{
return deviceControlVersion;
}
public boolean getDeviceEnabled()
throws JposException
{
try
{
return service13.getDeviceEnabled();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setDeviceEnabled(boolean deviceEnabled)
throws JposException
{
try
{
service13.setDeviceEnabled(deviceEnabled);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getDeviceServiceDescription()
throws JposException
{
try
{
return service13.getDeviceServiceDescription();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getDeviceServiceVersion()
throws JposException
{
try
{
return service13.getDeviceServiceVersion();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getFreezeEvents()
throws JposException
{
try
{
return service13.getFreezeEvents();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setFreezeEvents(boolean freezeEvents)
throws JposException
{
try
{
service13.setFreezeEvents(freezeEvents);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getPhysicalDeviceDescription()
throws JposException
{
try
{
return service13.getPhysicalDeviceDescription();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getPhysicalDeviceName()
throws JposException
{
try
{
return service13.getPhysicalDeviceName();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getState()
{
try
{
return service13.getState();
}
catch(Exception e)
{
return JPOS_S_CLOSED;
}
}
public String getAccountNumber()
throws JposException
{
try
{
return service13.getAccountNumber();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setAccountNumber(String accountNumber)
throws JposException
{
try
{
service13.setAccountNumber(accountNumber);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getAdditionalSecurityInformation()
throws JposException
{
try
{
return service13.getAdditionalSecurityInformation();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public long getAmount()
throws JposException
{
try
{
return service13.getAmount();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setAmount(long amount)
throws JposException
{
try
{
service13.setAmount(amount);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getAvailableLanguagesList()
throws JposException
{
try
{
return service13.getAvailableLanguagesList();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getAvailablePromptsList()
throws JposException
{
try
{
return service13.getAvailablePromptsList();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getDataCount()
throws JposException
{
try
{
return service13.getDataCount();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getDataEventEnabled()
throws JposException
{
try
{
return service13.getDataEventEnabled();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setDataEventEnabled(boolean dataEventEnabled)
throws JposException
{
try
{
service13.setDataEventEnabled(dataEventEnabled);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getEncryptedPIN()
throws JposException
{
try
{
return service13.getEncryptedPIN();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getMaximumPINLength()
throws JposException
{
try
{
return service13.getMaximumPINLength();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setMaximumPINLength(int maximumPINLength)
throws JposException
{
try
{
service13.setMaximumPINLength(maximumPINLength);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getMerchantID()
throws JposException
{
try
{
return service13.getMerchantID();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setMerchantID(String merchantID)
throws JposException
{
try
{
service13.setMerchantID(merchantID);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getMinimumPINLength()
throws JposException
{
try
{
return service13.getMinimumPINLength();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setMinimumPINLength(int minimumPINLength)
throws JposException
{
try
{
service13.setMinimumPINLength(minimumPINLength);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public boolean getPINEntryEnabled()
throws JposException
{
try
{
return service13.getPINEntryEnabled();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getPowerNotify()
throws JposException
{
try
{
return service13.getPowerNotify();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setPowerNotify(int powerNotify)
throws JposException
{
try
{
service13.setPowerNotify(powerNotify);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getPowerState()
throws JposException
{
try
{
return service13.getPowerState();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getPrompt()
throws JposException
{
try
{
return service13.getPrompt();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setPrompt(int propmpt)
throws JposException
{
try
{
service13.setPrompt(propmpt);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getPromptLanguage()
throws JposException
{
try
{
return service13.getPromptLanguage();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setPromptLanguage(String promptLanguage)
throws JposException
{
try
{
service13.setPromptLanguage(promptLanguage);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public String getTerminalID()
throws JposException
{
try
{
return service13.getTerminalID();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setTerminalID(String terminalID)
throws JposException
{
try
{
service13.setTerminalID(terminalID);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public byte[] getTrack1Data()
throws JposException
{
try
{
return service13.getTrack1Data();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setTrack1Data(byte[] track1Data)
throws JposException
{
try
{
service13.setTrack1Data(track1Data);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public byte[] getTrack2Data()
throws JposException
{
try
{
return service13.getTrack2Data();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setTrack2Data(byte[] track2Data)
throws JposException
{
try
{
service13.setTrack2Data(track2Data);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public byte[] getTrack3Data()
throws JposException
{
try
{
return service13.getTrack3Data();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setTrack3Data(byte[] track3Data)
throws JposException
{
try
{
service13.setTrack3Data(track3Data);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public int getTransactionType()
throws JposException
{
try
{
return service13.getTransactionType();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void setTransactionType(int transactionType)
throws JposException
{
try
{
service13.setTransactionType(transactionType);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public byte[] getTrack4Data()
throws JposException
{
// Attempt call to service if:
// 1. The service supports the necessary service interface version
// 2. The service is not open (this insures we fire the correct exception)
if((service13 == null) || (serviceVersion >= deviceVersion15))
{
try
{
return service15.getTrack4Data();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
else
{
throw new JposException(JPOS_E_NOSERVICE,
"Service does not support the PINPadControl15 interface");
}
}
public void setTrack4Data(byte[] track4Data)
throws JposException
{
// Attempt call to service if:
// 1. The service supports the necessary service interface version
// 2. The service is not open (this insures we fire the correct exception)
if((service13 == null) || (serviceVersion >= deviceVersion15))
{
try
{
service15.setTrack4Data(track4Data);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
else
{
throw new JposException(JPOS_E_NOSERVICE,
"Service does not support the PINPadControl15 interface");
}
}
//--------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------
public void claim(int timeout)
throws JposException
{
try
{
service13.claim(timeout);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public synchronized void close()
throws JposException
{
try
{
service13.close();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED,
"Service not open",
e);
}
try
{
serviceConnection.disconnect();
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Unable to free service connection",
e);
}
finally
{
service13 = null;
service14 = null;
service15 = null;
service16 = null;
}
}
public void checkHealth(int level)
throws JposException
{
try
{
service13.checkHealth(level);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void directIO(int command, int[] data, Object object)
throws JposException
{
try
{
service13.directIO(command, data, object);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public synchronized void open(String logicalDeviceName)
throws JposException
{
// Make sure the control is not already open
if(service13 != null)
{
throw new JposException(JPOS_E_ILLEGAL,
"Device control already open");
}
// Use JCL to get a connection to the device service
try
{
serviceConnection = JposServiceLoader.findService(logicalDeviceName);
serviceConnection.connect();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Could not connect to service",
e);
}
// Get an instance of the minimum service level supported
try
{
service13 = (PINPadService13)serviceConnection.getService();
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Could not get service instance",
e);
}
// Get service version
try
{
serviceVersion = service13.getDeviceServiceVersion();
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Could not get service version information",
e);
}
// Make sure that the service actually conforms to the interfaces it
// claims to.
if(serviceVersion >= deviceVersion14)
{
try
{
service14 = (PINPadService14)service13;
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Service does not fully implement PINPadDevice14 interface",
e);
}
}
if(serviceVersion >= deviceVersion15)
{
try
{
service15 = (PINPadService15)service13;
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Service does not fully implement PINPadDevice15 interface",
e);
}
}
if(serviceVersion >= deviceVersion16)
{
try
{
service16 = (PINPadService16)service13;
}
catch(Exception e)
{
throw new JposException(JPOS_E_NOSERVICE,
"Service does not fully implement PINPadDevice16 interface",
e);
}
}
// Create callback subclass and attach it to the device service
PINPadCallbacks callbacks = this.new PINPadCallbacks();
service13.open(logicalDeviceName, callbacks);
}
public void release()
throws JposException
{
try
{
service13.release();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void beginEFTTransaction(String PINPadSystem, int transactionHost)
throws JposException
{
try
{
service13.beginEFTTransaction(PINPadSystem, transactionHost);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void clearInput()
throws JposException
{
try
{
service13.clearInput();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void computeMAC(String inMsg, String[] outMsg)
throws JposException
{
try
{
service13.computeMAC(inMsg, outMsg);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void enablePINEntry()
throws JposException
{
try
{
service13.enablePINEntry();
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void endEFTTransaction(int completionCode)
throws JposException
{
try
{
service13.endEFTTransaction(completionCode);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void updateKey(int keyNum, String key)
throws JposException
{
try
{
service13.updateKey(keyNum, key);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
public void verifyMAC(String message)
throws JposException
{
try
{
service13.verifyMAC(message);
}
catch(JposException je)
{
throw je;
}
catch(Exception e)
{
throw new JposException(JPOS_E_CLOSED, "Control not opened", e);
}
}
//--------------------------------------------------------------------------
// Event Listener Methods
//--------------------------------------------------------------------------
public void addDataListener(DataListener l)
{
synchronized(dataListeners)
{
dataListeners.addElement(l);
}
}
public void removeDataListener(DataListener l)
{
synchronized(dataListeners)
{
dataListeners.removeElement(l);
}
}
public void addDirectIOListener(DirectIOListener l)
{
synchronized(directIOListeners)
{
directIOListeners.addElement(l);
}
}
public void removeDirectIOListener(DirectIOListener l)
{
synchronized(directIOListeners)
{
directIOListeners.removeElement(l);
}
}
public void addErrorListener(ErrorListener l)
{
synchronized(errorListeners)
{
errorListeners.addElement(l);
}
}
public void removeErrorListener(ErrorListener l)
{
synchronized(errorListeners)
{
errorListeners.removeElement(l);
}
}
public void addStatusUpdateListener(StatusUpdateListener l)
{
synchronized(statusUpdateListeners)
{
statusUpdateListeners.addElement(l);
}
}
public void removeStatusUpdateListener(StatusUpdateListener l)
{
synchronized(statusUpdateListeners)
{
statusUpdateListeners.removeElement(l);
}
}
//--------------------------------------------------------------------------
// EventCallbacks inner class
//--------------------------------------------------------------------------
protected class PINPadCallbacks implements EventCallbacks
{
public BaseControl getEventSource()
{
return (BaseControl)PINPad.this;
}
public void fireDataEvent(DataEvent e)
{
synchronized(PINPad.this.dataListeners)
{
// deliver the event to all registered listeners
for(int x = 0; x < dataListeners.size(); x++)
{
((DataListener)dataListeners.elementAt(x)).dataOccurred(e);
}
}
}
public void fireDirectIOEvent(DirectIOEvent e)
{
synchronized(PINPad.this.directIOListeners)
{
// deliver the event to all registered listeners
for(int x = 0; x < directIOListeners.size(); x++)
{
((DirectIOListener)directIOListeners.elementAt(x)).directIOOccurred(e);
}
}
}
public void fireErrorEvent(ErrorEvent e)
{
synchronized(PINPad.this.errorListeners)
{
// deliver the event to all registered listeners
for(int x = 0; x < errorListeners.size(); x++)
{
((ErrorListener)errorListeners.elementAt(x)).errorOccurred(e);
}
}
}
public void fireOutputCompleteEvent(OutputCompleteEvent e)
{
}
public void fireStatusUpdateEvent(StatusUpdateEvent e)
{
synchronized(PINPad.this.statusUpdateListeners)
{
// deliver the event to all registered listeners
for(int x = 0; x < statusUpdateListeners.size(); x++)
{
((StatusUpdateListener)statusUpdateListeners.elementAt(x)).statusUpdateOccurred(e);
}
}
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy