Appendix A: Java Class Definitions

This appendix lists the templates used to create objects and to define object types and methods:

com.elavon.commerce.datatype.ECLAVSField

package com.elavon.commerce.datatype;

/// \brief Values used in AVS processing
@SupportedSince(Version = "4.0.0")
public enum ECLAVSField
{
    CARDHOLDER_FIRST_NAME, ///< cardholder first name
    CARDHOLDER_LAST_NAME, ///< cardholder last name
    CARDHOLDER_ADDRESS, ///< cardholder address
    CARDHOLDER_CITY, ///< cardholder city
    CARDHOLDER_STATE, ///< cardholder state
    CARDHOLDER_ZIP, ///< cardholder zip code
    CARDHOLDER_COUNTRY, ///< cardholder country
    CARDHOLDER_EMAIL, ///< cardholder email.  Note this field is not related to AVS processing.  See the integration guide for more details.
}

com.elavon.commerce.datatype.ECLConnectionType

// Supported device connection types for device search.
@SupportedSince(Version = "4.0.0")
public enum ECLConnectionType
{
    USB,          ///< USB connectivity type
    BT,           ///< Bluetooth connectivity type
    IP,           ///< IP connectivity type - supported for Ingenico RBA/UPP card readers only
    PERIPHERAL,   ///< Integrated device type
    AUDIO,        ///< Audio connectivity type - supported for Ingenico Roam RUA card readers only
    ;
}

com.elavon.commerce.datatype.ECLCurrencyCode

package com.elavon.commerce.datatype;

// Supported currency codes (ISO 4217) for specifying monetary amounts.
@SupportedSince(Version = "2.4.0")
public enum ECLCurrencyCode implements Serializable
{
    CAD(2), // Canadian Dollar
    EUR(2), // Euro
    GBP(2), // British Pound
    PLN(2),
    USD(2), // US Dollar
    UNKNOWN(0),
    UNSET(-1);

    // Defines currency type with number of digits for fraction
    // @param fractionDigits number of digits for fraction
    ECLCurrencyCode(int fractionDigits);

    // Gets the number of fractional digits (or decimal places) associated with the given currency code.
    // @return number of fractional (decimal) digits associated with the currency code.
    public int getFractionDigits();

    // Gets a defined currency code based on its string representation.
    // @param currencyCodeAsString String representation (e.g., "USD") of currency code.

    // @return instance of ECLCurrencyCode.
    public static ECLCurrencyCode getCurrencyCodeFromString(String currencyCodeAsString);
}

com.elavon.commerce.datatype.ECLDeviceType

package com.elavon.commerce.datatype;

// Supported device types for device search.
@SupportedSince(Version = "3.0.0")
public enum ECLDeviceType
{
    CARD_READER,    // Device type of card reader
    CHECK_READER,   // Device type of check reader
    PRINTER;        // Device type of printer
}

com.elavon.commerce.datatype.ECLMoney

package com.elavon.commerce.datatype;

// Representation of monetary amounts with a currency code (ECLCurrencyCode - ISO 4217) and a value in minor units.
//
// $10.95 USD would be specified as a minor units value of 1095 and a currency code of USD.
//
// £0.10 GBP would be specified as a minor units value of 10 and a currency code of GBP.
//
// $0.00 USD would be specified as a minor units value of 0 and a currency code of USD.
@SupportedSince(Version = "3.0.0")
public class ECLMoney implements Serializable
{
    // Constructor for defining monetary amounts.
    // @param currencyCode Currency code as an instance of ECLCurrencyCode
    // @param amountInMinorUnits Amount in minor units.
    // @throws IllegalArgumentException if amountInMinorUnits is less than 0.
    public ECLMoney(com.elavon.commerce.datatype.ECLCurrencyCode currencyCode, long amountInMinorUnits) throws IllegalArgumentException;

    // Constructor for defining monetary amounts.
    // @param currencyCode Currency code as an instance of ECLCurrencyCode
    // @param amount Regular amount.
    // @throws IllegalArgumentException if currencyCode is null or amountInMinorUnits is less than 0.
    public ECLMoney(ECLCurrencyCode currencyCode, double amount) throws IllegalArgumentException;

    // Gets the monetary amount in minor units.
    // @return amount in minor units.
    public long getAmount();

    // Gets the currency code associated with the monetary amount.
    // @return instance of ECLCurrencyCode
    public ECLCurrencyCode getCurrencyCode();

    // Constructs the string presentation of this class
    // @return the string presentation in format of [CurrencyCode],[AmountInMinorUnit].
    public String presentation();
}

Reference

com.elavon.commerce.datatype.ECLTaxType

package com.elavon.commerce.datatype;

// Supported tax types. For the general case, TAX_SALE_GENERAL should be used.
// However, there are territories where different & multiple taxes are needed - for example Puerto Rico.
@SupportedSince(Version = "4.0.0")
public enum ECLTaxType
{
    SALE_GENERAL,   // General tax type
    IVU_STATE,
    IVU_MUNICIPALITY
}

com.elavon.commerce.datatype.ECLTransactionAuthorizationMode

package com.elavon.commerce.datatype;

// Transaction authorization mode
@SupportedSince(Version = "4.7.0")
public enum ECLTransactionAuthorizationMode
{
    ISSUER, ///< Transaction is authorized online by issuer.
    CARD    ///< Transaction is authorized offline by card.
}

com.elavon.commerce.datatype.ECLTransactionAuthorizationResult

package com.elavon.commerce.datatype;
 
// Enum for transaction result
@SupportedSince(Version = "2.4.0")
public enum ECLTransactionAuthorizationResult
{
    UNKNOWN,
    UNSET,
    APPROVED,
    APPROVED_OFFLINE,
    PARTIALLY_APPROVED,
    SWIPED_SUCCESSFULLY,  /* for non-processing case where card reader is being used solely to retrieve swipe data */
    SECURITY_CODE_FAILURE,
    DECLINED,
    VOICE_REFERRAL,
    REJECTED,
    TEMPORARILY_UNAVAILABLE,
    EXPIRED_CARD,
    PRE_VALID_CARD,
    FAILED_LUHN_CHECK,
    ISSUE_NUMBER_MISSING,
    ISSUE_NUMBER_INVALID,
    UNKNOWN_ACQUIRER,
    ACQUIRER_DISABLED,
    UNKNOWN_MERCHANT,
    UNKNOWN_TERMINAL,
    MERCHANT_DISABLED,
    CARD_BLACKLISTED,
    CARD_BLOCKED,
    CARD_USAGE_EXCEEDED_LIMITS,
    CARD_USAGE_EXCEEDED_COUNT, /* too many attempts in a time interval (mainly for contactless) */
    CARD_SCHEME_UNKNOWN,
    AMOUNT_MISSING,
    AMOUNT_ERROR,
    AMOUNT_TOO_SMALL,
    AMOUNT_TOO_LARGE,
    CURRENCY_CODE_MISSING,
    UNKNOWN_CURRENCY_CODE,
    UNSUPPORTED_CURRENCY_CODE,
    APPL_TYPE_ERROR,
    SYSTEM_ERROR,
    INCORRECT_PIN,
    INVALID_CARD,
    INVALID_CAVV,
    INVALID_ROUTING_NUMBER,
    INVALID_SERVICE_ENTITLEMENT_NUMBER,
    MICR_READ_ERROR,
    OPEN_BATCH_TOO_OLD,
    SEQUENCE_ERROR,
    EXCEEDED_NUMBER_OF_CHECKS,
    MAXIMUM_AMOUNT_LOADED_ON_CARD,
    CARD_NOT_RELOADABLE,
    TRANSACTION_NOT_ALLOWED,
    INVALID_TRANSACTION_TYPE,
    CARD_ALREADY_ACTIVE,
    CARD_NOT_ACTIVE,
    DUPLICATE_TRANSACTION,
    INVALID_BATCH_ID,
    INVALID_TENDER,
    INVALID_DATA,
    DUPLICATE_CHECK_NUMBER,
    MAXIMUM_VOLUME_REACHED,
    INVALID_SERVICE,
    ISSUER_NEEDS_TO_BE_CONTACTED,
    ENGINEERS_TEST,
    OFFLINE_NOT_ALLOWED,
    DECLINED_CONTACT_SUPPORT_CENTER,
    DECLINED_BY_CARD,
    EMV_POST_AUTH_ERROR,
    DECLINED_DUE_TO_COMMUNICATION_ERROR,
    AVS_MISMATCH,
    SCHEDULED_FOR_SETTLEMENT,
    EMPTY_BATCH,
    CASHBACK_UNAVAILABLE,
    CASHBACK_AMOUNT_LIMIT_EXCEEDED,
    PIN_ENTRY_LIMIT_EXCEEDED,
    INVALID_TRANSACTION,
    INVALID_SURCHARGE,
    WITHDRAWAL_LIMIT_EXCEEDED,
    RESTRICTED_CARD,
    DECLINED_BLOCKED,
    DECLINED_NON_SUFFICIENT_FUNDS,
    STOP_PAYMENT,
    STOP_ORDER,
    STOP_ALL_ORDERS;
 
    // Does the result indicate some type of approval?
    // @param result the txn result
    // @return whether or not the result param was one of the approval variants
    public static boolean isApproved(ECLTransactionAuthorizationResult result);
}

com.elavon.commerce.datatype.ECLTriState

package com.elavon.commerce.datatype;

@SupportedSince(Version = "3.0.0")
public enum ECLTriState
{
    YES,
    NO,
    UNKNOWN
}

com.elavon.commerce.ECCError

package com.elavon.commerce;
 
public abstract class ECCError
{
    // Gets nested error lists
    public List<ECCError> getNestedErrors();
}

com.elavon.commerce.ECCSensitiveData

package com.elavon.commerce;

// This class can used to keep critical data in encrypted form in memory
@SupportedSince(Version = "2.4.0")
public class ECCSensitiveData
{
    // Instantiates an instance of ECCSensitiveData keeping the encrypted form for a string
    public ECCSensitiveData(String newData);

    // Instantiates an instance of ECCSensitiveData keeping the encrypted form for a byte array
    public ECCSensitiveData(byte[] newData);

    // Instantiates an instance of ECCSensitiveData keeping nothing
    public ECCSensitiveData();

    // Instantiates an instance of ECCSensitiveData keeping the already encrypted byte array and the key used to generate the encrypted data
    public ECCSensitiveData(byte[] encryptedData, byte[] keyRandomData);

    // Decrypts the encrypted data and return the data in form of StringBuilder
    public StringBuilder decrypt();

    // Decrypts the encrypted data and return the data in form of String
    // This method is strongly discouraged because string is immutable
    public String getData();

    // Decrypts the encrypted data and return the data in form of byte array
    public byte[] getDataInRawForm();

    // Get the encrypted data

    public byte[] getCipherText();

    // Gets the encryption key
    public byte[] getKeyRandomData();

    // Clears the encrypted data being kept here
    public void clear();

    // Gets the length of the original data
    public int getLength();
}

com.elavon.commerce.ECCSensitiveDataInterface

package com.elavon.commerce;
 
/// \brief Defines an interface for keeping sensitive data in an encrypted form
@SupportedSince(Version="5.2.0")
public interface ECCSensitiveDataInterface
{
    /// \brief Retrieves the character from decrypted data at specific location.
    /// \param the location where the character should be retrieved.
    /// \return the character
    int charAt(int index);
 
    /// \brief Gets the length of sensitive data in decrypted form
    /// \return the length of the decrypted sensitive data
    int getLength();
 
    /// \brief Gets the decrypted data in (immutable) string
    /// \return the string presentation of decrypted sensitive data
    String getData();
 
    /// \brief Gets the decrypted data in (mutable) byte array
    /// \return the byte array presentation of decrypted sensitive data
    byte[] getDataInRawForm();
}

com.elavon.commerce.ECLAccountCredential

package com.elavon.commerce;

// Commerce Account Credential place holder.
@SupportedSince(Version = "3.0.0")
public class ECLAccountCredential
{
    private final HashMap<String, ECCSensitiveData> attributes = new HashMap<>();

    // Creates a Commerce account credential object with a set of credential attributes.
    // @param attributes the set of the credential attributes
    public ECLAccountCredential(Map<String, ECCSensitiveData> attributes);


    // Retrieves an attribute of Commerce account credential.
    // @param attributeName name of the attribute
    // @return the attribute value in encrypted form
    public ECCSensitiveData getAttribute(String attributeName);
}

Reference

com.elavon.commerce.ECLAccountInformation

package com.elavon.commerce;
 
/// \brief Information about an account that we retrieve from the server at the time of account creation.
@SupportedSince(Version = "3.0.0")
public class ECLAccountInformation
{
    /// \brief The merchant name on the account
    public String getName();
 
    /// \brief The default currency for the account
    public ECLCurrencyCode getCurrencyCode();
 
    /// \brief The first line of address for the account
    public String getAddress1();
 
    /// \brief Indicates if gratuity is supported for the account.
    public Boolean isGratuitySupported();
 
    /// \brief Indicates whether CVV is enabled for the account
    public ECLTriState isCvvEnabled();
}

Reference

com.elavon.commerce.ECLAccountInformationRetrievalListener

package com.elavon.commerce;
 
 
// Listener to receive notifications when retrieving Account Information via 'account.retrieveAccountInformation'
@SupportedSince(Version = "3.0.0")
public interface ECLAccountInformationRetrievalListener
{
    // Notifies POS system that the account information retrieval has succeeded
    // @account The account the retrieval request was done for
    // @param accountInformation The account information that was retrieved
    void accountInformationRetrievalDidSucceed(final ECLAccountInterface account, final ECLAccountInformation accountInformation);
 
    // Notifies POS system that the account information retrieval has failed
    // @param account The account the retrieval request was done for
    // @param error ECCError instance which indicates the reason for the failure. Use 'error.getDebugDescription()' to get more information.
    void accountInformationRetrievalDidFail(final ECLAccountInterface account, final ECCError error);
}

