Diversify Your Payment Options with Samsung Pay
secure payment, and then click save and next. fill in the required details to define your in-app service. if you have created one previously, you can also use it instead. then click save and next to advance to the next step. define a tentative debug date by clicking generate new date. click add samsung account to add the samsung accounts that will be used for testing purposes. click done. figure 2: creating an in-app payment service this completes the creation of your service and links it with your application. wait for it to be approved. the team will contact you promptly once your request has been processed. in case of any delays, feel free to reach out to 1:1 support for assistance. samsung pay feature development now that your partner account set up is complete, it's time to integrate samsung pay functionality into your android application. next we will integrate the samsung pay sdk and implement core payment features to enable seamless in-app transactions in your app. download and add the sdk go to the downloads page in samsung pay and scroll down to the android section to download the samsung pay sdk. sdk components the samsung pay sdk has the following components: java library (samsungpay_x.xx.xx.jar): contains the classes and interfaces to integrate with the samsung pay. sample apps: demonstrates the implementation of samsung pay apis to simplify the process of building your own. add the sdk to your project create a folder called ‘libs’ if one does not already exist, and move the sdk .jar file into this folder. /app ├── libs/ │ └── samsungpay_x.xx.xx.jar ├── src/main/ │ ├── kotlin/ │ ├── res/ │ └── androidmanifest.xml configure gradle and dependencies update settings.gradle.kts add the ‘libs’ folder with the other repositories, if it is not there already. dependencyresolutionmanagement { repositories { google() mavencentral() flatdir { dirs 'libs' } } } add the sdk dependency in app/build.gradle.kts add the samsung pay sdk as a dependency for your application. dependencies { implementation(files("libs/samsungpay_x.xx.xx.jar")) } sync the gradle to apply the changes. configure android app manifest add the following configurations in your androidmanifest.xml. this ensures the compatibility and proper functioning of your application. add the element <queries> <package android:name="com.samsung.android.spay" /> </queries> add metadata <meta-data android:name="spay_sdk_api_level" android:value="2.xx" /> <!-- latest version is recommended] --> implement functionality now that the samsung pay sdk integration is complete, let us use this sdk to implement the complete functionality of the samsung pay sdk in your android application. here we will go through the complete flow of initiating a payment using the samsung pay sdk. check samsung pay availability initiating a payment starts by checking if samsung wallet is available for payment or not. initialize the samsung pay service with your partner credentials, then verify if samsung pay is supported. if available, display the samsung pay button in your app. val serviceid = "partner_service_id" val bundle = bundle() bundle.putstring(samsungpay.partner_service_type, samsungpay.servicetype.inapp_payment.tostring()) val partnerinfo = partnerinfo(serviceid, bundle) val samsungpay = samsungpay(context, partnerinfo) samsungpay.getsamsungpaystatus(object : statuslistener { override fun onsuccess(status: int, bundle: bundle) { when (status) { samsungpay.spay_not_supported -> samsungpaybutton.setvisibility(view.invisible) samsungpay.spay_not_ready -> { samsungpaybutton.setvisibility(view.invisible) val errorreason = bundle.getint(samsungpay.extra_error_reason) if (errorreason == samsungpay.error_setup_not_completed) samsungpay.activatesamsungpay() else if (errorreason == samsungpay.error_spay_app_need_to_update) samsungpay.gotoupdatepage() } samsungpay.spay_ready -> samsungpaybutton.setvisibility(view.visible) } } override fun onfail(errorcode: int, bundle: bundle) { samsungpaybutton.setvisibility(view.invisible) log.d(tag, "checksamsungpaystatus onfail() : $errorcode") } }) set up payment details and request the payment after the availability check is completed, you need to set up the payment details such as merchant information, transaction information, order number, and so on, before requesting the payment. the following code snippets show how to accomplish this. make customsheet create a simple custom payment sheet with amounts and items for the transaction. this sheet will be displayed during the payment process. you can customize the sheet according to your requirements. private fun makeupcustomsheet(): customsheet { val amountboxcontrol = amountboxcontrol(amount_control_id, mbinding.currency.selecteditem.tostring()) amountboxcontrol.additem( product_item_id, mcontext.getstring(r.string.amount_control_name_item), mdiscountedproductamount, "" ) amountboxcontrol.additem( product_tax_id, mcontext.getstring(r.string.amount_control_name_tax), mtaxamount + maddedbillingamount, "" ) amountboxcontrol.additem( product_shipping_id, mcontext.getstring(r.string.amount_control_name_shipping), mshippingamount + maddedshippingamount, "" ) amountboxcontrol.setamounttotal(totalamount, amountformat) val sheetupdatedlistener = sheetupdatedlistener { controlid: string, sheet: customsheet -> log.d(tag, "onresult control id : $controlid") updatecontrolid(controlid, sheet) } val customsheet = customsheet() customsheet.addcontrol(amountboxcontrol) return customsheet } make customsheetpaymentinfo create payment information with merchant details, order number, and card brand preferences. private fun maketransactiondetailswithsheet(): customsheetpaymentinfo { // get brandlist (supported card brands) val brandlist = getbrandlist() val customsheetpaymentinfo: customsheetpaymentinfo val customsheetpaymentinfobuilder = customsheetpaymentinfo.builder() customsheetpaymentinfobuilder.setaddressinpaymentsheet(mrequestaddressoptions.requestaddresstype) customsheetpaymentinfo = customsheetpaymentinfobuilder .setmerchantid("your_merchant_id") .setmerchantname("your_merchant_name") .setordernumber("your_order_number") .setaddressinpaymentsheet(customsheetpaymentinfo.addressinpaymentsheet.do_not_show) .setallowedcardbrands(brandlist) .setcardholdernameenabled(mbinding.cardbrandcontrol.displaycardholdername.ischecked) .setcustomsheet(makeupcustomsheet()) .build() return customsheetpaymentinfo } request the payment initiate the samsung pay payment process with transaction details and handle payment callbacks. mpaymentmanager.startinapppaywithcustomsheet( maketransactiondetailswithsheet(), object : customsheettransactioninfolistener{ override fun oncardinfoupdated( selectedcardinfo: cardinfo?, sheet: customsheet? ) { // update your controls if needed based on business logic for card information update. // updatesheet() call is mandatory pass the updated customsheet as parameter. try { paymentmanager.updatesheet(customsheet) } catch (e: java.lang.illegalstateexception) { e.printstacktrace() } catch (e: java.lang.nullpointerexception) { e.printstacktrace() } } override fun onsuccess( customsheetpaymentinfo: customsheetpaymentinfo?, paymentcredential: string?, extrapaymentdata: bundle? ) { // triggered upon successful payment, providing customsheetpaymentinfo and paymentcredential. // for example, you can send the payment credential to your server for further processing with pg. or you could send it directly to the pg as per business need. sendpaymentdatatoserver(paymentcredential) } override fun onfailure(errcode: int, errordata: bundle?) { // fired when the transaction fails, offering error codes and details. log.d(tag, "onfailure() : $errcode") showerrordialog(errcode, errordata) } }) testing and release test and validate to ensure a seamless and reliable integration of samsung pay, thorough testing is essential. this process validates transaction performance and guarantees a positive user experience for making a robust business impact. testing goes beyond error detection; it aims to comprehensively assess the quality and functionality of your samsung pay integration. release after successful testing, the next step is to secure release version approval from samsung through the samsung pay developers portal. once approved, your application can be launched, allowing you to monitor user satisfaction and optimize performance. conclusion by integrating samsung pay in-app payments, you’ve enabled secure, convenient transactions for samsung pay users. this implementation expands your payment options while providing a seamless checkout experience. additional resources for additional information on this topic, refer to the resources below. samsung pay faqs samsung pay in-app payment documentation