# Direct Card API

interface IPoyntCardReaderService{
    /**
      * Initiates the card reader to connect over the specific interface (CT or CL or Both). If a
      * card is found on any of the specified interfaces, the reader establishes an L1 connection
      * to the card.  If a card is not found for the specified duration of time, the command returns
      * an apprepriate error code.
      *
      * @param card read connection options
      * @param callback {@link IPoyntConnectToCardListener}
      */
    void connectToCard(in ConnectionOptions connectionOptions, IPoyntConnectToCardListener callback);

    /**
      * Disconnects from the card (CT or CL or both) and powers off corresponding interface.
      *
      * @param card read connection options
      * @param callback {@link IPoyntDisconnectFromCardListener}
      */
    void disconnectFromCard(in ConnectionOptions connectionOptions, IPoyntDisconnectFromCardListener callback);

    /**
      * Checks whether a card is present in the card reader slot or not. This command does not check
      * whether a connection to the card has been established or not. It only checks if a card is
      * physically inserted in the slot such that the card inserted switch is asserted. It does not
      * apply to contactless interface.
      *
      * @param card read connection options
      * @param callback {@link IPoyntCardInsertListener}
      */
    void checkIfCardInserted(in ConnectionOptions connectionOptions, IPoyntCardInsertListener callback);

    /**
      * Send an APDU command to the card and receive the response APDU.
      *
      * @param apduData containing C-APDU
      * @param callback {@link IPoyntAPDUListener}
      */
    void exchangeAPDU(in APDUData apduData, IPoyntExchangeAPDUListener callback);

    /**
      * Abort any pending connect or wait for card removal operations.
      *
      */
    void abort();
    /**
      * Send a list of APDU commands to the card and receive the response APDU.
      *
      * @param apduData containing list of C-APDU
      * @param callback {@link IPoyntAPDUListListener}
      */
    void exchangeAPDUList(in List<APDUData> apduData, IPoyntExchangeAPDUListListener callback);
}

  ..
  ..
  private ServiceConnection serviceConnection = new ServiceConnection() {
      @Override
      public void onServiceConnected(ComponentName name, IBinder service) {
          cardReaderService = IPoyntCardReaderService.Stub.asInterface(service);
      }
      @Override
      public void onServiceDisconnected(ComponentName name) {
        // service is disconnected
      }
  };
  protected void onResume() {
      super.onResume();
      // Bind to service
      bindService(Intents.getComponentIntent(Intents.COMPONENT_POYNT_CARD_READER_SERVICE),
              serviceConnection, BIND_AUTO_CREATE);
  }
  protected void onPause() {
    super.onPause();
    // Make sure you unbind from service to prevent memory leaks
    unbindService(serviceConnection);
  }
  ..
  ..

  ConnectionOptions connectionOptions = new ConnectionOptions();
  // select the interface to check, can be one of EMV, GSM, SLE
  connectionOptions.setContactInterface(ConnectionOptions.ContactInterfaceType.GSM);
  connectionOptions.setTimeout(60);
  try {
      cardReaderService.checkIfCardInserted(connectionOptions,
          new IPoyntCardInsertListener.Stub() {
              @Override
              public void onCardFound() throws RemoteException {
                  // code to handle card found case
              }
              @Override
              public void onCardNotFound() throws RemoteException {
                  // code to handle card not found
              }
              @Override
              public void onError(PoyntError poyntError) throws RemoteException {
                  // error occured while checking for card presence, check the error message
              }
          });
  } catch (RemoteException e) {
      e.printStackTrace();
  }

  ConnectionOptions connectionOptions = new ConnectionOptions();
  connectionOptions.setContactInterface(ConnectionOptions.ContactInterfaceType.GSM);
  connectionOptions.setTimeout(60);
  try {
      cardReaderService.connectToCard(connectionOptions,
          new IPoyntConnectToCardListener.Stub() {
              @Override
              public void onSuccess(ConnectionResult connectionResult) throws RemoteException {
                  // code to handle card connected case
              }
              @Override
              public void onError(PoyntError poyntError) throws RemoteException {
                  // code to hande error case
              }
          });
  } catch (RemoteException e) {
      e.printStackTrace();
  }

  APDUData apduData = new APDUData();
  apduData.setContactInterface(APDUData.ContactInterfaceType.GSM);
  apduData.setTimeout(60);
  apduData.setCommandAPDU("<YOUR APDU COMMAND>");
  try {
      cardReaderService.exchangeAPDU(apduData,
              new IPoyntExchangeAPDUListener.Stub() {
                  @Override
                  public void onSuccess(String rAPDU) throws RemoteException {
                      // code to handle APDU response
                  }
                  @Override
                  public void onError(PoyntError poyntError) throws RemoteException {
                      // code to handle APDU command error
                  }
              });
  } catch (RemoteException e) {
      e.printStackTrace();
  }

  // first command
  APDUData apduData = new APDUData();
  apduData.setContactInterface(APDUData.ContactInterfaceType.EMV);
  apduData.setTimeout(60);
  apduData.setCommandAPDU("<APDU_1>");

  // second command
  APDUData apduData2 = new APDUData();
  apduData2.setContactInterface(APDUData.ContactInterfaceType.EMV);
  apduData2.setTimeout(60);
  apduData2.setCommandAPDU("<APDU_2>");

  ArrayList<APDUData> apdus = new ArrayList<>();
  apdus.add(apduData);
  apdus.add(apduData2);
  try {
      cardReaderService.exchangeAPDUList(apdus,
              new IPoyntExchangeAPDUListListener.Stub() {
                  @Override
                  public void onResult(List<String> list, PoyntError poyntError) throws RemoteException {
                      if (poyntError != null) {
                          // error occurred
                      } else {
                          // APDU response is in the same order as the commands sent
                      }
                  }
              });
  } catch (RemoteException e) {
      e.printStackTrace();
  }

  ConnectionOptions connectionOptions = new ConnectionOptions();
  connectionOptions.setContactInterface(ConnectionOptions.ContactInterfaceType.GSM);
  connectionOptions.setTimeout(60);
  try {
      cardReaderService.disconnectFromCard(connectionOptions,
              new IPoyntDisconnectFromCardListener.Stub() {
                  @Override
                  public void onDisconnect() throws RemoteException {
                    // code to handle card disconnected
                  }
                  @Override
                  public void onError(PoyntError poyntError) throws RemoteException {
                    // handle error
                  }
              });
  } catch (RemoteException e) {
      e.printStackTrace();
  }