References

com.elavon.commerce.ECLAccountInterface

package com.elavon.commerce;
 
// Commerce account for transactions, receipts, transaction search, printers, and card readers
@SupportedSince(Version = "2.4.0")
public interface ECLAccountInterface
{
    /// Provides the list of supported attribute name for credential.
    List<String> getSupportedCredentialAttributes();
 
    // Ensures that an account is properly configured and can authenticate with the server
    // @param listenernotification of success or failure to validate account.
    void validateAccount(ECLAccountValidationListener listener);
 
    // Retrieves information about this account from server, including default currency, name, address, etc
    void retrieveAccountInformation(ECLAccountInformationRetrievalListener listener);
 
    // Retrieves from server information about this account including default currency, name, address, etc and force an update of account configuration
    void retrieveAccountInformationWithUpdate(ECLAccountInformationRetrievalListener listener);
 
    // Calls this method when any of the credentials or server type of the account change.
    void propertiesDidChange(ECLAccountValidationListener listener);
 
    // Provides access to interface for the processing of transactions
    ECLTransactionProcessorInterface getTransactionProcessor();
 
    // Provides access to sending receipts to supported methods such as printer, file, sms
    ECLReceiptProcessorInterface getReceiptProcessor();
 
    // Provides access to transaction search
    ECLHistorianInterface getHistorian();
 
    // Rrovides account credential
    ECLAccountCredential getCredential();
 
    // Rrovides control of card readers
    // By default when doing a transaction if there is only one card reader, it will be used.
    ECLDevicesInterface<ECLCardReaderInterface> getCardReaders();
 
    // Provides control of printers
    ECLDevicesInterface<ECLPrinterInterface> getPrinters();
 
    // Provides control of check readers
    ECLDevicesInterface<ECLCheckReaderInterface> getCheckReaders();
 
    // Search for available devices (card readers, printers, etc.)
    // Use {@link ECLConnectionConfiguration} to set search criteria before calling this for a more refined search.
    // @param listener A listener for receiving callbacks on the progress of the search
    // @param forceToDisconnect flag indicating whether to disconnect already connected devices first. True if need to disconnect existing connection first
    // @param timeoutInSeconds After this many seconds, the search will stop
    // @return Error if failed to start search. Nil if able to start search.
    ECCError findDevices(com.elavon.commerce.ECLFindDevicesListener listener, boolean forceToDisconnect, int timeoutInSeconds);
 
    // Called when your app is moving to the foreground
    void appDidBecomeActive();
 
    // Called when your app is being sent to the background
    void appWillResignActive();
 
    // Retrieve information about the environment
    // @return an ECLEnvironmentInfo object
    ECLEnvironmentInfo getEnvironmentInfo();
 
    // Retrieves terminal configuration
    // @return an ECLTerminalConfiguration object
    // @apiNote
    ECLTerminalConfiguration getTerminalConfiguration();
 
    // Sets account credential
    // @param accountCredential the credential to set for this account
    // @param setCredentialListener the listener to receive the notification of set credential result
    void setCredential(ECLAccountCredential accountCredential, ECLSetCredentialListener setCredentialListener);
 
    // Indicates if account support search for historical transactions.
    boolean isSearchTransactionSupported();
}

References

com.elavon.commerce.ECLAccountListener

package com.elavon.commerce;
 
@SupportedSince(Version = "2.4.0")
public interface ECLAccountListener
{
    // Gets the application context required by Commerce SDK. Mainly used in Android environment
    deckard.content.Context getApplicationContext();
 
    // Notifies that an account has been initialized and can be used for transactions, etc.
    // @account The account which has been initialized
    void accountDidInitialize(ECLAccountInterface account);
 
    /// Notifies that an account failed to initialize.
    /// @account The account which has not been initialized
    /// @error The error which indicates the reason for the failure
    void accountDidFailToInitialize(ECLAccountInterface account, ECCError error);
 
    // Notifies the implementer that the currency supported for the account has changed.
    //
    // If Commerce is able to get the currency after account initialization this will be called.
    // @account The account which changed currency
    // @defaultCurrencyCode ECLCurrencyCode. The currency of the account.
    // @apiNote This method is not applicable to CSDK integration for EU market
    void accountDefaultCurrencyDidChange(ECLAccountInterface account, ECLCurrencyCode defaultCurrencyCode);
 
    // Gets type of server. This method is called when Commerce needs to know which payment gateway environment to communicate with.
    // @return server to use. ECLServerType.DEMO and ECLServerType.PROD are available externally.
    // @apiNote This method is not applicable to CSDK integration for EU market
    ECLServerType getServerType();
}

References

com.elavon.commerce.ECLAccountType

package com.elavon.commerce.datatype;

/// \brief Account types available for processing a transaction.
@SupportedSince(Version = "2.4.0")
public enum ECLAccountType
{
    UNSET,
    UNKNOWN,
    NO_MATCH,
    CHECKING,
    SAVINGS;

    // Lookup enum based on its display name.
    // @param String name of enum.
    // @return Enum if name is found, NO_MATCH otherwise.
    public static ECLAccountType lookupByName(String name);
}

com.elavon.commerce.ECLAccountValidationListener

package com.elavon.commerce;

// Listener to get notifications for account validation via the '[account.validateAccount(listener)]'
@SupportedSince(Version = "3.0.0")
public interface ECLAccountValidationListener
{
    // Notifies POS system that the account was validated
    // @param account The account which was validated
    void accountDidValidate(final ECLAccountInterface account);

    // Notifies POS system that the account failed to be validated
    // @account The account which was not validated
    // @ error Indicates the reason that the account was not validated. Use 'error.getDebugDescription()' to get more information.
    void accountDidFailToValidate(final ECLAccountInterface account, final ECCError error);
}

References

com.elavon.commerce.ECLCardEntryType

package com.elavon.commerce;

// Card entry methods
@SupportedSince(Version = "3.0.0")
public enum ECLCardEntryType
{
    UNKNOWN,
    UNSET,
    SWIPE, ///< Card was swiped using magnetic stripe
    MSD_PROXIMITY, ///< Card was tapped on card reader to get non-EMV information
    MANUALLY_ENTERED, ///< Card was manually entered on card reader
    EMV_CONTACT, ///< Card was inserted to get EMV information
    EMV_PROXIMITY, ///< Card was tapped to get EMV information
    MOBILE, ///< Card was presented from a mobile application
    TOKEN ///< Card token was used
}

com.elavon.commerce.ECLCardholderVerificationMethod

package com.elavon.commerce;

// Enum to explain how card holder was verified
@SupportedSince(Version = "3.0.0")
public enum ECLCardholderVerificationMethod
{
    UNKNOWN,
    FAILED, ///< Failed CMV processing
    PIN, ///< User entered PIN on card reader
    SIGNATURE, ///< User signed card reader or will sign receipt
    PIN_AND_SIGNATURE, ///< PIN and User signed card reader or will sign receipt
    NO_CVM_REQUIRED ///< No CVM required
}

com.elavon.commerce.ECLCardReaderInterface

package com.elavon.commerce;
 
 
@SupportedSince(Version = "3.0.0")
public interface ECLCardReaderInterface extends ECLDeviceInterface
{
    // Gets the name of this Card reader
    String getName();
 
    // Gets the serial number of this card reader
    String getSerialNumber();
 
    // Gets the flag indicating that this card reader is already connected and initialized.
    boolean isConnectedAndInitialized();
 
    // Adds a connection listener to this card reader
    // @param listener the listener to be added
    void addConnectionListener(ECLCardReaderListener listener);
 
    // Removes a connection listener from this card reader
    // @param listener the listener to be removed
    void removeConnectionListener(ECLCardReaderListener listener);
 
    // Tries to connect and initialize card reader
    // @param updateIfNecessary flag indicating that the update should be performed during initialization if there is one.
    void connectAndInitialize(boolean updateIfNecessary);
 
    // Disconnects this card reader from Commerce SDK.
    void disconnect();
 
    // Adds a status listener to this card reader
    // @param listener the listener to be added
    void addStatusListener(ECLDeviceStatusListener listener);
 
    // Removes a status listener from this card reader
    // @param listener the listener to be removed
    void removeStatusListener(ECLDeviceStatusListener listener);
}

References

com.elavon.commerce.ECLCardReaderListener

package com.elavon.commerce;

// Listener to receive card reader notifications.
@SupportedSince(Version = "3.0.0")
public interface ECLCardReaderListener
{
    // Notifies POS system that the card reader is already connected and will be initialized
    // @param cardReader the card reader Commerce SDK connects to
    void cardReaderConnectedAndWillInitialize(ECLCardReaderInterface cardReader);

    // Notifies POS system that the card reader is already initialized
    // @param cardReader the card reader Commerce SDK initialized
    void cardReaderInitialized(ECLCardReaderInterface cardReader, ECLDeviceConnectionChangeReason connectedReason);

    // Notifies POS system that Commerce SDK cannot either connect to or initialize the card reader
    // @param cardReader the card reader Commerce SDK is dealing with
    void cardReaderConnectionOrInitializationError(ECLCardReaderInterface cardReader, ECCError error);

    // Notifies POS system that Commerce SDK will update configuration on the card reader during initialization.
    // @param cardReader the card reader Commerce SDK will be operating on
    void cardReaderWillUpdateConfiguration(ECLCardReaderInterface cardReader);

    // Notifies POS system that Commerce SDK has successfully updated configuration on the card reader during initialization.
    // @param cardReader the card reader which configuration was updated.
    void cardReaderUpdateSucceeded(ECLCardReaderInterface cardReader);

    // Notifies POS system that Commerce SDK failed to perform update on the card reader during initialization.
    // @param cardReader the card reader which configuration was failed to be updated.
    // @param error the reason for the failure.
    void cardReaderUpdateError(ECLCardReaderInterface cardReader, ECCError error);

    // Notifies POS system the progress when Commerce SDK connects and initializes the card reader.
    // @param cardReader the card reader which Commerce SDK operates on.
    // @param progress the progress update.
    void cardReaderProgress(ECLCardReaderInterface cardReader, ECLTransactionProgress progress);
}

References

com.elavon.commerce.ECLCardTenderInterface

package com.elavon.commerce;

// Provides ability to interact with the card tender being used for a transaction
@SupportedSince(Version = "3.0.0")
public interface ECLCardTenderInterface extends ECLTenderInterface
{
    // Tells CSDK that a voice referral will be needed for this transaction.  Needed in Force Sale scenarios.
    void requiresVoiceReferral();

    // Tells CSDK that a signature verification process happened and the signature was verified successfully
    void setSignatureVerificationHandledAndVerified();

    // Tells CSDK that a signature verification process happened and the signature was not verified successfully
    void setSignatureVerificationHandledAndUnverified();

    // Tells CSDK that a voice referral process happened and the auth request was approved
    // @param authorizationCode an auth code received from the auth center
    void setVoiceReferralHandledAndApproved(String authorizationCode);

    // Tells CSDK that a voice referral process happened and the auth request was denied
    void setVoiceReferralHandledAndDenied();

    // Retrieves a state if card is present during a transaction.
    // @returns state for card being present or not during a transaction.
    ECLTriState getCardPresent();

    // Tells CSDK if a card is present for a transaction
    // @cardPresent is the card present?
    void setCardPresent(ECLTriState cardPresent);
}

References

com.elavon.commerce.ECLCardTenderScheme

package com.elavon.commerce;

// Card schemes
@SupportedSince(Version = "2.4.0")
public enum ECLCardTenderScheme
{
    UNKNOWN,
    VISA,
    MASTERCARD,
    MAESTRO,
    AMEX,
    JCB,
    DINERS,
    DISCOVER,
    CARTE_BLEUE,
    CARTE_BLANC,
    VOYAGER,
    WEX,
    CHINA_UNION_PAY,
    STYLE,
    LASER,
    PAYPAL,
    RPS,
    TORONTO_PARKING_AUTHORITY,
    CITY_OF_OTTOWA,
    DK12,
    GIFT_CARD,
    MBNA,
    INTERAC,
    VALUE_LINK
}

com.elavon.commerce.ECLCardTransactionOutcome

package com.elavon.commerce;

// Provides details about the result of a card transaction.
@SupportedSince(Version = "2.4.0")
public class ECLCardTransactionOutcome extends ECLTransactionOutcome
{
    // Gets response from card issuer
    public String getIssuerResponse();

    // Gets the authorization code, if any, for the transaction
    public String getAuthCode();

    // The state of the transaction (eg., committed, uncommitted, etc.)
    public ECLTransactionState getState();

    // The masked PAN
    public String getMaskPan();

    // The card scheme
    public ECLCardTenderScheme getCardScheme();

    // The card holder's first name
    public String getCardHoldersFirstName();

    // The card holder's last name
    public String getCardHoldersLastName();

    // Specifies if this was a EMV fallback transaction (Chip was unable to be read so customer swiped or tapped).
    public boolean getIsFallback();

    // Amount requested for this transaction. See amountAuthorized in ECLTransactionOutcome to get amount that was authorized.
    public ECLMoney getAmountRequested();

    // iccMode
    public ECLTransactionMode getIccMode();

    // Card entry type used for this transaction
    public ECLCardEntryType getCardEntryType();

    // Account type used for this transaction if it was a debit transaction
    public ECLAccountType getDebitAccountType();

    // Card type used for this transaction
    public ECLCardType getCardType();
}

References

com.elavon.commerce.ECLCardType

package com.elavon.commerce;

// Card types
@SupportedSince(Version = "2.4.0")
public enum ECLCardType
{
    UNKNOWN,
    CREDIT,
    DEBIT,
}

com.elavon.commerce.ECLCommerceAndroid

package com.elavon.commerce;
 
