SDK de Android v2.1.1

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

allprojects {
	        repositories {
                   …
                   maven {url 'https://developer.huawei.com/repo/'}
               } 
	}

dependencies {
	        implementation 'com.payclip.sdk:payment-ui:2.1.1'
	        implementation 'com.payclip.sdk:plus-reader:1.2.0'
	}

class MyApplication : Application() {
   override fun onCreate() {
       super.onCreate()
       ClipApi.init(this, ClipPlusApi())
   }
}

public class MyApplication extends Application {
   @Override
   public void onCreate() {
       super.onCreate();
       ClipApi.init(this, new ClipPlusApi());
   }
}

ClipApi.login(email: String, password: String, object: LoginListener {
   override fun onLoginSuccess(statusCode: Int) {
       // Login was successful
   }

   override fun onLoginFailed(statusCode: Int) {
       // Login failed
   }
})

ClipApi.logout(String email, String password, new LoginListener() {
    @Override
    public void onLoginSuccess(int statusCode) {
        //Login was successful.
    }

    @Override
    public void onLoginFailed(int statusCode) {
        //Login failed.
    }
});

ClipApi.logout(object : LogoutListener {
   override fun onLogoutSuccess(statusCode: Int) {
       // Logout was successful
   }

   override fun onLogoutFailed(statusCode: Int) {
       // Logout failed
   }
})

ClipApi.logout(new LogoutListener() {
   @Override
   public void onLogoutSuccess(int statusCode) {
       //Logout was successful.
   }

   @Override
   public void onLogoutFailed(int statusCode) {
       //Logout failed.
   }
});

val clipPayment = ClipPayment.Builder()
                .amount(amount: BigDecimal)
                .enableContactless(enabled: Boolean)
                .enableTips(enabled: Boolean)
                .roundTips(round: Boolean)
                .enablePayWithPoints(enabled: Boolean)
                .customTransactionId(customTransactionId: String?)
                .build()

ClipPayment clipPayment = new ClipPayment.Builder()
               .amount(BigDecimal: amount)
               .enableContactless(boolean enabled)
               .enabledTips(boolean enabled)
               .roundTips(boolean round)
               .enablePayWithPoints(boolean enabled)
               .customTransactionId(String customTransactionId)
               .build();

ClipApi.launchPaymentActivity(activity: Activity, payment: ClipPayment, requestCode: Int)

ClipApi.launchPaymentActivity(Activity activity, ClipPayment payment, int requestCode);

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    when (requestCode) {
        REQUEST_CODE_PAYMENT -> {
            when (data?.getIntExtra(StatusCode.RESULT_CODE, StatusCode.FAILURE)) {
                StatusCode.SUCCESSFUL -> {
                    val transactionResult = data.getParcelableExtra<ClipTransaction>(StatusCode.RESULT_PAYMENT_DATA)
                    // Transaction succeeded
                }
                StatusCode.FAILURE -> {
                    // Transaction failed
                }
            }
        }

        else -> super.onActivityResult(requestCode, resultCode, data)
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    String content;
    if (requestCode == REQUEST_CODE_PAYMENT) {
        case REQUEST_CODE_PAYMENT_RESULT :
        switch(data.getIntExtra(StatusCode.RESULT_CODE, StatusCode.FAILURE)) {
            case StatusCode . SUCCESSFUL :
            ClipTransaction transactionResult = data . getParcelableExtra (StatusCode.RESULT_PAYMENT_DATA);
            // Transaction succeeded
            break;
            case StatusCode . FAILURE :
            int errorCode = data . getIntExtra (StatusCode.RESULT_ERROR, -1);
            String errorCodeDesc = data . getStringExtra (StatusCode.RESULT_ERROR_DESC);
            String messageError = data . getStringExtra (StatusCode.RESULT_ERROR_MESSAGE);
            // Transaction failed
            break;
        }
    } else {
        super.onActivityResult(requestCode, resultCode, data);
    }
}

val listOfBins = listOf(CardBin(“XXXXXX”), CardBin(“XXXXXX”))

List<CardBin> listOfBins = Arrays.asList(CardBin(“XXXXXX”), CardBin(“XXXXXX”));

ClipApi.setCardBinRestriction(restrictionType: RestrictionType, listOfBins: List<CardBin>)

ClipApi.setCardBinRestriction(RestrictionType restrictionType, List<CardBin> listOfBins);

ClipHistory.search(SearchParamsRequest.byDate(date: Date, page: Int), object : ClipHistoryListener.OnSearchSuccessListener {
                override fun onSearchSuccess(response: List<ClipTransaction>?) {
                }
            }, , object : ClipHistoryListener.OnErrorListener {
                override fun onError(error: StatusCode.ClipError) {
                }
            })

