Regarding running an application in Tizen Web Simulator
-
Similar Topics
-
By Samsung Newsroom
Integrating payments into a mobile app is a security-critical and UX-sensitive task. While Flutter simplifies cross-platform development, platform-specific payment systems like Samsung Pay still require careful handling.
Samsung provides an official Samsung Pay SDK Flutter Plugin, which allows Flutter applications to integrate Samsung Pay without writing custom platform channels. However, for production-grade integration, using the plugin correctly is essential, especially when it comes to checking Samsung Pay readiness.
In this blog, you learn how to build a sample Flutter application by using the official Samsung Pay SDK Flutter Plugin and following Samsung-recommended best practices. You can download the complete sample project at the end of this blog.
Why Use the Official Samsung Pay SDK Flutter Plugin?
Integrating payment systems requires careful handling of platform constraints, security, and long-term maintainability. The Samsung Pay SDK Flutter Plugin addresses these concerns by providing an official abstraction over the native Samsung Pay SDK, enabling Flutter applications to leverage Samsung Wallet features without direct interaction with platform-specific APIs.
By exposing supported Dart APIs and managing native SDK communication internally, the Flutter plugin removes the need for custom MethodChannel implementations and reduces integration risk. For Flutter applications targeting Samsung Galaxy devices, this approach offers the most stable and maintainable path to Samsung Pay integration.
The following diagram illustrates the high-level architecture of the Samsung Pay integration.
Figure 1: Samsung Pay integration architecture
Prerequisites
Before starting, ensure the following requirements are met:
You are an approved Samsung Pay partner (approval typically takes a few days) A service is created in the Samsung Pay partner portal. Find details from here. The latest version of Android Studio is installed The Flutter SDK is installed and configured The Samsung Pay SDK Flutter Plugin is downloaded Set Up the Integration Code
To start the integration process, add the Samsung Pay SDK Flutter Plugin to your project dependencies:
dependencies: samsung_pay_sdk_flutter: path: ./samsungpaysdkflutter_v1.03.00/samsungpaysdkflutter Next, configure the Samsung Pay SDK API level by setting a valid Samsung Pay SDK API version (latest version: 2.22) by opening android > app > src > main > AndroidManifest.xml and adding the API level in the metadata inside the <application> tag.
<meta-data android:name="spay_sdk_api_level" android:value="2.22" /> <!-- Use the most recent SDK version to leverage the latest APIs --> Initialize Samsung Pay in Flutter
Create an instance of SamsungPaySdkFlutter with valid PartnerInfo (which contains the service ID and service type). If you are a merchant, then the service type must be set to INAPP_PAYMENT.
The following code snippet initializes the Samsung Pay SDK using your service ID and in-app payment configuration.
import 'package:samsung_pay_sdk_flutter/samsung_pay_sdk_flutter.dart'; static final SamsungPaySdkFlutter sdk = SamsungPaySdkFlutter( PartnerInfo( serviceId: SERVICE_ID, data: { SpaySdk.PARTNER_SERVICE_TYPE: ServiceType.INAPP_PAYMENT.name } ) ); Check Samsung Pay Availability
Samsung Pay readiness must be checked before calling any API of the Samsung Pay SDK Flutter Plugin. There are several reasons why Samsung Pay might not be in the ready state, such as an unsupported device, unsupported region, or incomplete Samsung Wallet setup, so this check is mandatory.
SamsungPayConfig.sdk.getSamsungPayStatus( StatusListener( onSuccess: (status, bundle) { // Status "2" means Samsung Pay is READY onResult(status == "2"); }, onFail: (errorCode, bundle) { // If status check fails, Samsung Pay is not ready onResult(false); } ) ); NoteDo not show the Samsung Pay button if the Samsung Pay status is not READY. Create Payment Information with a Custom Payment Sheet
To initiate a transaction, you must create a payment request using a custom payment sheet.
The AmountBoxControl object is mandatory for building a CustomSheet. It provides the monetary details of the transaction.
AmountBoxControl amountControl = AmountBoxControl( Strings.AMOUNT_CONTROL_ID, Strings.currency ); // Add product item to the payment sheet amountControl.addItem( product.productId, product.name, product.price, "" ); // Set total amount (product price + additional fees) // You can add tax, shipping, or other fees here amountControl.setAmountTotal( product.price + 5.00, // Add $5 for shipping/fees as example SpaySdk.FORMAT_TOTAL_PRICE_ONLY ); Next, add the amountBoxControl to the CustomSheet instance.
CustomSheet customSheet = CustomSheet(); customSheet.addControl(amountControl); Finally, create the payment information by populating the CustomSheetPaymentInfo instance
// Configure merchant information for the payment CustomSheetPaymentInfo paymentInfo = CustomSheetPaymentInfo( merchantName: "Samsung Pay Flutter App", customSheet: customSheet ); // Set merchant details paymentInfo.merchantId = "123456"; paymentInfo.setMerchantName("Sample Merchant"); paymentInfo.setMerchantCountryCode("US"); Request Payment
To start the payment process, call the startInAppPayWithCustomSheet() API. This API requires CustomSheetPaymentInfo and CustomSheetTransactionInfoListener instances set up in the last step.
When this API is called, a custom payment sheet is displayed on the merchant application screen. The user can select a registered card for the payment and change the billing and shipping addresses if needed. Payment results are delivered to the CustomSheetTransactionInfoListener.
The onCardInfoUpdated() callback is triggered when the user changes the payment card. In this callback, the updateSheet() method must be called to update current payment sheet.
CustomSheetTransactionInfoListener listener = CustomSheetTransactionInfoListener( onCardInfoUpdated: (PaymentCardInfo cardInfo, CustomSheet sheet) { // Called when user changes the selected card on payment sheet // You can update the sheet here if needed (e.g., change fees based on card) SamsungPayConfig.sdk.updateSheet(sheet); }, onSuccess: (paymentInfo, paymentCredential, extraData) { // Payment completed successfully // paymentCredential contains the encrypted card details to send to your backend print("Payment Successful!"); print("Payment Credential: $paymentCredential"); onSuccess(); }, onFail: (errorCode, bundle) { // Payment failed or user cancelled print("Payment Failed: $errorCode"); onFail(errorCode); } ); Lastly, call startInAppPayWithCustomSheet() API to start the payment:
SamsungPayConfig.sdk.startInAppPayWithCustomSheet(paymentInfo, listener); Testing Samsung Pay Integration
Follow the steps below to test Samsung Pay integration
Configure the STG environment: Add tester accounts to your service and generate a debug expiration date for the test accounts. Install Samsung Wallet test application: To test your application in the staging environment, the latest version of the Samsung Wallet test application is required. You can install it from the Samsung Pay Partner portal. However, to test your app in production mode, you need to use a market released application. Test cards: To thoroughly test your application, you must add at least one payment card to the Samsung Wallet application. Samsung provides test cards for this purpose. Keep in mind that the test cards only work in staging environments, not in production. Run the application: After setting up the environment, build the application and test it on any supported Galaxy device.
Figure 2: Samsung Pay Flutter sample application
Release Your Application
After successful testing, submit your application for release approval through the Samsung Pay Developers Portal. Once approved, your app can be published for your users.
Conclusion
Using the official Samsung Pay SDK Flutter Plugin makes it simpler to create a secure and reliable payment integration for Flutter applications on Galaxy devices. By following Samsung-recommended practices, such as checking Samsung Pay readiness and handling custom payment sheets correctly, you can build a production-ready and maintainable payment experience.
Additional Resources
Samsung Pay Documentation provides an overview of the key features and highlights the benefits of using Samsung Pay. Samsung Pay Partner Onboarding is an end-to-end guide of becoming a partner to release your app. Samsung Pay – Code Lab is an interactive, hands-on tutorial that teaches you to how to integrate Samsung Pay SDK. Samsung Developer Forums is an open community for developers where you can post your query and get support from other developers. Samsung Developer Tech Support Channel is a 1-on-1 support channel where you can get assistance from the Samsung engineers. Download the complete sample project here. View the full blog at its source
-
By Samsung Newsroom
Samsung Electronics today announced that it has supplied more than 6,000 hospitality TVs and Smart Signage displays to Royal Caribbean`s Star of the Seas, the world’s best family vacation. The installation spans guest cabins, crew quarters and public areas — including lounges and theaters. This collaboration marks the latest milestone in a longstanding partnership, with Samsung serving as Royal Caribbean’s official display technology provider across the vacation brand`s fleet over 21 years.
Completing its maiden voyage from Port Canaveral, Florida, in August 2025, Star of the Seas is the second ship in Royal Caribbean’s Icon-class series of cruise ships.
Samsung Hospitality TVs and Smart Signage Provide a New Standard of Onboard Experiences
Designed specifically for commercial environments, Samsung’s Crystal UHD Hospitality TVs (HBU8000 model) have been installed in guest cabins aboard Star of the Seas. Through Samsung’s Dynamic Crystal Color technology — which is capable of displaying over one billion colors — the TVs deliver 4K UHD resolution and lifelike, accurate color, ensuring that each guest enjoys clear, vibrant picture quality and an engaging viewing experience throughout their voyage. Each in-room TV also serves as a central information hub that shares a welcome message personalized for each guest, daily activity schedules, destination information and weather and emergency updates, while also offering the ability to revisit onboard programs and announcements at the user’s convenience.
The ultra-slim UHD Smart Signage QMC series is also featured onboard, providing high-resolution content in public areas while maximizing space efficiency.
Two Decades of Collaboration Anchored by Innovation
Since 2004, Samsung has supplied more than 200,000 hospitality TVs and Smart Signage displays across 28 ships in Royal Caribbean’s global fleet. This includes over 6,000 displays for Icon of the Seas — sister ship to Star of the Seas — which set sail in 2024. Backed by 17 consecutive years as the global leader of the commercial display market,1 Samsung continues to lead the industry in delivering reliable, feature-rich displays tailored for hospitality environments.
“What we’ve achieved with Royal Caribbean over the past 20 years is a testament to our shared commitment to innovation and delivering world-class experiences to guests,” said Hoon Chung, Executive Vice President of the Visual Display Business at Samsung Electronics. “As demand for richer entertainment experiences rise, we’re proud to deliver our most dynamic commercial displays to Star of the Seas and look forward to expanding our collaboration in the years ahead.”
Samsung Expands Display Innovation for Compact Hospitality Spaces
Building on its established leadership in cruise and hospitality display solutions, Samsung has introduced the HF8000F model, a 24-inch hospitality TV developed for compact spaces such as crew cabins, hospitals and hotel rooms. As demand grows for smaller displays that can fit multi-occupancy rooms or space-constrained environments, the HF8000F provides a streamlined option with many of the capabilities of Samsung’s 2025 hospitality lineup, including Google Cast, Apple AirPlay, LYNK Cloud for remote display management, Samsung Knox, Samsung TV Plus and Smart Hub. The HF8000F is now available in multiple regions including the U.S., Canada, Australia and Singapore.
For more on Samsung’s hospitality display solutions, visit Samsung.com.
Source: Omdia Q3 2025 Public Display Report. ︎ View the full article
-
By Samsung Newsroom
Digital identity verification has become a rising topic in the current technological landscape. Samsung Wallet allows Samsung Galaxy device users to securely register their state-issued US driver's license in their device, letting them use it as a mobile driver's license (mDL). Through the "Verify with Wallet" (VWW) functionality, Samsung Wallet provides Android developers with the ability to authenticate a user's identity directly from their application by utilizing the user's registered mDL on the device. The implementation of the functionality is based on and is fully compliant with the ISO 18013-5 standard. In this article, we explore the complete process of implementing Verify with Wallet in an Android application.
Prerequisites
In order to complete the tasks in this article and implement a complete sample application for verifying a user's identity, you need the following:
Valid US driver's license or state ID US region Samsung Galaxy device with mDL support Complete the Samsung Wallet Partner onboarding process Understanding the Verify with Wallet process
Samsung Wallet offers a native Relying Party (RP) SDK for Android applications. RP SDK is an App2App SDK designed for enabling Samsung Wallet's mDL service in online use cases. By integrating this SDK, you can leverage the VWW functionality within their applications.
In your application, you need to create a JSON object for defining the request and a JSON payload for the Relying Party card. Then, you can utilize the RP SDK to create a valid mDoc request using the provided information. Finally, the request needs to be sent to the Samsung Wallet application.
In response, Samsung Wallet sends an encrypted response back to the application, which contains the requested information in a CBOR encoded format. The application can then decode the provided data and use it as necessary. Refer to the ISO 18013-5 standard, AAMVA mDL guidelines and the Samsung Wallet documentation for a better understanding of the VWW process.
Implementing the Verify with Wallet Functionality in Your Android Application
The process of implementing VWW in an Android application includes creating a Relying Party card for Samsung Wallet, downloading and integrating the RP SDK into the Android application and implementing the necessary functions in the Android application for completing the verification process.
Creating a Relying Party Wallet Card Template in the Samsung Wallet Partners Portal
In order to implement and use the VWW functionality, you need a wallet card of the Relying Party type for this purpose.
To create a Relying Party wallet card template:
Go to the Samsung Wallet Partners Portal. Select Wallet Card > Create Wallet Cards. From Wallet Card Templates, select Relying Party. Select the applicable Service Location and Authentication Issuer from the Advanced setting section. Make sure to select the proper values for the card, otherwise the verification process may not work. Figure 1: Creating a Relying Party card for VWW
Integrating the RP SDK in an Android Application
Once the Relying Party card template has been created, we can download and integrate the RP SDK to work with the Android application.
Step 1: Download the RP SDK for Android
To download the RP SDK:
Download the ZIP file containing the latest RP SDK release AAR file from Samsung Wallet Code Resources on the Samsung Developer website. Extract the AAR file from the downloaded ZIP file. Copy and paste the downloaded rp-sdk-x.xx-release.aar file inside a new directory in the Android Studio project (for example, \libs\). Step 2: Add Android Manifest Permissions
To implement the Verify with Wallet functionality, the application needs both the Internet access permission and the ability to query the installed Samsung Wallet application. To provide the application with these permissions, open the AndroidManifest.xml file in the Android Studio project and add the following lines:
<uses-permission android:name="android.permission.INTERNET" /> <queries> <package android:name="com.samsung.android.spay" /> </queries> Step 3: Add Gradle Dependencies
In the application's build.gradle file, load the RP SDK AAR file and the necessary additional dependencies for using the SDK, as follows:
// Load RP SDK AAR file implementation(files("libs/rp-sdk-1.05-release.aar")) //CBOR decoding dependencies implementation("com.upokecenter:cbor:4.0.1") implementation("com.augustcellars.cose:cose-java:1.1.0") // Other dependencies implementation("com.google.code.gson:gson:2.11.0") implementation("org.bouncycastle:bcprov-jdk15to18:1.66") implementation("com.nimbusds:nimbus-jose-jwt:9.37.3") implementation("io.reactivex.rxjava2:rxjava:2.2.21") implementation("io.reactivex.rxjava2:rxkotlin:2.4.0") implementation("io.reactivex.rxjava2:rxandroid:2.1.1") implementation("com.squareup.okhttp3:okhttp:4.11.0") After these steps, the RP SDK is ready for use in your Android application.
Configuring the Android Application for Verify with Wallet
Next, we need to complete the implementation of the Verify with Wallet functionality in your Android application.
Step 1: Build a Card Payload for the Relying Party Card
First, we need to create a request payload for the Relying Party card following the specification.
private fun buildApp2AppPayload(): String { return PAYLOAD .replace("{refId}", UUID.randomUUID().toString()) .replace("{createdAt}", System.currentTimeMillis().toString()) .replace("{updatedAt}", System.currentTimeMillis().toString()) } private val PAYLOAD = """ { "card": { "type": "relyingparty", "data": [ { "createdAt": {createdAt}, "updatedAt": {updatedAt}, "language": "en", "refId": "{refId}", "attributes": { "clientPackageName": "com.ahsan.verifyappsample", "clientType": "app", "fontColor": "#ffffff", "logoImage": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "logoImage.darkUrl": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "logoImage.lightUrl": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "providerName": "Samsung Verification Sample" } } ] } } """.trimIndent() Step 2: Build the AppLink
The AppLink is a tokenized URL that is similar to the CData tokens used for Samsung Wallet cards. The Samsung Wallet RP SDK includes a function to generate the AppLink using the payload and the partner credentials (private key, public key, partner ID, card ID, certificate ID, etc.).
To build the AppLink, you can simply call the rpClientApis.buildAppLink() function with the required parameters:
val rpClientApis = RpClientApis(this) val appLink = rpClientApis.buildAppLink( partnerId = PARTNER_ID, cardId = CARD_ID, payload = buildApp2AppPayload(), samsungPublicKey = SAMSUNG_CERTIFICATE, partnerPublicKey = PARTNER_CERTIFICATE, partnerPrivateKey = PARTNER_PRIVATE_KEY, partnerCertificateId = CERTIFICATE_ID, isStagingServer = true ) Step 3: Build the Request Data
Finally, once the AppLink creation is complete, we can send the verification request using the RP SDK.
Before sending the request, we need to specify exactly which information we wish to retrieve. For this purpose, we need to create a JSON document following the ISO 18013-5 specification and specify the fields we wish to retrieve in the response. It is possible to request for the following fields in the request data under the "org.iso.18013.5.1" namespace:
portrait family_name given_name document_number age_in_years resident_address birth_date issue_date expiry_date sex height weight_range weight eye_colour hair_colour organ_donor driving_privileges veteran Additionally, it is also possible to request for the following 3 fields, under the "org.iso.18013.5.1.aamva" namespace:
domestic_driving_privileges DHS_compliance EDL_credential In our example, we only try to retrieve the following 4 fields: family_name, age_in_years, issue_date, and expiry_date. In the following code example, we build the request string accordingly:
val requestData = """ { "docType": "org.iso.18013.5.1.mDL", "nameSpaces": { "org.iso.18013.5.1": { "family_name": true, "age_in_years": true, "issue_date": true, "expiry_date": true } } } """.trimIndent() Step 4: Create the OnResponseListener Class
When using the VWW RP SDK, it is necessary to create a listener class for both sending the request and for receiving and processing the response from the mDoc server.
For our example, let's create an empty placeholder OnResponseListener class which extends the RP SDK's OnResponseListener class.
class OnResponseListener(private val requestData: String) : RpClientApis.OnResponseListener{ override fun onGetMdocRequestData(deviceEngagementBytes: ByteArray): ByteArray? { TODO("Not yet implemented") } override fun onMdocResponse(encryptedResponseBytes: ByteArray) { TODO("Not yet implemented") } override fun onMdocResponseFailed(exception: Exception) { Log.e(TAG, "Response processing failed", exception) } } Initiating the Verification Request
To initiate the identity verification process, we need to establish a secure session and send a structured request to the Samsung Wallet application. We can use the previously created OnResponseListener class for this purpose.
Step 1: Define the onGetMdocRequestData() Function for Sending the Request Data
Inside the onGetMdocRequestData() function, we need to do 2 things for establishing a secure encrypted session:
Generate an elliptic curve key pair Build session establishment bytes following the ISO-18013-5 specification. Once the key pair is generated, we can use this key pair, the device engagement bytes, and the previously created request data for building the encrypted session establishment bytes. The device engagement bytes are provided automatically inside the onGetMdocRequestData() function by the RP client SDK.
private val secureRepository = SecureRepository() override fun onGetMdocRequestData(deviceEngagementBytes: ByteArray): ByteArray? { val keyPair = secureRepository.generateEcKeyPair() val encryptedSessionEstablishmentBytes = secureRepository.buildSessionEstablishment(requestData, deviceEngagementBytes, keyPair) return encryptedSessionEstablishmentBytes!! } For further information regarding generating the key pair and building the session establishment bytes, check the provided sample code.
Step 2: Initiate a Verification Request with the AppLink
Once the onGetMdocRequestData() function is ready, we can use the request() function to initiate the verification request.
val sessionId = UUID.randomUUID().toString() val WALLET_PACKAGE = "com.samsung.android.spay" rpClientApis.request( WALLET_PACKAGE, sessionId, appLink, OnResponseListener(requestData) ) Processing the Request Response
Once the mDoc request has been sent and processed successfully, the application should receive a ByteArray as response in the onMdocResponse() function inside the listener class. This ByteArray is an encrypted JSON object. Once decrypted, the response should look like the following:
{ "documents": [ { "issuerSigned": { "nameSpaces": { "org.iso.18013.5.1": [ "pGhkaWdlc3RJRBkU-mZyYW5kb21UaGNkNGduZDl5Z2I1cTRjaDV4ZnpxZWxlbWVudElkZW50aWZpZXJrZXhwaXJ5X2RhdGVsZWxlbWVudFZhbHVlwHQyMDMxLTExLTIxVDA3OjAwOjAwWg", "pGhkaWdlc3RJRBknbWZyYW5kb21Udjg1NmsydzIzZzQ3OHk5cTQ0aHJxZWxlbWVudElkZW50aWZpZXJsYWdlX2luX3llYXJzbGVsZW1lbnRWYWx1ZRgr", "pGhkaWdlc3RJRBlvWWZyYW5kb21UbnRtdnJ5OXlucXcyZjY2bmp2NXRxZWxlbWVudElkZW50aWZpZXJqaXNzdWVfZGF0ZWxlbGVtZW50VmFsdWXAdDIwMjMtMTEtMDhUMDc6MDA6MDBa", "pGhkaWdlc3RJRBnXQWZyYW5kb21UOXJqd2NydjZ6cXpqZm1xajNkcnhxZWxlbWVudElkZW50aWZpZXJrZmFtaWx5X25hbWVsZWxlbWVudFZhbHVlZUFoc2Fu" ] }, "issuerAuth": [ "dCBa", { "33": "..." }, "...", "..." ] }, "deviceSigned": {…}, "docType": "org.iso.18013.5.1.mDL" } ], "version": "1.0", "status": 0 } The values inside the org.iso.18013.5.1 JSON Array are the information we requested, in the CBOR (Concise Binary Object Representation) format.
For example, if we decode the value: "pGhkaWdlc3RJRBlvWWZyYW5kb21UbnRtdnJ5OXlucXcyZjY2bmp2NXRxZWxlbWVudElkZW50aWZpZXJqaXNzdWVfZGF0ZWxlbGVtZW50VmFsdWXAdDIwMjMtMTEtMDhUMDc6MDA6MDBa", we find that this CBOR object contains the issue_date field and its value is 2023-11-08T07:00:00.000Z. Similarly, every value provided in the array is a CBOR object that can be decoded using CBOR decoders to find a key-value pair containing the requested information.
We can now receive the mDoc response in the onMdocResponse() function and decode it to retrieve the final requested values:
override fun onMdocResponse(encryptedResponseBytes: ByteArray) { val plainResponse = secureRepository.decryptMdocResponse(encryptedResponseBytes) Log.i(TAG, "plainResponse=${plainResponse?.toPrettyJson()}") val mDocContent = Mdoc18013Utils.parseMdocResponse(plainResponse!!) mDocContent.forEach { (key, value) -> Log.i(TAG, "$key: $value") } } Here, secureRepository.decryptMdocResponse() performs the decryption operation and converts the encrypted bytes into a plain JSON response. Afterwards, the Mdoc18013Utils.parseMdocResponse() function takes the plain response and decodes each CBOR-encoded element contained in the org.iso.18013.5.1 array and returns these values in a simplified dictionary of key-value pairs. If you wish to learn more about these functions, you can check out the provided sample code.
With this step, the sample application's implementation of Verify with Wallet is complete. You can now build and run the application. In the sample application, once the user clicks the "Verify with Samsung Wallet" button, the VWW procedure is initiated. Once the user confirms that they wish to share their information, the application will receive the requested information about the user.
Figure 2: Complete the verification process using VWW
Conclusion
In this article, we have explored how you can integrate the Verify with Wallet RP SDK directly into your application and use it to verify the user's identity. Feel free to integrate the RP SDK in your own application and test the Verify with Samsung Wallet process as well. If you have any further queries regarding this process, feel free to reach out to us through the Samsung Developers Forum.
Related Resources
ISO/IEC 18013-5:2021 - Personal identification — ISO-compliant driving licence — Part 5: Mobile driving licence (mDL) application Mobile Driver License - American Association of Motor Vehicle Administrators - AAMVA RP SDK download link Verify with Wallet API Guidelines Relying Party Card Specifications Sample Code Download Link View the full blog at its source
-
By Samsung Newsroom
Digital identity verification has become a rising topic in the current technological landscape. Samsung Wallet allows Samsung Galaxy device users to securely register their state-issued US driver's license in their device, letting them use it as a mobile driver's license (mDL). Through the "Verify with Wallet" (VWW) functionality, Samsung Wallet provides Android developers with the ability to authenticate a user's identity directly from their application by utilizing the user's registered mDL on the device. The implementation of the functionality is based on and is fully compliant with the ISO 18013-5 standard. In this article, we explore the complete process of implementing Verify with Wallet in an Android application.
Prerequisites
In order to complete the tasks in this article and implement a complete sample application for verifying a user's identity, you need the following:
Valid US driver's license or state ID US region Samsung Galaxy device with mDL support Complete the Samsung Wallet Partner onboarding process Understanding the Verify with Wallet process
Samsung Wallet offers a native Relying Party (RP) SDK for Android applications. RP SDK is an App2App SDK designed for enabling Samsung Wallet's mDL service in online use cases. By integrating this SDK, you can leverage the VWW functionality within their applications.
In your application, you need to create a JSON object for defining the request and a JSON payload for the Relying Party card. Then, you can utilize the RP SDK to create a valid mDoc request using the provided information. Finally, the request needs to be sent to the Samsung Wallet application.
In response, Samsung Wallet sends an encrypted response back to the application, which contains the requested information in a CBOR encoded format. The application can then decode the provided data and use it as necessary. Refer to the ISO 18013-5 standard, AAMVA mDL guidelines and the Samsung Wallet documentation for a better understanding of the VWW process.
Implementing the Verify with Wallet Functionality in Your Android Application
The process of implementing VWW in an Android application includes creating a Relying Party card for Samsung Wallet, downloading and integrating the RP SDK into the Android application and implementing the necessary functions in the Android application for completing the verification process.
Creating a Relying Party Wallet Card Template in the Samsung Wallet Partners Portal
In order to implement and use the VWW functionality, you need a wallet card of the Relying Party type for this purpose.
To create a Relying Party wallet card template:
Go to the Samsung Wallet Partners Portal. Select Wallet Card > Create Wallet Cards. From Wallet Card Templates, select Relying Party. Select the applicable Service Location and Authentication Issuer from the Advanced setting section. Make sure to select the proper values for the card, otherwise the verification process may not work. Figure 1: Creating a Relying Party card for VWW
Integrating the RP SDK in an Android Application
Once the Relying Party card template has been created, we can download and integrate the RP SDK to work with the Android application.
Step 1: Download the RP SDK for Android
To download the RP SDK:
Download the ZIP file containing the latest RP SDK release AAR file from Samsung Wallet Code Resources on the Samsung Developer website. Extract the AAR file from the downloaded ZIP file. Copy and paste the downloaded rp-sdk-x.xx-release.aar file inside a new directory in the Android Studio project (for example, \libs\). Step 2: Add Android Manifest Permissions
To implement the Verify with Wallet functionality, the application needs both the Internet access permission and the ability to query the installed Samsung Wallet application. To provide the application with these permissions, open the AndroidManifest.xml file in the Android Studio project and add the following lines:
<uses-permission android:name="android.permission.INTERNET" /> <queries> <package android:name="com.samsung.android.spay" /> </queries> Step 3: Add Gradle Dependencies
In the application's build.gradle file, load the RP SDK AAR file and the necessary additional dependencies for using the SDK, as follows:
// Load RP SDK AAR file implementation(files("libs/rp-sdk-1.05-release.aar")) //CBOR decoding dependencies implementation("com.upokecenter:cbor:4.0.1") implementation("com.augustcellars.cose:cose-java:1.1.0") // Other dependencies implementation("com.google.code.gson:gson:2.11.0") implementation("org.bouncycastle:bcprov-jdk15to18:1.66") implementation("com.nimbusds:nimbus-jose-jwt:9.37.3") implementation("io.reactivex.rxjava2:rxjava:2.2.21") implementation("io.reactivex.rxjava2:rxkotlin:2.4.0") implementation("io.reactivex.rxjava2:rxandroid:2.1.1") implementation("com.squareup.okhttp3:okhttp:4.11.0") After these steps, the RP SDK is ready for use in your Android application.
Configuring the Android Application for Verify with Wallet
Next, we need to complete the implementation of the Verify with Wallet functionality in your Android application.
Step 1: Build a Card Payload for the Relying Party Card
First, we need to create a request payload for the Relying Party card following the specification.
private fun buildApp2AppPayload(): String { return PAYLOAD .replace("{refId}", UUID.randomUUID().toString()) .replace("{createdAt}", System.currentTimeMillis().toString()) .replace("{updatedAt}", System.currentTimeMillis().toString()) } private val PAYLOAD = """ { "card": { "type": "relyingparty", "data": [ { "createdAt": {createdAt}, "updatedAt": {updatedAt}, "language": "en", "refId": "{refId}", "attributes": { "clientPackageName": "com.ahsan.verifyappsample", "clientType": "app", "fontColor": "#ffffff", "logoImage": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "logoImage.darkUrl": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "logoImage.lightUrl": "https://kr-cdn-gpp.mcsvc.samsung.com/mcp25/resource/2024/9/4/b940b7a2-0f55-42ce-8da7-025d50dbb6b7.png", "providerName": "Samsung Verification Sample" } } ] } } """.trimIndent() Step 2: Build the AppLink
The AppLink is a tokenized URL that is similar to the CData tokens used for Samsung Wallet cards. The Samsung Wallet RP SDK includes a function to generate the AppLink using the payload and the partner credentials (private key, public key, partner ID, card ID, certificate ID, etc.).
To build the AppLink, you can simply call the rpClientApis.buildAppLink() function with the required parameters:
val rpClientApis = RpClientApis(this) val appLink = rpClientApis.buildAppLink( partnerId = PARTNER_ID, cardId = CARD_ID, payload = buildApp2AppPayload(), samsungPublicKey = SAMSUNG_CERTIFICATE, partnerPublicKey = PARTNER_CERTIFICATE, partnerPrivateKey = PARTNER_PRIVATE_KEY, partnerCertificateId = CERTIFICATE_ID, isStagingServer = true ) Step 3: Build the Request Data
Finally, once the AppLink creation is complete, we can send the verification request using the RP SDK.
Before sending the request, we need to specify exactly which information we wish to retrieve. For this purpose, we need to create a JSON document following the ISO 18013-5 specification and specify the fields we wish to retrieve in the response. It is possible to request for the following fields in the request data under the "org.iso.18013.5.1" namespace:
portrait family_name given_name document_number age_in_years resident_address birth_date issue_date expiry_date sex height weight_range weight eye_colour hair_colour organ_donor driving_privileges veteran Additionally, it is also possible to request for the following 3 fields, under the "org.iso.18013.5.1.aamva" namespace:
domestic_driving_privileges DHS_compliance EDL_credential In our example, we only try to retrieve the following 4 fields: family_name, age_in_years, issue_date, and expiry_date. In the following code example, we build the request string accordingly:
val requestData = """ { "docType": "org.iso.18013.5.1.mDL", "nameSpaces": { "org.iso.18013.5.1": { "family_name": true, "age_in_years": true, "issue_date": true, "expiry_date": true } } } """.trimIndent() Step 4: Create the OnResponseListener Class
When using the VWW RP SDK, it is necessary to create a listener class for both sending the request and for receiving and processing the response from the mDoc server.
For our example, let's create an empty placeholder OnResponseListener class which extends the RP SDK's OnResponseListener class.
class OnResponseListener(private val requestData: String) : RpClientApis.OnResponseListener{ override fun onGetMdocRequestData(deviceEngagementBytes: ByteArray): ByteArray? { TODO("Not yet implemented") } override fun onMdocResponse(encryptedResponseBytes: ByteArray) { TODO("Not yet implemented") } override fun onMdocResponseFailed(exception: Exception) { Log.e(TAG, "Response processing failed", exception) } } Initiating the Verification Request
To initiate the identity verification process, we need to establish a secure session and send a structured request to the Samsung Wallet application. We can use the previously created OnResponseListener class for this purpose.
Step 1: Define the onGetMdocRequestData() Function for Sending the Request Data
Inside the onGetMdocRequestData() function, we need to do 2 things for establishing a secure encrypted session:
Generate an elliptic curve key pair Build session establishment bytes following the ISO-18013-5 specification. Once the key pair is generated, we can use this key pair, the device engagement bytes, and the previously created request data for building the encrypted session establishment bytes. The device engagement bytes are provided automatically inside the onGetMdocRequestData() function by the RP client SDK.
private val secureRepository = SecureRepository() override fun onGetMdocRequestData(deviceEngagementBytes: ByteArray): ByteArray? { val keyPair = secureRepository.generateEcKeyPair() val encryptedSessionEstablishmentBytes = secureRepository.buildSessionEstablishment(requestData, deviceEngagementBytes, keyPair) return encryptedSessionEstablishmentBytes!! } For further information regarding generating the key pair and building the session establishment bytes, check the provided sample code.
Step 2: Initiate a Verification Request with the AppLink
Once the onGetMdocRequestData() function is ready, we can use the request() function to initiate the verification request.
val sessionId = UUID.randomUUID().toString() val WALLET_PACKAGE = "com.samsung.android.spay" rpClientApis.request( WALLET_PACKAGE, sessionId, appLink, OnResponseListener(requestData) ) Processing the Request Response
Once the mDoc request has been sent and processed successfully, the application should receive a ByteArray as response in the onMdocResponse() function inside the listener class. This ByteArray is an encrypted JSON object. Once decrypted, the response should look like the following:
{ "documents": [ { "issuerSigned": { "nameSpaces": { "org.iso.18013.5.1": [ "pGhkaWdlc3RJRBkU-mZyYW5kb21UaGNkNGduZDl5Z2I1cTRjaDV4ZnpxZWxlbWVudElkZW50aWZpZXJrZXhwaXJ5X2RhdGVsZWxlbWVudFZhbHVlwHQyMDMxLTExLTIxVDA3OjAwOjAwWg", "pGhkaWdlc3RJRBknbWZyYW5kb21Udjg1NmsydzIzZzQ3OHk5cTQ0aHJxZWxlbWVudElkZW50aWZpZXJsYWdlX2luX3llYXJzbGVsZW1lbnRWYWx1ZRgr", "pGhkaWdlc3RJRBlvWWZyYW5kb21UbnRtdnJ5OXlucXcyZjY2bmp2NXRxZWxlbWVudElkZW50aWZpZXJqaXNzdWVfZGF0ZWxlbGVtZW50VmFsdWXAdDIwMjMtMTEtMDhUMDc6MDA6MDBa", "pGhkaWdlc3RJRBnXQWZyYW5kb21UOXJqd2NydjZ6cXpqZm1xajNkcnhxZWxlbWVudElkZW50aWZpZXJrZmFtaWx5X25hbWVsZWxlbWVudFZhbHVlZUFoc2Fu" ] }, "issuerAuth": [ "dCBa", { "33": "..." }, "...", "..." ] }, "deviceSigned": {…}, "docType": "org.iso.18013.5.1.mDL" } ], "version": "1.0", "status": 0 } The values inside the org.iso.18013.5.1 JSON Array are the information we requested, in the CBOR (Concise Binary Object Representation) format.
For example, if we decode the value: "pGhkaWdlc3RJRBlvWWZyYW5kb21UbnRtdnJ5OXlucXcyZjY2bmp2NXRxZWxlbWVudElkZW50aWZpZXJqaXNzdWVfZGF0ZWxlbGVtZW50VmFsdWXAdDIwMjMtMTEtMDhUMDc6MDA6MDBa", we find that this CBOR object contains the issue_date field and its value is 2023-11-08T07:00:00.000Z. Similarly, every value provided in the array is a CBOR object that can be decoded using CBOR decoders to find a key-value pair containing the requested information.
We can now receive the mDoc response in the onMdocResponse() function and decode it to retrieve the final requested values:
override fun onMdocResponse(encryptedResponseBytes: ByteArray) { val plainResponse = secureRepository.decryptMdocResponse(encryptedResponseBytes) Log.i(TAG, "plainResponse=${plainResponse?.toPrettyJson()}") val mDocContent = Mdoc18013Utils.parseMdocResponse(plainResponse!!) mDocContent.forEach { (key, value) -> Log.i(TAG, "$key: $value") } } Here, secureRepository.decryptMdocResponse() performs the decryption operation and converts the encrypted bytes into a plain JSON response. Afterwards, the Mdoc18013Utils.parseMdocResponse() function takes the plain response and decodes each CBOR-encoded element contained in the org.iso.18013.5.1 array and returns these values in a simplified dictionary of key-value pairs. If you wish to learn more about these functions, you can check out the provided sample code.
With this step, the sample application's implementation of Verify with Wallet is complete. You can now build and run the application. In the sample application, once the user clicks the "Verify with Samsung Wallet" button, the VWW procedure is initiated. Once the user confirms that they wish to share their information, the application will receive the requested information about the user.
Figure 2: Complete the verification process using VWW
Conclusion
In this article, we have explored how you can integrate the Verify with Wallet RP SDK directly into your application and use it to verify the user's identity. Feel free to integrate the RP SDK in your own application and test the Verify with Samsung Wallet process as well. If you have any further queries regarding this process, feel free to reach out to us through the Samsung Developers Forum.
Related Resources
ISO/IEC 18013-5:2021 - Personal identification — ISO-compliant driving licence — Part 5: Mobile driving licence (mDL) application Mobile Driver License - American Association of Motor Vehicle Administrators - AAMVA RP SDK download link Verify with Wallet API Guidelines Relying Party Card Specifications Sample Code Download Link View the full blog at its source
-
-
By Samsung Newsroom
Samsung Electronics is delivering a more responsive and refined screen experience with the Smart Monitor M9 (M90SF model), the first OLED display in Samsung’s Smart Monitor (M series) lineup.
The Smart Monitor M9 brings together the brilliance of a 4K OLED display with built-in Smart TV Apps, AI-powered features and Samsung Gaming Hub to achieve a seamless experience no matter what’s on screen — no PC required.
Since its release, the device has earned praise from industry experts for its stunning picture quality, intelligent features and gaming-ready performance.
Below is a summary of what leading tech outlets are saying about the Smart Monitor M9 (listed in alphabetical order):
HomeTheaterReview Techaeris Tom’s Guide
Next-Level Picture Quality Backed by QD-OLED Brilliance
Highlighting the high-end features and performance improvements of the M9, one of Samsung’s best OLED 4K models in its class, Tom’s Guide wrote, “The new M9 offers a significant upgrade over its predecessor thanks to its 32-inch 4K QD-OLED panel, which dramatically enhances contrast and color for an improved movie-watching experience.”
The Smart Monitor M9 delivers true-to-life visuals powered by QD-OLED technology, producing rich colors and deep inky blacks — complemented by sharp 4K resolution. With support for VESA DisplayHDR True Black 400, content appears with greater depth and contrast, even in dark scenes.
“The Smart Monitor M9 features Samsung Vision AI, providing advanced upscaling and picture optimisation features,” added Tom’s Guide. “During my time with the M9, I came to the conclusion that it’s a huge leap forward from its predecessor, offering more than enough advancements to justify a price increase.”
Techaeris rated the M9 a 9.7 out of 10, calling its QD-OLED panel “one of the best you’re going to find on any monitor,” and noting the display “looks spectacular” with colors that “pop” and brightness that “doesn’t wash out the colors.”
To help reduce the risk of burn-in and maintain screen integrity over time, Samsung OLED Safeguard+ features advanced technologies like adaptive brightness controls and a proprietary cooling system with a Pulsating Heat Pipe.
Game in High Gear With Pro-Level Specs
“With a brilliant 4K QD-OLED display, 165Hz refresh rate, Smart TV apps, Gaming Hub, and more, this is a do-it-all monitor and TV, perfect for work and play,” wrote Techaeris.
The Smart Monitor M9 is engineered for smooth, fast-paced gaming, featuring a near-instant 0.03ms GTG response time and support for both NVIDIA G-SYNC Compatible and AMD FreeSync Premium Pro.
HomeTheaterReview described the M9 as “one of the most impressive displays money can buy,” pointing to a responsive performance and “color accuracy that creative professionals will drool over.”
Whether jumping into cloud-based titles via Samsung Gaming Hub or connecting to a console or PC, the M9 delivers the speed and clarity needed for an immersive gaming experience. The same reviewer noted they use the M9 just as often without a PC as with one, describing it as “the kind of paradigm shift that makes this monitor truly special.”
A Smarter Screen and a Smarter Experience: AI That Adapts to You
“Imagine a monitor so capable, you might forget to connect a computer,” wrote HomeTheaterReview, which awarded the M9 five stars and an “Editors’ Choice” distinction.
The M9 is a smart entertainment hub that provides built-in access to popular streaming apps like Netflix and YouTube, Samsung TV Plus and Samsung Gaming Hub, enabling cloud-based gaming and content streaming, all without a PC.
Powered by the NQM AI Gen3 Processor, the M9 optimizes both picture and audio for a more immersive viewing experience. Intelligent features like 4K AI Upscaling Pro, AI Picture Optimizer and Active Voice Amplifier (AVA) Pro automatically adapt to content and the display’s surroundings to consistently provide reliable, high-quality entertainment.
Whether used for content viewing, cloud gaming, or everyday tasks, it delivers the flexibility of a monitor and the functionality of a smart TV. Techaeris calls the M9 “an outstanding monitor” and adds, “for those who only want to spend once, this is a solid choice.”
The M9 also features a 90W-charging USB-C, one HDMI 2.1, one DisplayPort 1.4, and eARC ports, supporting a variety of gaming and entertainment input needs. The slim metal stand, which offers tilt and height adjustment, “deserves special mention,” according to HomeTheaterReview, for its balance of form and function in a modern flat-back design.
The Smart Monitor M9 was named a CES 2025 Innovation Awards Honoree, receiving the recognition for its advancements in display performance and intelligent features.
Techaeris named the M9 a Top Pick of 2025, citing its versatility across work, play and everything in between. That recognition joins a growing list of accolades across Samsung’s next-generation display portfolio, including a 2025 Techaeris Innovation Award for the Odyssey 3D G90XF — celebrated for its “mind-blowing” 3D experience and praised as the “real deal” for those seeking a 3D monitor without glasses.
For more information on the Samsung Smart Monitor M9, visit samsung.com.
View the full article
-
-
-
Similar Tagged Content
-
- 0 replies
- 2,038 views
-
- 0 replies
- 2,722 views
-
- 1 reply
- 4,031 views
-
- 7 replies
- 22,491 views
-
- 0 replies
- 2,253 views
-
Recommended Posts
Join the conversation
You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.