// This class is first integration point for POS to integrate with Commerce SDK.
// POS system should make call ECLCommerceAndroid.initialize(
public class ECLCommerceAndroid extends ECLCommerce
{
    // Initialize Commerce SDK on Android
    // @param application the application object for POS Android application
    // @return ECCError null will be returned if initialized otherwise error contains the reason for failure.
    public static ECCError initialize(android.app.Application application);
 
    // Initialize Commerce SDK on Android with a set of customized EMV Tags.
    // @param application the application object for POS Android application
    // @param tagList a set of customized EMV tags, added to TLV tag list in transaction authorization request to Host.
    // @return ECCError null will be returned if initialized otherwise error contains the reason for failure.
    public static ECCError initialize(android.app.Application application, Map<String, String> tagList)
}

Reference

com.elavon.commerce.ECLCommerceError

package com.elavon.commerce;
 
public class ECLCommerceError extends ECCError
{
    // Commerce error code defintions.
    public enum Codes
    {
        ECLNone,
 
        ECLOperationNotSupported, /// < Operation not supported
 
        ECLSetCredentialFail, /// < Failed to set credential for account in CSDK
        ECLSetCredentialFailUnsettledTransaction, /// < Failed to set credential for account in CSDK because there are still outstanding unsettled transactions.
 
        // BEGIN ERRORS SPECIFIC TO TRANSACTIONS
        ECLTransactionDeclined, ///< Transaction was declined
        ECLTransactionNotCommitted, ///< Transaction was not committed on server
        ECLTransactionNotApproved, ///< Transaction was declined
        ECLTransactionVoid, ///< Transaction was voided or had a hold put on it
        ECLTransactionCanceled, ///< Action was canceled due to a cancel request
        ECLTransactionUnsupportedTender, ///< Tried to use tender type that is not supported
        ECLTransactionUnimplemented, ///< Commerce failed to implement something. Will never happen in release.
        ECLTransactionUnavailable, ///< Tried to cancel or continue a transaction that is not in a state where that is possible
        ECLTransactionPropertyFailure, ///< Not used for converge
        ECLTransactionFailure, ///< General error occurred. Check log.
        ECLTransactionUnsupportedTransactionType, ///< Tried to use transaction type that is not supported
        ECLTransactionTokenGenerationFailure, ///< Server was unable to generate token
        ECLTransactionStoreTokenFailure, ///< Server was unable to store token for use in Card Manager in Converge web site
        ECLTransactionInvalidToken, ///< Invalid token was used for token transaction
        ECLTransactionSignatureRejected, ///< Signature was rejected
        ECLTransactionVoiceReferralRejected, ///< Voice referral rejected
        ECLTransactionReceiptFailure, ///< Not used for converge
        ECLTransactionReceiptNotSent, ///< Unable to send request to Converge to email receipt
        ECLTransactionResponseWrongRecipient, ///< Response from server was incorrectly processed
        ECLTransactionRequestBad, ///< Unable to send request to server
        ECLTransactionInsufficientCash, ///< Not used for converge
        ECLTransactionUnsupportedCash, ///< Not used for converge
        ECLTransactionSearchCanceled, ///< Transaction search was canceled
        ECLTransactionSearchResponseBad, ///< not used
        ECLTransactionSearchResponseWrongRecipient, ///< Response from server was incorrectly processed by search handler
        ECLTransactionSearchRequestBad, ///< Search request problem
        ECLTransactionSearchFailure, ///< Converge server returned that our search request contained invalid criteria. Use 'error.getDebugDescription()' to see more
        ECLTransactionAlreadyCompleted, ///< Tried to use cancel, process, or continue a transaction that was already completed
        ECLTransactionAlreadyStarted, ///< Tried to call processTransaction on a transaction that was already started
        ECLTransactionOtherTransactionBeingProcessed, ///< Commerce can only process one transaction at a time and one is in progress
        ECLTransactionNoneInProgress, ///< Tried to do something to a transaction but none were in progress
        ECLTransactionBluetoothOff, ///< Not used for converge
        ECLTransactionValidationFail, ///< Validation failed. Use 'error.getDebugDescription()' to see more. Nested errors will contain reason.
        ECLTransactionValidationCardNumberTooLong, ///< Not used
        ECLTransactionValidationSecurityCodeTooLong, ///< Not used
        ECLTransactionValidationSignatureSmall, ///< Signature does not have minimum width and/or height
        ECLTransactionValidationUnsupportedTransaction, ///< Not used for converge
        ECLTransactionValidationWrongCurrency, ///< Currency for tender does not match what the account can process
        ECLTransactionValidationStartDateAfterEnd, ///< Transaction search criteria start date is after end date
        ECLTransactionValidationDateRangeTooWide, ///< Transaction search criteria difference between start date and end date exceeds maximum
        ECLTransactionValidationLastFourWrongLength, ///< Transaction search criteria last four digits is not 4 digits long
        ECLTransactionValidationFirstSixWrongLength, ///< Transaction search criteria first six digits is not 6 digits long
        ECLTransactionValidationHasTransactionId, ///< Transaction search criteria has a transaction ID and last 4, first 6, or card number also set.
        ECLTransactionValidationRequiresTransactionDate, ///< Transaction search criteria has a transaction ID but not transaction date
        ECLTransactionValidationHasCardNumber, ///< Not used
        ECLTransactionValidationMissingAmount, ///< Not used
        ECLTransactionSignatureMissing, ///< Not used for converge
        ECLTransactionSignatureNotVerified, ///< Not used for converge
        ECLTransactionValidationVoiceReferralTooLong, ///< Not used for converge
        ECLTransactionValidationVoiceReferralTooShort, ///< Not used for converge
        ECLTransactionValidationVoiceReferralWrongCharacters, ///< Not used for converge
        ECLTransactionValidationRequired, ///< Transaction search criteria missing at least one required property
        ECLTransactionValidationNotAvailable, ///< Transaction search criteria contains property that is not available
        ECLTransactionReceiptValidationNoPhoneNumber, ///< Trying to SMS receipt with no phone number. Not used for Converge
        ECLTransactionReceiptValidationNoEmailAddress, ///< Trying to email receipt with no email address
        ECLTransactionReceiptValidationNoPrinterName, ///< Not used
        ECLTransactionReceiptValidationUnsupportedOutputType, ///< Trying to use ECLReceiptOutputType that is not supported
        ECLTransactionUnsupportedCurrency, ///< Trying to use ::ECLReceiptOutputType that is not supported
        ECLTransactionUninitializedDefaultCurrencyCode,
        ECLTransactionAmountInvalid, ///< Server return that the amount was invalid, refund amount too much, or cash back amount was invalid. Use 'error.getDebugDescription()' to see exact reason
        ECLTransactionAmountDoesNotApply, ///< Not used
        ECLTransactionAmountNotConfirmed, ///< Not used
        ECLTransactionTaxAmountExceedsBaseAmount, ///< Tried to send base amount as tax inclusive, but tax amount exceeded base amount
        ECLTransactionEmvApplicationBlocked, /// EMV Application Blocked by Reader
        ECLTransactionEmvApplicationFailed, ///< Not used
        ECLTransactionClientNeedsUpdate, ///< Not used
        ECLTransactionInProgress, ///< Tried to use transaction in card reader state machine and one was already in progress
        ECLTransactionIncorrectContinuation, ///< Card reader state machine received information that is not correct for state
        ECLTransactionFormTypeNotSupported, ///< Not used
        ECLTransactionLoginBusy, ///< Not used for converge
        ECLTransactionReversalFailed, ///< Reversal was needed for EMV transaction but commerce failed to reverse it.
        ECLTransactionOfflineNotSupported, ///< Commerce does not support offline authorization
        ECLTransactionCardRemoved, ///< EMV Card was removed in middle of transaction
        ECLTransactionCardNeedsRemoval, ///< EMV Card needs to be removed
        ECLTransactionCardNotSupported, ///< Card used is not supported
        ECLTransactionCardApplicationBlocked, ///< EMV card application is blocked
        ECLTransactionCardApplicationExpired, ///< EMV card application is expired
        ECLTransactionCardholderVerificationFailed, ///< Card holder verification failed
        ECLTransactionCardholderVerificationNotSpecified, ///< No card holder verification. Unable to continue
        ECLTransactionInvalidCredentials, ///< Server returned that credentials are invalid. See nested error for more specific reason.
        ECLTransactionInvalidTerminalConfiguration, ///< Terminal configuration is invalid. See nested error for more specific reason.
        ECLTransactionWrongRecipient, ///< not used for converge
        ECLTransactionResponseBad, ///< Server returned data we are unable to parse. Log 'error.getDebugDescription()' to see more info
        ECLTransactionInvalidTransactionRequest, ///< Server returned that our request contains invalid data. Log 'error.getDebugDescription()' to see more info
        ECLTransactionInvalidTransactionForAccount, ///< Server returned that account or terminal is not configured for this transaction.
        ECLTransactionSignatureServerRejected, ///< Server returned that signature was too large, already had signature, or not allowed for account's market segment. See nested error for specific error. Log 'error.getDebugDescription()' to see more info
        ECLTransactionCardReaderNoneAvailable, ///< Commerce is unable to find a card reader to use. Make sure reader is paired and connected.
        ECLTransactionCardReaderMultipleAvailable, ///< Not used for converge
        ECLTransactionFailedDueToRule, ///< Transaction state on server shows it failed to settle due to a fraud, pre-auth, or post-auth rule. See nested error for specific error. Log 'error.getDebugDescription()' to see more info
        ECLTransactionEmailInvalid, ///< Email was invalid
        ECLTransactionEmailNotConfigured, ///< Server returned that the account or terminal is not configured to send email receipts
        ECLTransactionTipNotAllowedForAccount, ///< Server returned market segment for account does not allow gratuity
        ECLTransactionInvalidCardNumber, ///< Server returned card number provided is invalid
        ECLTransactionInvalidExpiry, ///< Server returned expiration date for card is invalid.
        ECLTransactionMissingCvv2, ///< Server returned cvv2 is missing
        ECLTransactionInvalidCvv2, ///< Server returned cvv2 provided is invalid
        ECLTransactionInvalidCardPresentIndicator, ///< Server returned that the card present indicator sent is invalid
        ECLTransactionDescriptionLimitExceeded, ///< Server returned that the description (note) provided is too long
        ECLTransactionSignatureCancelled,
        ECLTransactionRequiresPin, ///< Server returned that a PIN is required for this card
        ECLTransactionAvsZipCharLimitExceeded, ///< Server returned AVS zip code too long
        ECLTransactionAvsAddressCharLimitExceeded, ///< Server returned AVS address too long
        ECLTransactionMerchantReferenceIdCharLimitExceeded, ///< Server returned merchant reference ID too long
        ECLTransactionFieldTooLong, ///< Server returned field too long
        ECLTransactionSessionKeyRetrievalFailed, ///< Failed to retrieve session keys (e.g., PIN and MAC) from server
        ECLTransactionInvalidPaymentType, ///< Invalid Payment Type (e.g., an unrecognized option was used)
        ECLTransactionInvalidAccountType, ///< Invalid Account Type (e.g., an unrecognized option was used)
        ECLTransactionMoneyTransferOctNotSupported, ///< OCT Disbursement is not enabled for the terminal
        ECLTransactionOctRefNumberNotSet, ///< The OCT transaction is missing the required OCT reference number
        ECLTransactionOctRefNumberTooLong, ///< The OCT reference number is over 16 bytes
        ECLTransactionOctNotEligible, ///< Server returned card is not eligible for OCT disbursement
        ECLTransactionInvalidLaneNumber, ///< The lane number provided is invalid. Provide an 8-digit number for the lane number.
        ECLTransactionServiceFeeNotSupportChangeCard, ///< consumer requires to change card during service fee confirmation.
        ECLTransactionPreAuthNotSupportedForServiceFeeEnabledTerminal, ///< Pre auth transaction is not supported for service fee enabled terminal.
        ECLTransactionForceSaleNotSupportedForServiceFeeEnabledTerminal, ///< Forced sale transaction is not supported for service fee enabled terminal.
        ECLTransactionPreAuthCompleteExceedsOriginalAmount,   ///< The amount set in pre auth complete exceeds the amount in the original Pre-Auth Transaction.
        ECLTransactionInvalidTransactionId, ///< The transaction requires a transaction id
        ECLTransactionTipAmountNotSet, ///< The tip adjust transaction requires a tip amount
        ECLTransactionTipAmountInvalid, ///< The tip amount was invalid
        ECLTransactionInvalidDestinationZipCode, ///< Destination zip code specified in Level3 transaction info is invalid.
        ECLTransactionInvalidShipFromZipCode, ///< ShipFrom zip code specified in Level3 transaction info is invalid.
        ECLTransactionLevel3TaxAmountIncorrect, ///< the tax amount set in Level 3 info for a transaction is different than what is set for the transaction itself.
        ECLTransactionOctFundingNotSupported, ///< OCT Funding is not enabled for the terminal.
        ECLTransactionDuplicated, ///< Duplicated transactions due to same amount and card used for consecutive transactions.
        ECLTransactionDebitNetworkUnavailable, ///< POS system cannot communicate to debit network when running a debit transaction.
        ECLTransactionExpiredCard, ///< The card used in transaction has expired
        ECLTransactionBatchCloseFailure, ///< Failed to run batch close processing.
        ECLTransactionBatchCloseNoTransaction, ///< There is no transaction to close for batch processing.
        ECLTransactionNetworkUnavailable, ///< POS system cannot communicate to internet when running a transaction.
        ECLTransactionMissingOriginalTransactionId, ///< the original transaction id is missing in the transaction request.
        ECLTransactionTipAdjustNotSupported,        ///< tip adjust transaction is only supported for a SALE transaction without surcharge
        ECLTransactionTaxNotAllowedForAccount, ///< Server returned market segment for account does not allow tax
        // END ERRORS SPECIFIC TO TRANSACTIONS
 