ClipHistory.search(SearchParamsRequest.byDate(Date date, int page), new ClipHistoryListener.OnSearchSuccessListener() {
            @Override
            public void onSearchSuccess(@Nullable List<ClipTransaction> list) {
            }
        }, new ClipHistoryListener.OnErrorListener() {
            @Override
            public void onError(@NotNull StatusCode.ClipError clipError) {
            }
        });

ClipHistory.detail(receiptNumber: ReceiptNumber, object : ClipListener<ClipTransaction?> {
     override fun onCompleteListener(response: ClipTransaction?, error: StatusCode.ClipError?) {}
})

ClipHistory.detail(ReceiptNumber receiptNumber, new ClipListener<ClipTransaction?>() {
            @Override
            public void onCompleteListener(@Nullable ClipTransaction clipTransaction, @Nullable StatusCode.ClipError error) {
            }
        });

ClipRefund.refund(receiptNumber: ReceiptNumber, object : ClipListener<Boolean> {
                override fun onCompleteListener(response: Boolean, error: StatusCode.ClipError?) {}})

ClipRefund.refund(ReceiptNumber receiptNumber, new ClipHistoryListener<Boolean>() {
            @Override
            public void onCompleteListener(boolean response, @Nullable StatusCode.ClipError error) {
            }
        }});

ClipApi.showSettingsActivity(activity: Activity, loginEnabled: Boolean, logoutEnabled: Boolean, requestCode: Integer)

ClipApi.showSettingsActivity(Activity activity, boolean loginEnabled, boolean logoutEnabled, requestCode: Integer);

ClipApi.launchRemotePaymentActivity(activity: Activity, amount: BigDecimal, requestCode: Int)

ClipApi.launchRemotePaymentActivity(Activity activity, BigDecimal amount, int requestCode);

val query = SearchParamsRequest.byAmount(amount: String, page: Int)

Map<String, String> query = SearchParamsRequest.byAmount(String amount, int page);

val query = SearchParamsRequest.byCustomerEmail(customerEmail: String, page: Int)

Map<String, String> query = SearchParamsRequest.byCustomerEmail(String customerEmail, int page);

val query = SearchParamsRequest.byDate(date: Calendar, page: Int)

Map<String, String> query = SearchParamsRequest.byDate(Calendar date, int page);

val query = SearchParamsRequest.byDateRange(dateFrom: Calendar, dateTo: Calendar, page: Int)

Map<String, String> query = SearchParamsRequest.byDateRange(Calendar dateFrom, Calendar dateTo, int page);

val query = SearchParamsRequest.byRequestNumber(requestCode: String, page: Int)

Map<String, String> query = SearchParamsRequest.byRequestNumber(String requestCode, int page);

ClipRemotePayment.search(searchQuery: SearchQuery, object : ClipListener<RemotePaymentHistoryResponse?> {
    override fun onCompleteListener(response: RemotePaymentHistoryResponse?, error: StatusCode.ClipError?) {

    }

    })

ClipRemotePayment.search(Map<String, String> searchQuery, new ClipListener<RemotePaymentHistoryResponse?>() {
    @Override
    public void onCompleteListener(@Nullable RemotePaymentHistoryResponse response, StatusCode.ClipError error) {

    }
});

val query = SearchParamsRequest.byStatus(status: RemotePaymentFilter, page: Int)

Map<String, String> query = SearchParamsRequest.byStatus(RemotePaymentFilter status, int page);

ClipRemotePayment.detail(requestCode: String, object : ClipListener<RemotePaymentDetailResponse?>{
    override fun onCompleteListener(response: RemotePaymentDetailResponse, error: StatusCode.ClipError?) {

    }

})

ClipRemotePayment.detail(String requestCode, new ClipListener<RemotePaymentDetailResponse>(){
    @Override
    public void onSuccess(@Nullable RemotePaymentDetailResponse response, @Nullable StatusCode.ClipError error) {

    }

});

ClipRemotePayment.cancel(requestCode: RequestCode, object : ClipListener<RemotePaymentDetailResponse?>{
    override fun onCompleteListener(response: RemotePaymentDetailResponse?, error: StatusCode.ClipError?) {
        
    }

})

ClipRemotePayment.cancel(RequestCode requestCode, new ClipListener<RemotePaymentDetailResponse>() {
    @Override
    public void onCompleteListener(@Nullable RemotePaymentDetailResponse response, @Nullable StatusCode.ClipError error) {
        
    }

});