On iOS

pod 'Starscream', :git => 'https://github.com/clover/Starscream.git', :branch => 'queuePriority'
pod 'CloverConnector', :git => 'https://github.com/clover/remote-pay-ios.git', :tag => '3.0.2'

post_install do |installer|
    ['CloverConnector'].each do |targetName|
        targets = installer.pods_project.targets.select { |target| target.name == targetName }
        target = targets[0]
        target.build_configurations.each do |config|
            config.build_settings['SWIFT_VERSION'] = '4.0'
        end
    end
end

/// To connect over a network, you will need a PairingDeviceConfiguration
/// class to handle pairing callbacks from the Clover device
        class ExamplePairingDeviceConfig : PairingDeviceConfiguration {
            
            @objc private func onPairingCode(pairingCode: String) {
                // present pairingCode to the user to be
                // entered on the Clover Device
                ...
            }
            @objc private func onPairingSuccess(authToken: String) {
                // The authToken can be used for the next connection
                // WebSocketDeviceConfiguration (see pairingAuthToken below)
                ...
            }
        }

        let pdc = ExamplePairingDeviceConfig()
        // ws vs wss must match Network Pay Display setting
        // wss requires Clover root CA
        let endpoint = "ws://192.168.0.15:12345/remote_pay" 
        
        // Network Pay Display must be installed and configured to allow 
        // insecure connections for the above configuration

        // Create a WebSocketDeviceConfiguration with the appropriate
        // remoteApplicationID (see above), POS name, and POS serial number
        let configuration = WebSocketDeviceConfiguration(endpoint: endpoint,
        // remoteApplicationID, posName and 
        // posSerial are associated with
        // pairingAuthToken
        remoteApplicationID: "SWDEFOTWBD7XT.9MGLGMDLSYWTV", 
        posName: "Aisle 2",
        posSerial: "ABC123",
        pairingAuthToken: nil,
        // use token from onPairingSuccess callback
        pairingDeviceConfiguration: pdc)

/// Use instance of WebSocketDeviceConfiguration
cloverConnector = CloverConnector(config: configuration)

// Create an implementation of ICloverConnectorListener
	class ExampleCloverConnectorListener : DefaultCloverConnectorListener {
  	override func onDeviceDisconnected() {
    	// Disconnected
      ...
        	}
          	override func onDeviceConnected() {
            	// Connected, but not available to process requests
              ...
            }
            override func onDeviceReady(merchantInfo: MerchantInfo) {
              // Connected and available to process requests
              ...
            }
        }

// Add an instance of an ICloverConnectorListener
let ccl = ExampleCloverConnectorListener(cloverConnector: cloverConnector)
cloverConnector.addCloverConnectorListener(ccl)

cloverConnector.initializeConnection()

cloverConnector.showMessage("Welcome to Clover Connector!")

public class ExampleCloverConnectorListener:DefaultCloverConnectorListener {
      …
      public override func onSaleResponse(_ response:SaleResponse){
            // check response for success and process accordingly
            // see the ‘Handling the Result of a Sale Transaction’ section below for more detail
            … 
      }
      public override func onConfirmPaymentRequest(){
            // must accept or reject the payment using the ICloverConnector
            // see the ‘Handling the Result of a Sale Transaction’ section below for more detail
            …
      }
      public override func onVerifySignatureRequest(_ request:VerifySignatureRequest) {
            // must accept or reject the signature using the ICloverConnector
            // see the ‘Handling the Result of a Sale Transaction’ section below for more detail 
            …
      }
      …
}

/// hold the pendingPaymentId to track the payment within Clover
let uuid = NSUUID().uuidString as NSString
let pendingPaymentId = uuid.replacingOccurrences(of: "-", with: "")
let saleRequest = SaleRequest(amount: 2250, externalId: pendingPaymentId)
cloverConnector!.sale(saleRequest)

class ExampleCloverConnectorListener:DefaultCloverConnectorListener { 
      override func onSaleResponse(response: SaleResponse) {
          if response.success {
              if let payment = response.payment {
                  if pendingPaymentId == payment.externalPaymentId {
                      // it is the expected payment
                      debugPrint("Got the payment for \(payment.amount ?? -1)")
                  } else {
                      debugPrint("Got a response, but not for the expected payment")
                  }
              } else {
                  debugPrint("Something went wrong...No payment found!")
              }
          } else {
              debugPrint("Payment failed: \(response.reason):\(response.message)")
          }
          
          cloverConnector?.dispose() /// if done using the connector, dispose of it
      }
      // a sale may require payment confirmation requests from the Clover device
      override func onConfirmPaymentRequest(request: ConfirmPaymentRequest) {
          // by default, Clover will just accept the payment
          if let payment = request.payment {
              cloverConnector?.acceptPayment(payment)
          } else {
              debugPrint("Payment is nil in ConfirmPaymentRequest")
          }
      }
      // a sale may require signature verification requests from the Clover device
      override func onVerifySignatureRequest(signatureVerifyRequest: VerifySignatureRequest)       
      {
          // by default, Clover will just accept the signature
          cloverConnector?.acceptSignature(signatureVerifyRequest)
      }
}