        // BEGIN ERRORS SPECIFIC TO PRINTERS
        ECLPrinterOffline, ///< Unable to print due to printer being offline
        ECLPrinterCoverOpen, ///< Unable to print due to cover being open
        ECLPrinterPaperEmpty, ///< Unable to print due to no paper being available
        ECLPrinterUnableToOpenPort, ///< Unable to print due because Commerce cannot open port to printer
        ECLPrinterPortTimeOut, ///< Unable to print due because Commerce timed out opening port to printer
        ECLPrinterCommunicationFailure, ///< Unable to print due because Commerce had communication problem with printer
        ECLPrinterBadFormatting, ///< Problem printing formatted data
        // END ERRORS SPECIFIC TO PRINTERS
 
        // BEGIN ERRORS SPECIFIC TO CARD READERS
        ECLCardReaderNotConnected, ///< Card reader is not connected
        ECLCardReaderMustFind, ///< Not used
        ECLCardReaderCannotConfigure, ///< Not used for converge
        ECLCardReaderCannotConnect, ///< Unable to connect to card reader
        ECLCardReaderConnectTimeout, ///< Timed out connecting to card reader
        ECLCardReaderCannotSelect, ///< Not used for converge
        ECLCardReaderCommunicationProblem, ///< Error communicating with card reader
        ECLCardReaderNoneSelected, ///< Not used
        ECLCardReaderRebootRequired, ///< Card reader needs to be rebooted. Commerce was unable to automatically reboot it.
        ECLCardReaderRebootAutomatic, ///< Card reader is automatically being rebooted and unable to continue transaction
        ECLCardReaderUnavailable, ///< card reader is locked
        ECLCardReaderFailedToReadCard, ///< Bad read of card on card reader
        ECLCardReaderAudioVolumeTooLow, ///< Not used
        ECLCardReaderError, ///< General card reader error
        ECLCardReaderNotInitialized, ///< card reader has not initialized
        ECLCardReaderCannotInitialize, ///< Not used
        ECLCardReaderDisconnecting, ///< Card reader disconnecting so unable to continue
        ECLCardReaderDisconnected, ///< Card reader disconnected so unable to continue
        ECLCardReaderUpdating, ///< Card reader updating so unable to continue
        ECLCardReaderUpdatingKeys, ///< Card reader updating keys so unable to continue
        ECLCardReaderNoCard, ///< Not used
        ECLCardReaderTerminated, ///< Not used
        ECLCardReaderNeedsUpdate, ///< Card reader does not meet minimum application version requirement
        ECLCardReaderEncryptionFailure, ///< Card reader encryption failed
        ECLCardReaderCanceled, ///< On card reader, user pushed cancel or ui timed out
        ECLCardReaderInvalidPrompt, ///< Tried to display invalid form or prompt on card reader
        ECLCardReaderNoSignatureData, ///< No signature data available
        ECLCardReaderSignatureError, ///< Card reader signature error
        ECLCardReaderNotPaired, ///< Card reader not paired
        ECLCardReaderPinAccountMismatch, ///< Account number mismatch for PIN on card reader
        ECLCardReaderPinNoAccount, ///< No account number provided for PIN on card reader
        ECLCardReaderPinInvalidKeyIndex, ///< Invalid key index on card reader
        ECLCardReaderPinTooShort, ///< Too short PIN provided on card reader
        ECLCardReaderPinRequestDeclined, ///< PIN request declined on card reader
        ECLCardReaderIsResetting, ///< Card reader is resetting so unable to continue
        ECLCardReaderInvalidMessage, ///< Not used
        ECLCardReaderFormTypeNotSupported, ///< Not used
        ECLCardReaderFormDeclined, ///< Unable to show form
        ECLCardReaderFormError, ///< Unable to show form
        ECLCardReaderAmountVerificationError, ///< Amount verification error on card reader
        ECLCardReaderAmountTooLarge, ///< Transaction amount is too large for card reader (> 999999999L)
        ECLCardReaderAmountTooSmall, ///< Amount was too small on the card reader
        ECLCardReaderKeysUpdateNotProvided, ///< Update keys data provided is invalid
        ECLCardReaderWriteKeysFileFailed, ///< Unable to write keys file
        ECLCardReaderTimeOut, ///< Card Reader timed out
        ECLCardReaderCannotAcceptCards, ///< None of the card entry modes provided are available on card reader
        ECLCardReaderCardDataInvalid, ///< Card data provided is invalid (and maybe fallback is not allowed)
        ECLCardReaderUnsupportedFeature, ///< An unsupported feature was tried for the card reader
        ECLCardReaderSearchInProgress, ///< findDevices was called when a search was already in progress
        ECLCardReaderEmvTlvTranslationFailure,///< unable to parse tlv data
        ECLCardReaderConfigurationUpdateFailed, ///< Error writing update to card reader
        ECLCardReaderMaxCardReadsExceeded, ///< Maximum number of reads for this transaction tried
        ECLCardReaderModelNotSupported,
        ECLCardReaderInvalidConfigurationForUpdatingKeys, ///< Keys installed on card reader are invalid
        ECLCardReaderBatteryLow, ///< Battery on card reader is too low
        ECLCardReaderUnsupportedCardEntryType, ///<Unsupported card entry type for card read
        ECLCardReaderMacValueCalculationFailure, ///<MAC Value calculation failed (general error) on the card reader
        ECLCardReaderMacValueCalculationSecurityAppError, ///<MAC Value calculation failed (security app error) on the card reader
        ECLCardReaderMacValueCalculationSessionKeyNotLoaded, ///<MAC Value calculation failed (invalid session key length) on the card reader
        ECLCardReaderMacValueCalculationSessionKeyLengthInvalid, ///<MAC Value calculation failed (invalid session key length) on the card reader
        ECLCardReaderMacValueVerificationFailure, ///<MAC Value verification failed (general error) on the card reader
        ECLCardReaderMacValueVerificationSecurityAppError, ///<MAC Value verification failed (security app error) on the card reader
        ECLCardReaderMacValueVerificationSessionKeyNotLoaded, ///<MAC Value verification failed (invalid session key length) on the card reader
        ECLCardReaderMacValueVerificationSessionKeyLengthInvalid, ///<MAC Value verification failed (invalid session key length) on the card reader
        ECLCardReaderPinSessionKeyLoadFailure, ///<Loading of the PIN session key failed on the card reader.
        ECLCardReaderMacSessionKeyLoadFailure, ///<Loading of the MAC session key failed on the card reader.
        ECLCardReaderOperationInProgress, ///< On Demand card reader operation is currently in progress
        ECLCardReaderNoCardReadInProgress, ///< No on-demand card read has been initiated
        ECLCardReaderDailyRebootTimeAlreadySet, ///< Request to change V4 card reader daily reboot time failed because it is already set to requested time
        ECLCardReaderDailyRebootTimeInvalid, ///< Request to change V4 card reader daily reboot time failed because specified time is not between 0000 and 2359
        ECLCardReaderDailyRebootTimeNotSupportedForDevice, ///< Request to change V4 card reader reboot time failed because the device does not support it
        ECLCardReaderTransactionTypeNotSupported, ///< Transaction failed because the device does not support its type
        ECLCardReaderCardReadFailure, ///< Failed to perform an ON-Demand card read
 
        // END ERRORS SPECIFIC TO CARD READERS
 
        // BEGIN ERRORS SPECIFIC TO Opayo
        // BEGIN ERRORS SPECIFIC TO Opayo
        // BEGIN ERRORS SPECIFIC TO Opayo
        ECLStorageUnknownError,
 
        ECLStorageFailedToClose,
        ECLStorageFailedToCreate,
        ECLStorageFailedToMigrate,
        ECLStorageFailedToOpen,
        ECLStorageFailedToRead,
        ECLStorageFailedToUpgrade,
        ECLStorageFailedToWrite,
        ECLStorageFailedToGetBaseDirectory,
        ECLStorageFailedToImportPublicKey,
        ECLStorageFailedBluetoothInitialisation,
        ECLStorageFailedCreatingCoreTables,
 
        ECLTmsUpdateFailure,
        ECLTmsUpdateRequired, ///< When connected to device/or running a transaction, tms update is required
 
        ECLTransactionFailedToClose,  ///< Transaction failed to commit, so cannot be settled
        ECLTransactionOnlinePinError1, ///< Transaction failed because there is configuration error with key slot
        ECLTransactionOnlinePinError2, ///< Transaction failed because there is configuration error with key slot
        ECLTransactionOnlinePinError3, ///< Transaction failed because there is configuration error with key slot
        ECLTransactionPANMissing,  ///< Transaction failed because PIN is not entered on pin pad
        ECLTransactionPANTooLong,  ///< Transaction failed because PIN entered on PinPad is too long
        ECLTransactionPANTooShort, ///< Transaction failed because PIN entered on PinPad is too short
        ECLTransactionTypeNotSupported, ///< Operation failed because the transaction is not supported
        ECLUnableToSetMerchantID, ///< Operation failed because cannot save merchant ID
        ECLBluetoothPairInvalidParameter, ///< Failed to pair pin pad via bluetooth due to invalid parameters
        ECLConnectToPinPadInvalidParameter, ///< Failed to connect to pin pad due to invalid parameters
        ECLCardReaderConnectDeviceNotFound, ///< Unable to connect to pin pad not already discovered
        ECLCardReaderCannotConnectUnpairedDevice, ///< Unable to connect to unpaired card reader
        ECLPinUpdateFailure, ///< Unable to update PIN for Opayo account
        ECLPinUpdateNotSupported, ///< Pin update is not supported
        ECLPasswordUpdateFailure, ///< Unable to update Password for Opayo account
        // END ERRORS SPECIFIC TO Opayo
        // END ERRORS SPECIFIC TO Opayo
        // END ERRORS SPECIFIC TO Opayo
 
 
 
        // BEGIN ERRORS SPECIFIC TO WEBMIS
        WebMisError_Failed, ///< Not used for converge
        WebMisError_Busy, ///< Not used for converge
        WebMisError_CouldNotCommunicate, ///< Not used for converge
        WebMisError_SSLHandshakeFailure, ///< Does your smartphone support TLS 1.2?
        WebMisError_ServerFailure, ///< Not used for converge
        WebMisError_NoResponseData, ///< Not used for converge
        WebMisError_UnknownResponse, ///< Not used for converge
        WebMisError_LogOnRequired, ///< Not used for converge
        WebMisError_LogOnFailed, ///< Not used for converge
        WebMisError_LogOnDisabled, ///< Not used for converge
        WebMisError_LogOnLockedOut, ///< Not used for converge
        WebMisError_CommunicationTimeout, ///< Not used for converge
        WebMisError_BadRequest, ///< Not used for converge
        WebMisError_InvalidLocale, ///< Not used for converge
        WebMisError_Cancelled, ///< Not used for converge
        // These will come when forgot/change password code comes from iOS
        WebMisError_ForgotPasswordUnknownError, ///< Not used for converge
        WebMisError_InvalidEmailAddress, ///< Not used for converge
        WebMisError_InvalidPassword, ///< Not used for converge
        WebMisError_InvalidCurrentPassword, ///< Not used for converge
        WebMisError_InvalidNewPasswordsDoNotMatch, ///< Not used for converge
        WebMisError_InvalidNewPasswordNotComplex, ///< Not used for converge
        WebMisError_InvalidNewPasswordPreviouslyUsed, ///< Not used for converge
        // END ERRORS SPECIFIC TO WEBMIS
 
        // BEGIN OTHER ERRORS
        ECLAccountValidationCanceled, ///< Not used
        ECLDeviceRooted, ///< Device is rooted
        ECLMerchantRetrievalNotSent, ///< Commerce failed to send request to server for account information retrieval
        ECLIllegalArgument, ///< Most likely a null value was passed where not allowed. See logging.
        ECLUnableToInitialize, ///< Not used
        ECLTransportCommunicationFailure, ///< Communication issue on server
        ECLSignatureTransactionFailed, ///< Failed to send signature for transaction to server. May want to print receipt for customer to sign.
        ECLUnsupportedSignatureFormat, ///< Server returned that the signature format is not supported.
        ECLSecurityLibraryNotFound, ///< Couldn't find/load commerce security library
        ECLTlvLibraryNotFound, ///< Couldn't find/load tlv jni library
        ECLStringTablesNotFound, ///< Couldn't load string tables
        ECLNoAccount, ///< Tried to create an account with invalid type or passed null for an account parameter
        ECLAccountInvalidCredentials, ///< Failed to provide merchant, pin, and/or user id for account
        ECLAccountInvalidVendorInfo, ///< Failed to provide vendorAppName, vendorAppVersion, and/or vendorId for account
        ECLRequestCanceled, ///< Not used for converge
        ECLCannotVerifyPasswordExpiration, ///< Not used for converge
        // will be added when CreditCall CreditCallDaysUntilPasswordExpiresSoapRequest is added
        ECLCardPresenceNotSpecified, ///< Card presence not specified for manual entry
        ECLInvalidAccountListener,
        ECLDeviceFailedToPair,
        ECLDevicePairingNotSupported,
        ECLDeviceAlreadyPaired,
        ECLOnDemandDisconnect,
        ECLInvalidProxyServerInfo, ///< Proxy host or port missing or port is not a number
        ECLInvalidProxyCredentials, ///< Proxy rejected the supplied credentials
        ECLTransactionNotRefundable, ///< Transaction is not refundable
        ECLTransactionRefundExceedsAmountAllowed,   ///< Transaction is not refundable because the amount being refunded exceeds the limit
        ECLAccountRetrievalInProgress, ///< Could not initiate request for account information while already in-progress
        ECLOperationNotAllowedUnsecuredChannel, ///< Operation not allowed over unsecured channel
        // END OTHER ERRORS
 
        // BEGIN ERRORS SPECIFIC TO CHECK READERS
        ECLCheckReaderFailure, ///< There was a problem executing the active command on the check reader
        ECLCheckReaderOperationNotSupported, ///< The  requested operation is not supported with the specified parameters
        ECLCheckReaderDuplexScanNotSupported, ///< The  requested operation is not supported with duplex scanning
        ECLCheckReaderFrankingNotSupported, ///< The  requested operation is not supported with franking
        ECLCheckReaderInUseByOtherUser, /// < The check reader is in use by another user
        ECLCheckReaderCommunicationError, ///< There was a problem communicating with the check reader
        ECLCheckReaderCommandAborted, ///< The active check reader command was aborted
        ECLCheckReaderNotConnected, ///< The check reader is not connected
        ECLCheckReaderDisconnected, ///< The check reader is disconnected
        // END ERRORS SPECIFIC TO CHECK READERS
 
        ECLCardReaderRefreshStatusNotAllowed, ///<Perform onDemand call RefreshStatus is not allowed
 
        ECLTransactionValidationItemQuantityMaxDecimalPlacesExceeded, ///< Item quantity value exceeds the max decimal digits allowed
 
        // BEGIN ERRORS SPECIFIC TO PRODUCT CATALOG
        ECLCatalogSessionExpired,
        ECLCatalogInternalError,
        ECLCatalogMissingRequiredField,
        ECLCatalogValidationError,
        ECLCatalogValidationNotNumeric,
        ECLCatalogValidationMaxLength,
        ECLCatalogValidationMinValue,
        ECLCatalogError,
        ECLCatalogNotFound,
        ECLCatalogProductExists,
        ECLCatalogProductNotFound,
        // END ERRORS SPECIFIC TO PRODUCT CATALOG
 
        // BEGIN ERRORS SPECIFIC TO CONNECTION CRITERIA
        ECLConnectionCriteriaInvalid, ///< Generic error for invalid connection criteria, previous or default criteria will be used
        ECLConnectionCriteriaEmptyDeviceProviderTypes, ///< Device provider types list was empty, previous or default criteria will be used
        ECLConnectionCriteriaEmptyConnectionTypes, ///< Connection types list was empty, previous or default criteria will be used
        ECLConnectionCriteriaEmptyDeviceTypes, ///< Device types list was empty, previous or default criteria will be used
        ECLConnectionCriteriaInvalidConnectionTypesForProviderTypes, ///< Connection types are incompatible for provider types, previous or default criteria will be used
        ECLConnectionCriteriaInvalidDeviceTypesForProviderTypes, ///< Device types are incompatible for provider types, previous or default criteria will be used
        ECLConnectionCriteriaInvalidInetAddress, ///< InetAddress is invalid, previous or default criteria will be used
        // END ERRORS SPECIFIC TO CONNECTION CRITERIA
    }
 
    // Gets specific error code.
    public Codes getCode()
    {
        return code;
    }
}

Reference

com.elavon.commerce.ECLCurrencyTransactionInterface

package com.elavon.commerce;
 
 
// Interface providing additional transaction related functionality.
@SupportedSince(Version = "2.4.0")
public interface ECLCurrencyTransactionInterface extends ECLTransactionInterface
{
    // Retrieves the total amount for the transaction. Includes tax, gratuity, discount if they exist.
    // @return total amount
    ECLMoney getTotal();
 
    /// \brief Retrieve the total amount minus gratuity.
    /// \return total amount minus gratuity
    ECLMoney getTotalWithoutGratuity();
 
    // Returns a collection of taxes that are set up for the transaction
    Collection<ECLTax> getTaxes();
 
    // Retrieve the total tax amount (adding up the tax amount for all the tax types set up for the transaction). Defaults to null.
    // @return tax amount
    ECLMoney getTax();
 
    // Sets the tax amount on a transaction together with the tax type. This is useful for the countries or regions where there are multiple types
    // of taxes - for example Puerto Rico's IVU system
    // This will set the specified tax type in addition to other tax types that were potentially specified prior to this call.
    // If null is passed for ECLMoney, an existing tax of type taxType will be removed from the transaction.
    // @param tax the tax amount
    // @taxType tax type
    void setTax(ECLMoney tax, ECLTaxType taxType);
 
    // Retrieves the subtotal amount. Does not include tax, gratuity, discount.
    // @return subtotal amount
    ECLMoney getSubtotal();
 
    // Retrieves the discount amount, default is null.
    // @return discount amount
    ECLMoney getDiscount();
 
    // Sets the discount amount on a transaction.
    // @param value the discount amount
    void setDiscount(ECLMoney value);
 
    // For this transaction, is tax inclusive (VAT) or exclusive (sales tax). By default it is false.
    // @return is tax inclusive?
    boolean getIsTaxInclusive();
 
    // Tells CSDK whether or not tax is inclusive
    // @param isTaxInclusive whether or not tax is inclusive
    void setIsTaxInclusive(boolean isTaxInclusive);
 
    // Retrieves the gratuity amount
    // @return gratuity amount
    ECLMoney getGratuity();
 
    // Sets the gratuity amount
    // @param gratuityAmount the gratuity amount
    void setGratuity(ECLMoney gratuityAmount);
 
    // For this transaction, are we going to use the gratuity flow on the card reader?  Defaults to false.
    // @return whether or not gratuity flow should be used
    boolean isGratuityRequested();
 
    // Tells CSDK whether or not gratuity flow should be used
    // @param isGratuityRequested whether or not gratuity flow should be used
    void setGratuityRequested(boolean isGratuityRequested);
 
    /// \brief Retrieve the note.
    /// \return the note
    String getNote();
 
    /// \brief Save an optional descriptive note along with the transaction
    /// \param value the note
    void setNote(String value);
 
    // Retrieves merchant transaction reference id.
    // @return merchant transaction reference id
    String getMerchantTransactionReference();
 
    // Saves an optional transaction reference id along with a transaction.  This value will be associated with the transaction and may be used when searching for transactions.
    // @param ref the transaction reference
    void setMerchantTransactionReference(String ref);
}

References

com.elavon.commerce.ECLDeviceInterface

package com.elavon.commerce;

/// Base interface for printers and card readers
@SupportedSince(Version = "3.0.0")
public interface ECLDeviceInterface
{
    // Returns if device name is equal to name
    // @param name Name to use for comparison
    // @return true if name equals device name. false if unequal
    boolean isNameEqual(String name);

    // Returns if device can be paired
    // @return true if device can be paired.
    boolean isCapableOfPairing();

    // Tries to pair the device which name is stored in this interface
    void pair(com.elavon.commerce.ECLDevicePairingListener.ECLDevicePairingListener listener);

    // Adds a listener to receive callbacks for devices that automatically start bluetooth pairing (Moby/5500)
    // @listener A listener which will receive the pairing event callbacks
    void addDevicePairingListener(com.elavon.commerce.ECLDevicePairingListener.ECLDevicePairingListener listener);
}

Reference

com.elavon.commerce.ECLDevicesInterface

package com.elavon.commerce;
 
/// \brief Provides access to devices (Card readers or printers depending on where the ECLDevicesInterface is retrieved from).
@SupportedSince(Version = "3.0.0")
public interface ECLDevicesInterface<DeviceType>
{
    /// \brief Find available devices.
    ///  Use {@link ECLConnectionConfiguration} to set search criteria before calling this for a more refined search.
    /// \param listener A listener for receiving callbacks on the progress of the search
    /// \param forceToDisconnect flag indicating whether to disconnect already connected device first. True if need to disconnect existing connection first
    /// \param timeoutInSeconds After this many seconds, the search will stop
    /// \return Error if failed to start search. Nil if able to start search.
    ECCError findDevices(ECLFindDevicesListener listener, boolean forceToDisconnect, int timeoutInSeconds);
 
    /// \brief Find pairable device which can be used.
    /// \param listener A listener for receiving callbacks on the progress of the search
    /// \param timeoutInSeconds After this many seconds, the search will stop
    /// \return Error if failed to start search. Nil if able to start search.
    ECCError findPairableDevices(ECLFindDevicesListener listener, int timeoutInSeconds);
 
    /// \brief Select a device to be used.
    /// \param deviceName Name of device to use
    /// \param connectionsToUse types of connection to use for this device
    /// \return DeviceType the device that is set to use. null if unable to find device with name and connection
    DeviceType selectDevice(String deviceName, EnumSet<ECLConnectionType> connectionsToUse);
 
    /// \brief The current selected device to be used.
    /// \return DeviceType to the device is being used.
    DeviceType getSelectedDevice();
 
    /// \brief Check if the selected device exists.
    /// \return true if the device would be non-null from getSelectedDevice, false otherwise
    boolean hasDevice();
 
    /// \brief Application should call this when his application moves to background in order to notify device to clear secure information and save battery.
    void applicationMovingToBackground();
 
    /// \brief Application should call this when his application moves to foreground in order to notify device to check connection and be ready.
    void applicationMovingToForeground();
}

References

com.elavon.commerce.ECLDevicePairingListener

package com.elavon.commerce;

/// \brief Listener for receiving callbacks related to device pairing.
@SupportedSince(Version = "4.0.0")
public interface ECLDevicePairingListener
{
    // Indicates that the pairing of the device succeeded
    // @param device The device being paired
    void devicePairingSucceeded(com.elavon.commerce.ECLDeviceInterface device);

    // Indicates The pairing of the device failed
    // @param device The device being paired
    // @error the reason for the failure
    void devicePairingFailed(com.elavon.commerce.ECLDeviceInterface device, ECCError error);

    // Returns The device pairing progress
    // @param device The device being paired
    // @param progress The current progress
    void devicePairingProgress(com.elavon.commerce.ECLDeviceInterface device, com.elavon.commerce.ECLTransactionProgress progress);
}

References

com.elavon.commerce.ECLDeviceStatusListener

package com.elavon.commerce;

// Listener for POS system to get device status update.
// @apiNote this interface is not applicable for Commerce SDK integrator in EU.
@SupportedSince(Version = "3.0.0")
public interface ECLDeviceStatusListener
{
}

com.elavon.commerce.ECLDispatcher

package com.elavon.commerce;

public class ECLDispatcher
{
    // Instantiates Dispatcher, which is used by CSDK internally to post tasks.
    public ECLDispatcher(deckard.os.Handler handler);   
}

Reference

com.elavon.commerce.ECLEmvCardTransactionOutcome

package com.elavon.commerce;
 
/// Provides details about the result of an EMV card transaction
@SupportedSince(Version = "3.0.0")
public class ECLEmvCardTransactionOutcome extends ECLCardTransactionOutcome
{
    // Gets the issuer script results
    public String getIccIssuerScriptResults();
 
    // Gets ICC final Transaction Status Information
    public String getIccFinalTsi();
 
    // Gets ICC card type
    public String getIccCardType();
 
    // Gets ICC Application ID
    public String getIccAid();
 
    // Gets ICC Transaction Verification Result
    public String getIccTvr();
 
    // Gets ICC Transaction Status Information
    public String getIccTsi();
 
    // Gets ICC authorization result
    public String getIccIssuerAuthorization();
 
    /// Gets the application cryptogram value that is generated by the application in the chip card.
    public String getIccAc();
 
    // Gets the Authorization Response Code
    public String getIccArc();
 
    // Gets the Application Transaction Counter
    public String getIccAtc();
 
    // Gets the Card Serial Number
    public String getIccCsn();
 
    // Gets the issuer script
    public ECLIssuerScript getIccIssuerScript();
     
    // Gets ICC application name
    public String getIccAppName();
   
    // Gets card holder verification method
    public ECLCardholderVerificationMethod getIccCvmr();
 
    // Gets the issuer Application Data
    public String getIssuerApplicationData();
 
    // Specifies if the EMV transaction was reversed; e.g. signature canceled
    public boolean isReversed();
}

Reference

com.elavon.commerce.ECLFindDevicesListener

package com.elavon.commerce;

/// Listener for getting result for device search
@SupportedSince(Version = "4.2.0")
public interface ECLFindDevicesListener
{
    //  Called by Commerce SDK upon trying to get existing POS application context, only used for Android platform
    //  @return the deckard application context.
    deckard.content.Context getApplicationContext();

    // Notifies POS system upon device search starting with designated connection types
    // @param connectionTypes the types used to search for a device.
    void uponSearchingDevices(EnumSet<com.elavon.commerce.datatype.ECLConnectionType> connectionTypes);

    // Notifies POS system a pairable device (either already paired or can be paired) is found during a search
    // @param name Name of the device. Same name may be passed more than once if more than one connection.
    // @param connectionType connection for the card reader
    void devicesSearchFound(String name, com.elavon.commerce.datatype.ECLConnectionType connectionType);

    // Notifies POS system that the search is complete.
    // @param deviceSearchResults list of ECLFindDevicesSearchResult which contains each device name with corresponding connection types and device types.
    void devicesSearchDone(List<com.elavon.commerce.ECLFindDevicesSearchResult> deviceSearchResults);
}

References

com.elavon.commerce.ECLFindDevicesSearchResult

package com.elavon.commerce;

// Result of calling ECLDevicesInterface->findDevices
@SupportedSince(Version = "4.2.0")
public class ECLFindDevicesSearchResult
{
    // Instantiates an instance of device search result
    public ECLFindDevicesSearchResult(String name);

    // Gets device connection types supported by this search result  
    public EnumSet<com.elavon.commerce.datatype.ECLConnectionType> getConnectionTypes();

    // Gets device type of this search result      
    public EnumSet<com.elavon.commerce.datatype.ECLDeviceType> getDeviceTypes();

    // Gets name of this search result
    public String getName();
}

References

com.elavon.commerce.ECLGeneralOperationListener

package com.elavon.commerce;
 
// Listener for general operation CSDK performs
@SupportedSince(Version = "5.2.0")
public interface ECLGeneralOperationListener
{
    // Notifies POS system the start of the operation
    // @param progress the first progress for the start of the operation
    void started(ECLTransactionProgress progress);
 
    // Notifies POS system any progress of the operation
    // @aram progress the progress for the operation
    void progress(ECLTransactionProgress progress);
 
    // Notifies POS system the end of the operation
    // @success flag indicating that the operation is successfully executed
    // @param progress the final progress for the end of an operation
    // @param error the specific error when failed.
    void completed(boolean success, ECLTransactionProgress progress, ECCError error);
}

References

com.elavon.commerce.ECLLinkedRefundTransactionInterface

package com.elavon.commerce;
 
// Provides access to details which are necessary for a linked refund.  (A refund which is tied to an existing transaction.)
@SupportedSince(Version = "3.0.0")
public interface ECLLinkedRefundTransactionInterface extends ECLTransactionInterface
{
    // Gets the unique id of the transaction which is being refunded.
    String getOriginalTransactionIdentifier();
 
    // Sets the unique id of the transaction which is being refunded.
    void setOriginalTransactionIdentifier(String value);
 
    /// The amount for the transaction being refunded.
    ECLMoney getAmount();
}

References

com.elavon.commerce.ECLOpayoAccountInterface

package com.elavon.commerce;
 
/// \brief
/// Commerce Opayo (EU) account
@SupportedSince(Version = "5.2.0")
public interface ECLOpayoAccountInterface extends ECLAccountInterface
{
    /// \brief Instructs CSDK to upload log to server for troubleshooting.
    /// \param listener the listener CSDK uses to notify the progress
    void uploadLog(ECLGeneralOperationListener listener);
 
    /// \brief Instructs CSDK to query available TIDs for a given MID.
    /// \param mid the MID for which TIDs are queried
    /// \param the listener CSDK uses this listener to update POS system the results
    void queryTIDs(String mid, ECLTidQueryListener listener);
 
    /// \brief Instructs CSDK to update pin for the current account.
    /// \param pin the pin to be updated
    /// \param listener the listener CSDK uses to notify the progress and result
    void updatePin(ECCSensitiveDataInterface pin, ECLGeneralOperationListener listener);
 
    /// \brief Instructs CSDK to return the type of TMS Update that needs to be performed.
    /// After calling this method, you should perform the appropriate TMS update
    /// \return the type of Tms Update required.
    ECLOpayoTmsUpdateType getRequiredTmsUpdateType();
 
    /// \brief Instructs CSDK to perform a TMS Update. This will perform an update even if it isn't required.
    /// \param updateType The update type (FULL or NORMAL)
    /// \return listener the listener for receiving updates and callbacks
    void performTmsUpdate(ECLOpayoTmsUpdateType updateType, ECLTmsUpdateListener listener);
}

References

com.elavon.commerce.ECLOpayoAccountListener

package com.elavon.commerce;
 
// A class which conforms to this interface must be implemented to use Commerce
@SupportedSince(Version = "5.2.0")
public interface ECLOpayoAccountListener extends ECLAccountListener
{
    // POS system provides merchant id in secured/encrypted fashion to Commerce SDK, called during account instantiation
    // POS system must provide a valid merchant id.
    ECCSensitiveDataInterface getMerchantId();
  
    // POS system provides client id in secured/encrypted fashion to Commerce SDK, called during account instantiation
    // POS system must provide a valid client id associated with the merchant id.
    ECCSensitiveDataInterface getClientId();
 
    // POS system provides password in secured/encrypted fashion to Commerce SDK, called during account instantiation
    // POS system must provide the correct password (either initial password or hashed password)
    ECCSensitiveDataInterface getPassword();
  
    // POS system provides operator PIN in secured/encrypted fashion to Commerce SDK, called during account instantiation
    // This value is optional. If not set, POS system can return null.
    ECCSensitiveDataInterface getPin();
}

References

com.elavon.commerce.ECLOpayoTmsUpdateType

package com.elavon.commerce;
 
/// \brief
/// Enumeration to represent Opayo (EU) TMS Update Type
@SupportedSince(Version = "5.2.0")
public enum ECLOpayoTmsUpdateType
{
    NONE,
    NORMAL,
    FULL;
 
    public static boolean isValidUpdateType(ECLOpayoTmsUpdateType updateType);
}

com.elavon.commerce.ECLOpayoTransactionProcessingListener

package com.elavon.commerce;
 
/// \brief Protocol to give notifications about processing of an Opayo (EU) transaction.
@SupportedSince(Version = "5.2.0")
public abstract class ECLOpayoTransactionProcessingListener extends ECLTransactionProcessingListener
{
    /// \brief Notification that the password hash has updated for the account.
    /// \param transaction the current transaction
    /// \param tender the current tender
    /// \param newPasswordHash the updated password hash
    abstract public void passwordHashUpdated(ECLTransactionInterface transaction, ECLTenderInterface tender,
        ECCSensitiveDataInterface newPasswordHash);
}

References

com.elavon.commerce.ECLServerType

package com.elavon.commerce;
 
@SupportedSince(Version = "2.4.0")
public enum ECLServerType
{
    PROD, ///< Live Production server
    DEMO, ///< Demo server
    ;
}

com.elavon.commerce.ECLSetCredentialListener

package com.elavon.commerce;
 
// Listener to get notifications for setting new credential for account
@SupportedSince(Version = "3.0.0")
public interface ECLSetCredentialListener
{
    // Notifies POS system that the credential was set
    // @param account The account which credential was set
    void credentialDidSet(final ECLAccountInterface account);
 
    // Notifies POS system that the the credential failed to be set
    // @param account The account which  credential was not set
    // @param error Indicates the reason that the credential was not set. Use 'error.getDebugDescription()' to get more information.
    void credentialDidFailToSet(final ECLAccountInterface account, final ECCError error);
}

References

com.elavon.commerce.ECLStandaloneRefundTransactionInterface

package com.elavon.commerce;
 
// Represents a standalone refund transaction. One that is not linked to a previous transaction. Used to give credit to customer.
@SupportedSince(Version = "2.4.0")
public interface ECLStandaloneRefundTransactionInterface extends ECLTransactionInterface
{
    /// The amount being refunded. This is the amount passed when creating the transaction
    ECLMoney getAmount();
 
    /// \brief Note you want associated with the transaction
    void setNote(String note);
}

References

com.elavon.commerce.ECLTenderInterface

package com.elavon.commerce;

/// Provides access to basic details about the tender being used for a transaction
@SupportedSince(Version = "2.4.0")
public interface ECLTenderInterface
{
    // Is the tender some type of card?
    // @return whether or not the tender is a card
    boolean isCard();

    // Is the tender a credit card?
    // @return whether or not the tender is a credit card
    boolean isCreditCard();

    // Is the tender a tokenized card?
    // @return whether or not the tender is a tokenized card?
    boolean isTokenizedCard();

    // Is the tender a debit card?
    // @return whether or not the tender is a debit card
    boolean isDebitCard();

    // Is the tender a manually entered card number?
    // @return whether or not the tender is a manually entered card number
    boolean isManualCardEntry();

    // Does the tender have mag stripe data elements?
    // @return whether or not the tender has mag stripe data elements
    boolean hasMagStripeData();

    // Does the tender have EMV data elements?
    // @return whether or not the tender has EMV data elements
    boolean hasEmvData();

    // Does the tender have a particular AVS data element?
    // @param field a particular AVS field
    // @return whether or not the tender has a value for a given AVS field
    boolean hasAvsData(ECLAVSField field);

    // Retrieves the ECLTenderType for the tender
    // @return the tender type
    ECLTenderType getType();

    // Provides a value for a given AVS field
    // @param field is one of the enum values from ECLAVSField
    // @param fieldValue is the value you want to set the AVS field to
    void setAVSField(ECLAVSField field, String fieldValue);
}

References

com.elavon.commerce.ECLTenderRequirementsInterface

package com.elavon.commerce;
 
 
// Specifies the information which is required for a tender to be successfully used for a transaction
@SupportedSince(Version = "2.4.0")
public interface ECLTenderRequirementsInterface
{
    // @return Whether the physical presence of the card must be specified. If a card is not present then it is a card-not-present transaction
    boolean requiresSpecifyingCardPresence();
 
    /// \return The type of signature verification which is required
    ECLSignatureVerificationRequirement getRequiresSignatureVerification();
 
    /// \return The type of voice referral verification which is required
    ECLVoiceReferralRequirement getRequiresVoiceReferral();
 
    /// \return The phone number which should be used for voice referral, when applicable
    String getVoiceReferralPhoneNumber();
 
    /// \ return An error, if applicable, for the last attempted signature submission
    ECCError getLastSignatureError();
 
    /// \return The error that last occurred when trying to continue the transaction after providing the voice referral authorization code
    ECCError getLastVoiceReferralError();
}

Reference

com.elavon.commerce.ECLTenderType

package com.elavon.commerce;

// Tender types that can be used to pay for a transaction
@SupportedSince(Version = "2.4.0")
public enum ECLTenderType
{
    UNKNOWN,
    CARD,
    CASH,
    ELECTRONICCHECK
}

com.elavon.commerce.ECLTidQueryListener

package com.elavon.commerce;

// Listener for Tid query operation
@SupportedSince(Version = "5.2.0")
public interface ECLTidQueryListener
{
    // Notifies POS system the start of TID querying  process
    void started();

    // Notifies POS system the end of log uploading process. If there is any error, tids will be null.
    // @param uccess flag indicating that the process is successfully executed
    // @param mid the MID for which TIDs are queried
    // @param the list TIDs under the MID
    // @param error the specific error when failed.
    void completed(boolean success, String mid, List<String> tids, ECCError error);
}

com.elavon.commerce.ECLTmsUpdateListener

package com.elavon.commerce;
 
// \brief Listener for receiving notifications about a TMS update.
public interface ECLTmsUpdateListener extends ECLGeneralOperationListener
{
    /// \brief Notification that multiple card readers were discovered and one needs to be selected to continue the TMS update.
    /// \param availableCardReaders the available card readers
    void shouldSetCardReaderToUse(List<String> availableCardReaders);
 
    /// \brief Notification of the card reader selected to perform the TMS update.
    /// \param selectedCardReader the name of the card reader to perform the TMS update on.
    void selectedCardReader(String selectedCardReader);
}

Reference

com.elavon.commerce.ECLTransactionInterface

package com.elavon.commerce;
 
// Provides the basis for information required for a transaction
@SupportedSince(Version = "2.4.0")
public interface ECLTransactionInterface
{
    // Gets the type of this transactions.
    // @return the transaction type.
    // @apiNote currently only the following transaction types are supported:
    //     com.elavon.commerce.ECLTransactionType.SALE,
    //     com.elavon.commerce.ECLTransactionType.LINKED_REFUND and
    //     com.elavon.commerce.ECLTransactionType.STANDALONE_REFUND
    com.elavon.commerce.ECLTransactionType getType();
 
    /// \brief Whether or not an attempt to cancel will be effective
    boolean canCancel();
}

Reference

com.elavon.commerce.ECLTransactionMode

package com.elavon.commerce;

// Mode for EMV card
@SupportedSince(Version = "3.0.0")
public enum ECLTransactionMode
{
    ICC_MODE, ///< chip was used
    ICC_FALLBACK_TO_SWIPE_MODE, ///< Unable to use chip. EMV card was swiped
}

com.elavon.commerce.ECLTransactionOutcome

package com.elavon.commerce;

/// Provides information about the outcome of a transaction. Base class for ECLCardTransactionOutcome.
@SupportedSince(Version = "2.4.0")
public class ECLTransactionOutcome
{
    // Specifies if a signature was needed for this transaction
    public boolean isSignatureNeeded();

    // Indicates whether or not the transaction was approved.  'Approved' in this case includes both normal approvals for the full amount requested as well as
    /// partial approvals in which only a portion of the requested amount was authorized.
    public boolean isApproved();

    // Error that occurred during completion of the transaction or null if no error
    public ECCError getError();

    // The type of the transaction.
    public ECLTransactionType getTransactionType();

    // The authorization result of the transaction
    public ECLTransactionAuthorizationResult getAuthorizationResult();

    // Amount authorized for this transaction. In the case where partial approvals has been allowed, this amount may be less than the requested amount.
    public ECLMoney getAmountAuthorized();

    // The date and time which the server recorded for the transaction
    public java.util.Date getDateTime();

    // An unique identifier of the transaction
    public String getIdentifier();

    // Tender type used for the transaction
    public ECLTenderType getTenderType();

    // Gets base amount for the transaction, this amount should be equal to the original amount before any fees are added
    public ECLMoney getBaseAmount();

    // Gets the authorization mode for the transaction.
    public ECLTransactionAuthorizationMode getAuthorizationMode();

    // The tip amount for the transaction
    public ECLMoney getTipAmount();

    // Returns currency code
    public ECLCurrencyCode getCurrencyCode();
}

References

com.elavon.commerce.ECLTransactionProcessingListener

package com.elavon.commerce;
 
// Protocol to give notifications about processing of a transaction.
@SupportedSince(Version = "2.4.0")
public abstract class ECLTransactionProcessingListener
{
    // Notifies POS system that the transaction has completed.
    //
    // 'outcome.error' will be non-null if an error took place. You can then look at the 'outcome.isApproved' to see if the transaction was approved.
    //
    // @param transaction The transaction which completed
    // @param tender The tender which was used for the transaction
    // @param outcome The details of the successful transaction. Can be ECLEmvCardTransactionOutcome, ECLCardTransactionOutcome, or ECLTransactionOutcome instance depending on the type of tender and transaction
    abstract public void transactionDidComplete(final ECLTransactionInterface transaction, final ECLTenderInterface tender, final ECLTransactionOutcome outcome);
 
    /// \brief Notificaties POS system that the transaction has failed
    // @param transaction The transaction which completed
    // @param tender The tender which was used for the transaction
    // @param errors A list of ECCError instances which indicate the reason(s) for the failure
    abstract public void transactionDidFail(final ECLTransactionInterface transaction, final ECLTenderInterface tender, final List<ECCError> errors);
 
    // Notifies POS system that the type of transaction or tender requires more information to complete the transaction.  The required information is specified in the transactionRequires and tenderRequires parameters.
    //
    // The transaction will remain in limbo until the required information has been provided by calling -[ECLTransactionProcessorInterface continueProcessingTransaction]
    // @param transaction The transaction which completed
    // @param tender The tender which was used for the transaction
    // @param transactionRequires Specifies which information, if any, the transaction requires to continue processing
    // @param tenderRequires Specifies which information, if any, the tender type requires to continue processing
    abstract public void shouldProvideInformation(final ECLTransactionInterface transaction, final ECLTenderInterface tender, final ECLTransactionRequirementsInterface transactionRequires, final ECLTenderRequirementsInterface tenderRequires);
 
    /// \brief Notification that a card reader has not been specified for use and multiple card readers are available for selection.
    ///
    /// Before the transaction can continue the following should happen:  one of the card readers should be selected by calling -[ECLDevicesInterface selectDevice:] and then the transaction should be continued by calling -[ECLTransactionProcessorInterface continueProcessingTransaction].
 
    /// \param transaction The transaction which is processing
    /// \param tender The tender which is being used
    /// \param cardReadersReadyForUse The list of card readers available.  These might be used to populate the UI to allow the user to choose which reader should be used.  One of these readers should be passed to -[ECLDevicesProtocol selectDevice:] before continuing the transaction.
    abstract public void shouldSetCardReaderToUse(final ECLTransactionInterface transaction, final ECLTenderInterface tender, final List<String> cardReadersReadyForUse);
 
    // Notifies that the current state of the transaction has changed
    // @param progress Indicates the current state of the transaction
    // @param transaction The transaction which completed
    // @param tender The tender which was used for the transaction
    public void transactionProgress(final ECLTransactionProgress progress, final ECLTransactionInterface transaction, final ECLTenderInterface tender);
}

References

com.elavon.commerce.ECLTransactionProcessorInterface

package com.elavon.commerce;

// Provides access to create and process tenders and transactions.
//
// Also provides what tender types and transaction types are supported.
@SupportedSince(Version = "2.4.0")
public interface ECLTransactionProcessorInterface
{
    // Specifies which types of tender are supported.
    // @return an EnumSet of ECLTenderType instances
    EnumSet<ECLTenderType> getSupportedTenders();

    /// Specifies which types of tender are supported for transaction type.
    /// @param transactionType ::ECLTransactionType that you want supported tender types for.
    /// @return an EnumSet of ECLTenderType instances
    EnumSet<ECLTenderType> getSupportedTendersForTransaction(ECLTransactionType transaction);

    // Creates a card tender instance, to be used to process a transaction using card.
    // @return ECLCardTenderInterface The tender instance
    ECLCardTenderInterface createCardTender();

    // Specifies which types of transactions are supported.
    // @return an EnumSet of ECLTransactionType instances
    EnumSet<ECLTransactionType> getSupportedTransactions();

    // Specifies which types of Cards are supported for passed transaction
    // @return EnumSet of ECLCardType
    EnumSet<ECLCardType> getSupportedCardTypesForCardTransaction(ECLTransactionType transactionType);

    // Specifies which types of Card Entries are supported for passed transaction
    // @return EnumSet of ECLCardEntryType
    EnumSet<ECLCardEntryType> getSupportedCardEntryTypesForCardTransaction(ECLTransactionType transactionType);

    // Creates a sale transaction if transaction processor supports it.
    //
    // Other properties can be set via the returned instance.
    // @param subtotal The subtotal amount for the transaction.
    // @return ECLCurrencyTransactionInterface the instance
    ECLCurrencyTransactionInterface createSaleTransactionWithSubtotal(ECLMoney subtotal);

    // Creates a linked refund transaction if transaction processor supports this (see supportedTransactions)
    //
    // Other properties can be set via the returned instance.
    // @param total The total amount of the transaction being refunded.
    // @param transactionID ID of transaction to be refunded
    // @return ECLCurrencyTransactionInterface the instance
    ECLLinkedRefundTransactionInterface createLinkedRefundTransactionWithTotal(ECLMoney total, String transactionID);

    // Creates a standalone refund transaction if transaction processor supports standalone refund transaction
    //
    // Other properties can be set via the returned instance.
    // @param total The total amount to refund.
    // @return ECLStandaloneRefundTransactionInterface the instance
    ECLStandaloneRefundTransactionInterface createStandaloneRefundTransactionWithTotal(ECLMoney total);

    // Begins processing a transaction
    // @param transaction The transaction to process
    // @param tender The tender to use to complete transaction
    // @param listener The delegate with which to receive updates on the state and progress of the transaction
    void processTransaction(ECLTransactionInterface transaction, ECLTenderInterface tender, ECLTransactionProcessingListener listener);

    // Continues processing a transaction which had previously required more information to continue.
    // @param transaction The transaction to continue processing
    // @param tender The tender to use
    // @param listener The delegate with which to receive updates on the state and progress of the transaction
    void continueProcessingTransaction(ECLTransactionInterface transaction, ECLTenderInterface tender, ECLTransactionProcessingListener listener);
}

References

com.elavon.commerce.ECLTransactionProgress

package com.elavon.commerce;
 
// Progress of current transaction
@SupportedSince(Version = "1.2.4")
public enum ECLTransactionProgress
{
    STARTING, ///< Indicates the transaction has started.
    UNDEFINED,  ///< Indicates that the transaction is in-progress but its exact state is not known.  In practice this should not occur
    ONLINE_AUTHORISATION,  ///< Indicates the transaction is going online for authorisation.
    CARD_ENTRY_PROMPTED, ///<Indicates card entry has been prompted on the PIN pad.
    BAD_CARD_ENTRY_PROMPTED, ///<Indicates card entry has been prompted on the PIN pad after unreadable/unusable card
    CARD_READ_ERROR, ///<Indicates that the card could not be read (if card source could not be determined)
    CARD_READ_DECLINED, ///<Indicates that the reader did not accept or failed to properly read the card (e.g., iPhone in bad position).
    CARD_INSERT_ERROR, ///<Indicates that the inserted card could not be read
    CARD_REMOVE_PROMPTED, ///<Indicates card removal has been prompted on the PIN pad.
    CARD_REMOVED, ///<Indicates card has been removed from the PIN pad.
    CARD_FLOOR_LIMIT_EXCEEDED, ///< Indicates that base transaction amount exceeds the amount allowed for the card.
    CARD_PROXIMITY_FLOOR_LIMIT_EXCEEDED, ///< Indicates that base transaction amount exceeds the amount allowed for the proximity/contactless card.
    SMARTCARD_INSERTED, ///<Indicates a smartcard has been inserted into the PIN pad.
    SMARTCARD_REMOVE_PROMPTED, ///<Indicates card removal has been prompted on the PIN pad.
    SMARTCARD_REMOVED, ///<Indicates a smartcard has been removed from the PIN pad.
    SMARTCARD_PROCESSING, ///<Indicates that the EMV transaction is being processed
    SMARTCARD_PROCESSING_ONLINE, ///<Indicates that the EMV transaction is being processed online
    SMARTCARD_REVERSING, ///<Indicates that an EMV reversal is being performed
    CARD_ENTRY_BYPASSED, ///<Indicates card entry on the PIN pad has been bypassed.
    CARD_ENTRY_TIMED_OUT, ///<Indicates card entry on the PIN pad has timed out.
    CARD_ENTRY_ABORTED, ///<Indicates card entry on the PIN pad has been aborted.
    CARD_SWIPED, ///<Indicates a card has been swiped on the PIN pad.
    CARD_TAPPED, ///<Indicates a card has been tapped (contactless) on the PIN pad.
    CARD_MANUALLY_ENTERED, ///<Indicates a card has been manually entered (keyed) on the PIN pad.
    SMARTCARD_TAPPED, ///<Indicates a smartcard has been tapped (contactless) on the PIN pad.
    CARD_SWIPE_SMARTCARD_REJECTED, ///<Indicates that an ICC was swiped. It should be inserted instead
    CARD_SWIPE_ERROR, ///<Indicates an error occurred when swiping a card on the PIN pad.
    CARD_SWIPE_FALLBACK_PROMPTED, ///<Indicates that fallback mode is in effect
    LANGUAGE_SELECTED_MANUALLY, ///<Indicates language selection has been done manually on the PIN pad.
    LANGUAGE_SELECTED_AUTOMATICALLY, ///<Indicates language selection has been done automatically.
    APPLICATION_SELECTION_STARTED, ///<Indicates application selection on the PIN pad has been started.
    APPLICATION_SELECTED_MANUALLY, ///<Indicates application selection has been done manually on the PIN pad.
    APPLICATION_SELECTED_AUTOMATICALLY, ///<Indicates application selection has been done automatically.
    APPLICATION_SELECTION_ACCEPTED, ///<Indicates application selection on the PIN pad has been accepted.
    APPLICATION_SELECTION_REJECTED, ///<Indicates application selection on the PIN pad has been rejected.
    APPLICATION_SELECTION_COMPLETED, ///<Indicates application selection on the PIN pad has been completed.
    EXTERNAL_APPLICATION_SELECTION_STARTED, ///<Indicates external (i.e. via the POS) application selection has been started.
    EXTERNAL_PAYMENT_TYPE_SELECTION_STARTED, ///<Indicates external (i.e. via the POS) payment type selection has been started.
    EXTERNAL_PAYMENT_TYPE_SELECTION_COMPLETED, ///<Indicates external (i.e. via the POS) payment type selection has been completed.
    EXTERNAL_ACCOUNT_TYPE_SELECTION_STARTED, ///<Indicates external (i.e. via the POS) account type selection has been started.
    EXTERNAL_ACCOUNT_TYPE_SELECTION_COMPLETED, ///<Indicates external (i.e. via the POS) account type selection has been completed.
    GRATUITY_ENTRY_STARTED, ///<Indicates gratuity entry on the PIN pad has been started. - status sent at onGratuityEntryStarted
    GRATUITY_ENTRY_COMPLETED, ///<Indicates gratuity entry on the PIN pad has been completed. - status sent at onTransactionGratuityEntryAvailable
    CHANGE_LANGUAGE_STARTED, ///<Indicates language selection on the PIN pad has been started. - status sent at onGratuityLanguageSelectionStarted
    CHANGE_LANGUAGE_COMPLETED, ///<Indicates language selection on the PIN pad has been completed.
    GRATUITY_QUICK_VALUE_ENTRY_STARTED, ///<Indicates quick value gratuity value entry on the PIN pad has been started. - status sent at onGratuityQuickValueEntryStarted
    GRATUITY_QUICK_VALUE_ENTRY_COMPLETED, ///<Indicates quick value gratuity value entry on the PIN pad has been completed.
    GRATUITY_CUSTOM_VALUE_ENTRY_STARTED, ///<Indicates custom gratuity value entry on the PIN pad has been started. - status sent at onGratuityCustomValueEntryStarted
    GRATUITY_CUSTOM_VALUE_ENTRY_COMPLETED, ///<Indicates custom gratuity value entry on the PIN pad has been completed. - status sent at onTransactionGratuityEntryAvailable
    GRATUITY_VALUE_VERIFICATION_STARTED, ///<Indicates gratuity value verification on the PIN pad has been started. - status sent at onGratuityValueVerificationStarted
    GRATUITY_VALUE_VERIFICATION_COMPLETED, ///<Indicates gratuity value verification on the PIN pad has been completed. - status sent at onGratuityValueVerificationAvailable
    GRATUITY_CANCELLATION_CONFIRMATION_STARTED, ///<Indicates gratuity cancellation confirmation on the PIN pad has been started. - status sent at onGratuityCancellationConfirmationStarted
    GRATUITY_CANCELLATION_CONFIRMATION_COMPLETED, ///<Indicates gratuity cancellation confirmation on the PIN pad has been completed. - status sent at onGratuityCancellationConfirmationAvailable
    PIN_ENTRY_STARTED, ///<Indicates PIN entry on the PIN pad has been started.
    PIN_ENTRY_OFFLINE_ACCEPTED, ///<Indicates PIN was entered on the PIN pad (offline).
    PIN_ENTRY_ONLINE_ACCEPTED, ///<Indicates PIN entry on the PIN pad has been accepted (online).
    PIN_ENTRY_COMPLETED, ///<Indicates PIN entry on the PIN pad has been completed.
    PIN_ENTRY_ABORTED, ///<Indicates PIN entry on the PIN pad has been aborted.
    PIN_ENTRY_BYPASSED, ///<Indicates PIN entry on the PIN pad has been bypassed.
    PIN_ENTRY_TIMED_OUT, ///<Indicates PIN entry on the PIN pad has timed out.
    PIN_ENTRY_INCORRECT, ///<Indicates PIN entry on the PIN pad was incorrect.
    LAST_PIN_ENTRY, ///<Indicates PIN entry on the PIN pad was the last one.
    AMOUNT_CONFIRMATION_STARTED, ///<Indicates amount confirmation on the PIN pad has been started.
    AMOUNT_CONFIRMATION_COMPLETED, ///<Indicates amount confirmation on the PIN pad has been completed.
    AMOUNT_CONFIRMATION_ABORTED, ///<Indicates amount confirmation on the PIN pad has been aborted.
    AMOUNT_CONFIRMATION_BYPASSED, ///<Indicates amount confirmation on the PIN pad has been bypassed.
    AMOUNT_CONFIRMATION_TIMED_OUT, ///<Indicates amount confirmation on the PIN pad has timed out.
    SIGNATURE_VERIFICATION_STARTED, ///<Indicates signature verification started.
    SIGNATURE_VERIFICATION_COMPLETED, ///<Indicates signature verification completed.
    VOICE_REFERRAL_STARTED, ///<Indicates voice referral started.
    VOICE_REFERRAL_COMPLETED, ///<Indicates voice referral completed.
    SIGNATURE_PROCESSING_STARTED, ///<Indicates signature is being processed
    VOICE_REFERRAL_PROCESSING_STARTED, ///<Indicates voice referral is being processed
    DEVICE_KEYS_UPDATE_STARTED, ///<Indicates keys update on the PIN pad has been started.
    DEVICE_KEYS_UPDATE_COMPLETED, ///<Indicates keys update on the PIN pad has been completed.
    DEVICE_KEYS_UPDATE_ABORTED, ///<Indicates keys update on the PIN pad has been aborted.
    FIRMWARE_UPDATE_STARTED, ///<Indicates firmware update on the card reader has been started.
    MAC_VALUE_CALCULATION_STARTED, ///<Indicates MAC value calculation on the card reader has started.
    MAC_VALUE_CALCULATION_COMPLETED, ///<Indicates MAC value calculation on the card reader has completed.
    MAC_VALUE_CALCULATION_ABORTED, ///<Indicates MAC value calculation on the card reader been aborted.
    MAC_VALUE_VALIDATION_STARTED, ///<Indicates MAC value validation on the card reader has started.
    MAC_VALUE_VALIDATION_COMPLETED, ///<Indicates MAC value validation on the card reader has completed.
    MAC_VALUE_VALIDATION_ABORTED, ///<Indicates MAC value validation on the card reader been aborted.
    SESSION_KEY_LOADING_STARTED, ///<Indicates Session Key(s) loading on the card reader has started.
    SESSION_KEY_LOADING_COMPLETED, ///<Indicates Session Key(s) loading on the card reader has completed.
    SESSION_KEY_LOADING_ABORTED, ///<Indicates Session Key(s) loading on the card reader been aborted.
    SESSION_KEY_RETRIEVAL_STARTED, ///<Indicates Session Key(s) retrieval (i.e. from payment gateway) has started.
    SESSION_KEY_RETRIEVAL_COMPLETED, ///<Indicates Session Key(s) retrieval (i.e. from payment gateway) has started.
    SESSION_KEY_RETRIEVAL_ABORTED, ///<Indicates Session Key(s) retrieval (i.e. from payment gateway) has started.
    ELAVON_UPDATE_STARTED, ///<Indicates Elavon update on the card reader has been started.
    ELAVON_UPDATE_REBOOT, ///<Indicates Elavon update on the card reader has benn completed and CSDK library will reboot the device.
    EMV_KEY_UPDATE_REBOOT, ///<Indicates EMV key update on the card reader has benn completed and CSDK library will reboot the device.
    FIRMWARE_UPDATE_REBOOT, ///<Indicates firmware update on the card reader has benn completed and CSDK library will reboot the device.
    DEVICE_UPDATE_COMPLETED, ///<Indicates update on the card reader has been completed.
    DEVICE_UPDATE_ABORTED, ///<Indicates update on the card reader has been aborted.
    PIN_PAD_WAITING_STARTED, ///<Indicates that we are starting to wait on a PIN Pad
    PIN_PAD_WAITING, ///<Indicates that we are waiting on a PIN Pad
    PIN_PAD_WAITING_COMPLETED, ///<Indicates that we are done waiting on a PIN Pad
    PIN_PAD_INITIALIZING, ///<Indicates that we have found a PIN Pad
    ATM_CARD_REJECTED, ///<Indicates that the card is an ATM only card
    TRANSACTION_COMPLETED, ///<Indicates that transaction has completed
    PIN_PAD_SIGNATURE_DRAWING_STARTED, ///<Indicates that signature drawing has started on card reader
    PIN_PAD_SIGNATURE_DRAWING_COMPLETED, ///<Indicates that signature drawing has completed on card reader
    PIN_PAD_RESETTING, ///<Indicates that card reader is resetting
    PIN_PAD_REBOOTING, ///<Indicates that card reader is rebooting
    CARD_READER_TRANSACTION_STARTED, ///<Indicates that transaction started on card reader
    CARD_READER_TRANSACTION_COMPLETED, ///<Indicates that transaction completed on card reader (we are only done on card reader)
    PAYMENT_TYPE_SELECTION_STARTED, ///<Indicates selection of payment type (credit vs debit) has started on card reader
    PAYMENT_TYPE_SELECTION_COMPLETED, ///<Indicates selection of payment type (credit vs debit) has completed on card reader
    ACCOUNT_TYPE_SELECTION_STARTED, ///<Indicates selection of debit card account type has started on card reader
    ACCOUNT_TYPE_SELECTION_COMPLETED, ///<Indicates selection of debit card account type has completed on card reader
    DEVICE_PAIRING_STARTED,
    DEVICE_PAIRING_COMPLETED,
    CARD_ENTRY_COMPLETED,
    REINSERT_PROMPTED, ///<Indicates card removal and insert has been prompted on the PIN pad.
    SWIPE_CARD_ERROR_AND_CARD_ENTRY_PROMPTED,
    CARD_RESWIPE_PROMPTED, ///<Indicates card re-swipe has been prompted on the PIN pad.
    CARD_INSERT_PROMPTED, ///<Indicates card insert has been prompted on the PIN pad.
    CARD_SWIPE_PROMPTED, ///<Indicates card swipe has been prompted on the PIN pad.
    CARD_INSERT_OR_SWIPE_PROMPTED, ///<Indicates card insert or swipe has been prompted on the PIN pad.
    CHECK_CONTACTLESS_PHONE,
    DEVICE_CONFIGURATION_SESSION_KEYS_REQUESTED_STARTED, ///<Indicates starting the request for device session keys (e.g., Canada)
    DEVICE_CONFIGURATION_SESSION_KEYS_REQUESTED_COMPLETED, ///<Indicates completing the request for device session keys (e.g., Canada)
    TRANSACTION_QUERY_COMPLETE, ///< Indicates the transaction query response has been handled
    PIN_PAD_RECONNECT, ///< Indicates pin pad needs to be reconnected during a transaction
    SET_DAILY_REBOOT_TIME_STARTED, ///< Indicates setting of V4 card reader daily reboot time was started
    SET_DAILY_REBOOT_TIME_COMPLETED, ///< Indicates setting of V4 card reader daily reboot time was completed
    BIN_LOOKUP_NEEDED, ///< Indicates BIN lookup is needed
    BIN_LOOKUP_STARTED, ///< Indicates BIN lookup request was sent to Converge payment gateway
    BIN_LOOKUP_COMPLETED, ///< Indicates BIN lookup response was received and deserialized
    SERVICE_FEE_LOOKUP_NEEDED, ///< Indicates Service Fee lookup is needed
    SERVICE_FEE_LOOKUP_STARTED, ///< Indicates Service Fee lookup request was sent to Converge payment gateway
    SERVICE_FEE_LOOKUP_COMPLETED, ///< Indicates Service Fee lookup response was received and deserialized
    SURCHARGE_CONFIRMATION_STARTED, ///< Indicates Surcharge Confirmation form is displayed on card reader
    SURCHARGE_CONFIRMATION_CHANGE_CARD, ///< Indicates consumer pressed the 'Change Card' button on Surcharge Confirmation form displayed on card reader
    SURCHARGE_CONFIRMATION_ACCEPTED, ///< Indicates consumer pressed the 'Accept' button on Surcharge Confirmation form displayed on card reader
    SERVICE_FEE_CONFIRMATION_STARTED, ///< Indicates Service fee Confirmation form is displayed on card reader
    SERVICE_FEE_CONFIRMATION_ACCEPTED, ///< Indicates consumer pressed the 'Accept' button on Service Fee Confirmation form displayed on card reader
    ZIP_CODE_ENTRY_PROMPTED, ///< ZIP entry prompt is displayed on card reader
    ZIP_CODE_ENTERED, ///< Zip code is entered on card reader,
    APPLICATION_UPDATE_STARTED, ///< Device application update started
    CONFIGURATION_UPDATE_STARTED, ///< Device configuration update started
    PIN_PAD_CHECK_STARTED, ///< Pin pad check starting
    PIN_PAD_CHECK_COMPLETED, ///< Pin pad check completed
    PIN_PAD_UPDATE_STARTED, ///< Pin pad update starting
    PIN_PAD_UPDATE_COMPLETED, ///< Pin pad update completed
    LOG_UPLOAD_STARTING, ///< Start to upload log to server.
    LOG_UPLOAD_COMPLETED, ///< Operation of log upload is completed.
    PIN_UPDATE_STARTING, ///< Start to pin update.
    PIN_UPDATE_COMPLETED, ///< Operation of pin update is completed.
    CONFIGURATION_UPDATE_FILE_DEPLOYED, ///< Indicates configuration file has been deployed to card reader during configuration
    CARD_READER_CONFIGURATION_UPDATE_STARTED, ///< Indicates configuration update on card reader started
    CARD_READER_CONFIGURATION_UPDATE_ABORTED, ///< Indicates configuration update on card reader aborted
    CARD_READER_CONFIGURATION_UPDATE_COMPLETED, ///< Indicates configuration update on card reader completed
    PASSWORD_UPDATE_STARTED, ///< Indicates password update started
    PASSWORD_UPDATE_COMPLETED, ///< Indicates password update completed
    CARD_READER_UPDATE_TIME_ZONE_STARTED, ///< Indicates timezone update on card reader started
    CARD_READER_UPDATE_TIME_ZONE_COMPLETED, ///< Indicates timezone update on card reader completed
}

com.elavon.commerce.ECLTransactionRequirementsInterface

package com.elavon.commerce;

// Specifies the information which is required for a transaction to be processed
@SupportedSince(Version = "2.4.0")
public interface ECLTransactionRequirementsInterface
{
    // Whether or not tax must be specified. Tax defaults to null so this will never be true.
    boolean isTaxRequired();

    // Whether or not gratuity must be specified. If you do not want gratuity set it to null on the transaction.
    boolean isGratuityRequired();

    // Whether or not a discount must be specified. Discount defaults to null so this will never be true.
    boolean isDiscountRequired();
}

com.elavon.commerce.ECLTransactionState

package com.elavon.commerce;

// State of a transaction that will be returned after processing or in search results
@SupportedSince(Version = "2.4.0")
public enum ECLTransactionState
{
    UNCOMMITTED,
    COMMITTED,
    PARTIALLY_COMMITTED,
    VOID,
    HOLD,
    UNDER_REVIEW,
    FAILED_DUE_TO_POST_AUTH_RULE,
    FAILED_DUE_TO_PRE_AUTH_RULE,
    FAILED_DUE_TO_FRAUD_PREVENTION,
    UNKNOWN,
    ;

    // Checks if transaction state is committed.
    // @return true if transaction is already committed (and ready for settlement)
    public static boolean isCommitted(ECLTransactionState stateToCheck);
}

com.elavon.commerce.ECLTransactionType

package com.elavon.commerce;

// Transaction types
@SupportedSince(Version = "2.4.0")
public enum ECLTransactionType
{
    SALE, ///< Standard Sale that can have tax, tip, discount, etc.
    SALE_LEVEL3, ///< Level 3 Sale transaction which should have level3 attributes besides what should be provided for SALE transaction.
    LINKED_REFUND, ///< Refund that is linked to a previous sale transaction
    STANDALONE_REFUND, ///< Refund that is not linked to a previous sale transaction.
    REFUND, ///< Generic Refund that is used for Converge responses, Converge doesn't specify different refund types
    VOID, ///< Void of a previous sale or refund transaction
    PRE_AUTH, ///< PreAuthorization of sale transaction
    PRE_AUTH_LEVEL3, ///< Level 3 Pre auth transaction which should have level3 attributes besides what should be provided for PRE_AUTH transaction.
    PRE_AUTH_COMPLETE, ///< Completion of a previous pre-auth transaction
    PRE_AUTH_DELETE, ///< Deletion of a previous pre-auth transaction
    FORCED_SALE, ///< Represents a forced sale transaction.  NOTE: This value should not be used when creating a transaction.  This value is only used when evaluating
    transaction search results.
    MONEY_TRANSFER_OCT, ///< OCT (Original Credit Transaction) Money Transfer
    TIP_ADJUST, ///< Tip adjustment post-authorization,
    BALANCE_INQUIRY, ///< Balance inquiry for debit or gift card
    OCT_FUNDING, ///< OCT (Original Credit Transaction) Funding, instantly fund transactions to a merchants debit account
    SCHEDULE_SETTLE, ///< Schedule settling for all the outstanding unsettled transactions.

    UNKNOWN;

    // Is the type some type of flavor of refund?
    // @param type the transaction type
    // @return whether or not the type param was one of the refund variants
    public static boolean isRefund(ECLTransactionType type);

    // Is the type some type of flavor of sale?
    // @param type the transaction type
    // @return whether or not the type param was one of the sale variants
    public static boolean isSale(ECLTransactionType type);
}

deckard.android.os.AndroidHandler

package deckard.android.os;

// Android handler used internally by CSDK to post tasks
public class AndroidHandler implements Handler
{
    // Instantiates Android Handler with Android OS handler from Android application
    // @param androidHandler the android native handle from Android application
    public AndroidHandler(android.os.Handler androidHandler);
}

Reference

deckard.content.android.AndroidContext

package deckard.content.android;

// Provides CommerceSDK a running context
public class AndroidContext implements deckard.content.Context
{
    // Instantiates Commerce Android Context, wrapping the Android application context.
    public AndroidContext(android.content.Context context);

    // Gets the Android application context.   
    public android.content.Context getContext();
}

Reference

deckard.content.Context

package deckard.content;

// Provides running context for Commerce SDK.
// @apiNote Can be ignored by Commerce SDK integrators.
public interface Context
{
    ContentResolver getContentResolver();

    AudioManager getAudioManager();
}

deckard.os.Handler

package deckard.os;

// Generic handler interface, used internally by CSDK to post tasks
public interface Handler
{
}