-
Similar Topics
-
By Parth
Hello Samsung / Tizen Technical Support Team,
We are observing a playback issue on Samsung Tizen TVs when streaming DRM-protected content that uses a multi-key DRM configuration. We would like to report the issue and request assistance in investigating the behavior on Samsung devices.
DRM Provider: Castlabs
DRM Type: Widevine
Streaming Format: MPEG-DASH (MPD)
Player Environment: Samsung Tizen Application using the Samsung AVPlay / native playback stack.
Content DRM Configuration:
Our content is packaged with a multi-key DRM setup, where different resolution groups use different encryption keys:
Key 1: 360p, 480p, 720p
Key 2: 1080p, 4K
Observed Issue:
Playback starts normally and the video plays correctly at the initial resolution. However, when the adaptive bitrate algorithm triggers a resolution change that requires switching DRM keys, playback fails.
Specifically, the issue occurs in the following scenarios:
When switching from 720p → 1080p or higher
When switching from 1080p → 720p or lower In both cases, the switch requires a DRM key change, and the playback fails shortly after the transition.
Additional Observations:
If we modify the MPD to limit playback to only one key group (for example, only up to 720p or only 1080p and above), playback works correctly without any interruption.
The issue appears only when the player needs to switch between representations encrypted with different keys.
Playback works correctly on other platforms using the same MPD and DRM configuration.
The issue appears specific to Samsung Tizen playback behavior during multi-key DRM key transitions. Device Details (Example Device Where Issue Was Observed):
Model Code: UA32T4380AKXXL Software Version: T-KTS2UABC-2700.6 Platform: Samsung Tizen TV Error Behavior:
Video plays normally for some time and then fails after a resolution change requiring key switch. In some cases playback stops after ~20–30 seconds when adaptive bitrate switching occurs. Request:
Could you please confirm:
Whether multi-key DRM streams with adaptive bitrate switching across keys are fully supported on Samsung Tizen TVs.
If there are specific packaging or DRM license configuration requirements for multi-key playback.
Whether there are known limitations in AVPlay or Tizen DRM handling related to key switching during DASH adaptive playback. We would appreciate any guidance or debugging steps that could help identify the root cause of this issue.
Device Details:
Test Labs Device: Korea (Suwon-TV), NEO QLED 4K, QN55QN80F(2025), Tizen 9.0, QN55QN80FAFXZA
Actual TV: UA32T4380AKXXL (Model Number)
-
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
The Samsung Pay SDK offers developers the ability to seamlessly incorporate mobile and online payment solutions and push provisioning capabilities into their applications, enhancing functionality and user experience. For Samsung Pay partners, mastering the development lifecycle and proactively addressing potential challenges are essential best practices for ensuring a smooth and successful integration. By adopting these strategies, developers can enhance the reliability of their implementations and minimize disruptions, ultimately delivering a superior user experience. This guide outlines the partnership process, best practices for development, testing strategies, and release process to ensure a smooth integration experience.
Setting Up Your Partnership
To begin integrating the Samsung Pay SDK, follow these steps:
Create a Samsung Account: Use your company email to register your Samsung Account. Personal emails may lead to rejection.
Register in the Partner Portal: To prevent rejection of your partnership request, ensure the following mandatory company details are provided accurately:
Business account name Company name Company legal structure Company country Number of employees Company address Company phone number Company introduction Company Data Universal Numbering System (DUNS) number Company website URL Collaborator access: Your colleagues can also sign up to be a member of your Business Account using either the business account name or the manager's email address to collaborate on your projects.
Review process: A Relationship Manager (RM) will review your application within 2-3 business days. If no response is received, contact Samsung Developer Support with your company name, country, and Samsung account details. While awaiting for approval, you can explore the Samsung Pay SDK Programming Guide.
Once your partnership request has been approved, you're ready to configure your project by creating a new service and registering your application.
You can find more details of the service creation process in the Samsung Pay documentation.
Key Considerations and Troubleshooting in the Development Phase
Follow the development guide, sample applications and code labs while integrating the Samsung Pay SDK. To avoid common pitfalls during implementation, make sure the following preparations have been implemented:
Verify the manifest configuration: Verify the inclusion of necessary queries.
<queries> <package android:name="com.samsung.android.spay" /> </queries> Apply optimizer rules: Make sure you have applied the correct ProGuard or DexGuard rules to prevent runtime errors.
ProGuard rules:
dontwarn com.samsung.android.sdk.samsungpay.** -keep class com.samsung.android.sdk.** { *; } -keep interface com.samsung.android.sdk.** { *; } DexGuard rules:
-keepresourcexmlelements manifest/application/meta-data@name=spay_sdk_api_level For banks and financial institutions, verify the issuer name for push provisioning: Confirm the issuer name matches your setup. If you are getting an empty list from the getAllCard() method, check that the issuer name on the Samsung Pay Portal matches the issuer name of the card. You can ensure the correct issuer name is used by adding the card to the Samsung Wallet application and retrieve the information from it:
Open the Samsung Wallet. Tap on the card. Tap on the three-dot menu. Select the Customer services option. The issuer name can be found under the title.
Figure 1: Retrieving the issuer name from the Samsung Wallet application
For merchants/payment gateways supporting Samsung Pay online payment, check the Service ID and Package Name configuration: Ensure alignment with Partner Portal configuration. Detailed information about the configuration can be found in the partner onboarding guide.
Check the allow list configuration: Ensure you have added the Samsung test accounts in the allow list. Follow these steps to add the test accounts to your service:
Log into the Partner Portal. Go to My projects > Service management. Click on your SERVICE NAME > ADD SAMSUNG ACCOUNT on the Service details page.
Figure 2:Adding test accounts to the allow list
Check the service expiration date: Make sure that your service ID is currently valid. To generate or extend the validity date of the service:
Go to My projects > Service management. Select the SERVICE NAME to open the Service details page. Click GENERATE NEW DATE. Provide Samsung Accounts for testing the application. These accounts are placed on the allow list for testing. Click Generate. The new expiration date of your service appears on the page. Remember to extend the date after 90 days if you continue testing your application past that point.
Figure 3: Generating the service expiration date
For merchants supporting Samsung Pay online payment, provide a valid CSR: For in-app payment services, you must upload a valid Certificate Signing Request (CSR) in the Partner Portal. This CSR is provided to you by your payment gateway (PG). If issues persist
Check the FAQ: Samsung Pay guide has an extensive list of common error codes and solutions for common issues. Check this FAQ to help you resolve your issue: Samsung Pay FAQ
Submit a support ticket: You can reach out to the Samsung Engineers directly by creating a support ticket from Samsung Developer Support. Include detailed issue descriptions, affected APIs, expected vs. actual responses from the API, and attach dumpstate logs. To capture dumpstate logs, follow the below steps:
Dial *#9900# > Set Debug Level to Mid > Restart the device. Reproduce the issue and re-enter *#9900# > Run dumpstate/logcat > Save logs to SD card. Package the logs in a zip file and submit them. NoteLogs expire after 15 minutes. Testing with the Samsung Wallet Application
The service status flow for Samsung Pay SDK begins with the Debugging stage, where the service is still under internal testing and can only be accessed by authorized Samsung Accounts in the allow list. Once testing is complete, the partner submits the service along with the release version of the APK for approval, transitioning it to the Pending state. At this stage, the service still remains accessible only to the authorized Samsung Accounts while awaiting review. The Relationship Manager (RM) then evaluates the submission. If the service meets all requirements, it is marked as Approved and becomes eligible for public use. However, if the service fails to meet the necessary standards, it is Rejected, indicating that further improvements are needed before resubmission.
Samsung offers both production and staging environments to test your application with the Samsung Pay Partner Portal. For testing using the staging environment, you need the service ID from the Partner Portal, the staging version of the Samsung Wallet application, and test cards. You can find the staging version of the Samsung Wallet application from the Partner Portal by navigating to Support > Request Test App then clicking GALAXY APP URL to copy the test application link. Make sure that you have registered your test accounts to use the Samsung Pay STG application. You can access the test cards for the staging environment at Test Cards on Samsung Pay.
Release Your Application
The release process of your application can begin as soon as you upload a release version of your application. After that, keep an eye on the status of the release version under App details on your portal dashboard.
To begin the release process, upload a new release version of your application:
Go to My projects > App management. Click on the application name to open its details, then click ADD NEW RELEASE VERSION.
You can also click the ADD NEW VERSION button corresponding to the application from the App management dashboard. Drag and drop your APK file in the field provided or click the paperclip icon to browse for it. Drag and drop up to three screenshots demonstrating your application's compliance with Samsung Pay's branding guidelines. Click Register. When the service status is approved, you're ready to publish the application.
Summary
Integrating the Samsung Pay SDK streamlines mobile payment solutions, offering partners a robust and scalable platform. By adhering to the onboarding guidelines, addressing development challenges proactively, and rigorously testing in both environments, you can ensure a successful deployment. Samsung’s dedicated support team and resources are readily available to assist at every stage. Leverage them to optimize your integration journey. Visit the Samsung Pay Developer Portal for official documentation and additional resources.
View the full blog at its source
-
By Samsung Newsroom
If you are looking for a visual approach to designing watch faces, Watch Face Studio is a great option. It offers an easy-to-use interface and doesn’t require any coding skills.
However, if you want to have more control, Watch Face Format is the way to go. It lets you define your watch face using XML. The declarative structure is designed specifically for Wear OS, giving you precise control over appearance and behavior. Watch faces built this way are easier to maintain and require fewer updates than those using the older Jetpack Watch Face libraries, since the platform handles key rendering and performance improvements automatically. This blog shows how to convert a Wear OS application project to a watch face that uses Watch Face Format in Android Studio.
Let’s walk through a simple project. You start by setting up the environment. Next, you set up the project and build the watch face using Watch Face Format. Then, you move on to customizing the watch face, defining its appearance, layout and components using the declarative structure.
Once the design is complete, you validate the memory footprint to ensure it stays within platform limits and check the XML structure to catch any potential issues.
PrerequisiteDownload the latest version of Android Studio on your computer. Project Setup
Create a new Empty Wear App. Go to File -> New -> New Project -> Wear OS -> No Activity from Android Studio. Make Sure Minimum SDK is 34 or higher since Watch Face Format version 2 is used. In Android Studio, switch the file structure to Project view by selecting Project from the dropdown menu at the top of the Project Tool Window. Figure 1: Project view
Go to the AndroidManifest.xml file, remove the existing attributes from the <application> tag and add the following attributes: android:label="@string/app_name" android:hasCode="false" tools:ignore="MissingApplicationIcon" Click on app_name and press Shift+F6 to refactor it. Give it a more appropriate name, such as watch_face_name. android:label="@string/watch_face_name" Add the following attribute to the <manifest> tag because the tools attribute is being used in the <application> tag: xmlns:tools="http://schemas.android.com/tools" Inside the <application> tag, add the <property> and <meta-data> tags shown below. The <property> tag here specifies the Watch Face Format version: <property android:name="com.google.wear.watchface.format.version" android:value="2" /> <meta-data android:name="com.google.android.wearable.standalone" android:value="true" /> Optionally, you can add the following <property> tag to identify the publisher: <property android:name="com.google.wear.watchface.format.publisher" android:value="publisher_name" /> Your AndroidManifest.xml should now look like this: Figure 2: AndroidManifest.xml file
Right click on the res directory and add directories named xml, drawable, font and raw. Download the fonts and images used in the sample project. Sample fonts and images (122 MB)
Add the downloaded preview and background images in the directory app\src\main\res\drawable. Figure 3: background and preview image path
NoteThe preview image shows in the watch face catalog until it's added to favorites. It's best to use an image that closely matches the actual watch face. Go to the directory app\src\main\res\xml and add a new file named watch_face_info.xml. Figure 4: watch_face_info.xml file path
Add the <WatchFaceInfo> tag to the empty file: <WatchFaceInfo> <Preview value="@drawable/preview" /> <MultipleInstancesAllowed value="false" /> <Editable value="false" /> </WatchFaceInfo> If you set MultipleInstancesAllowed to true, the watch face allows multiple instances on favorites with different styles for more personalized use. If the watch face supports style customization, set Editable to true. Since the sample project is not customizable, the value should be false.
Place the downloaded font files in the app\src\main\res\font directory. Figure 5: Fonts path
Optionally, you may remove the directories listed below since we do not need any application icon and the java folder is empty:
app\src\main\java app\src\main\res\mipmap-hdpi app\src\main\res\mipmap-mdpi app\src\main\res\mipmap-xhdpi app\src\main\res\mipmap-xxhdpi app\src\main\res\mipmap-xxxhdpi Go to the app\src\main\res\raw directory and add a new file named watchface.xml. This XML file contains the layout for the watch face. Figure 6: watchface.xml file path
Add the following <WatchFace> tag in the newly created file: <WatchFace width="450" height="450" clipShape="CIRCLE"> <Metadata key="CLOCK_TYPE" value="DIGITAL"/> <Scene backgroundColor="#ff000000"> <!-- Content to be rendered --> </Scene> </WatchFace> Open the application level build.gradle file. From the plugins block, remove the following: alias(libs.plugins.kotlin.android) From the android block, remove the compileOptions and kotlinOptions blocks because we are not using Java/Kotlin. From the root, remove the dependencies block since the watch face does not require any AndroidX Components or external libraries. Inside the buildTypes block, add this debug block and replace the release block with the following one: debug { isMinifyEnabled = true } release { // TODO:Add your signingConfig here to build release build isMinifyEnabled = true // Ensure shrink resources is false, to avoid potential for them // being removed. isShrinkResources = false signingConfig = signingConfigs.getByName("debug") } Your application level build.gradle file should now look like this:
Figure 7: Application level build.gradle file
Now open the project level build.gradle file. From the plugins block, remove the following and sync the project. alias(libs.plugins.kotlin.android) apply false Now the project is set up.
Building the Watch Face
First, add a background image inside the <Scene> tag in the watchface.xml file. The background image is not visible in Ambient mode: <PartImage x="0" y="0" width="450" height="450" name="Background" alpha="255"> <Variant mode="AMBIENT" target="alpha" value="0"/> <Image resource="background"/> </PartImage> Add a <DigitalClock> tag below the <PartImage> tag: <DigitalClock x="36" y="173" width="377" height="85" alpha="255"> <TimeText x="0" y="0" width="377" height="85" format="hh:mm:ss" hourFormat="SYNC_TO_DEVICE" align="CENTER" alpha="255"> <Variant target="alpha" value="0" mode="AMBIENT"/> <Font family="fredoka_semibold" size="100" weight="NORMAL" slant="NORMAL" color="#ff4e4b8f"/> </TimeText> <TimeText x="0" y="0" width="377" height="85" format="hh:mm" hourFormat="SYNC_TO_DEVICE" align="CENTER" alpha="0"> <Variant target="alpha" value="255" mode="AMBIENT"/> <Font family="fredoka_semibold" size="100" weight="NORMAL" slant="NORMAL" color="#ff4e4b8f"/> </TimeText> </DigitalClock> Two <TimeText> tags are used. One shows the full time with seconds in Active mode, and the other shows only hours and minutes in Ambient mode. This helps save battery life when the watch is in Ambient mode.
Add a <Text> tag to show the Date using Tag Expressions: <PartText x="48" y="264" width="355" height="35" name="Date" alpha="255"> <Text align="CENTER" ellipsis="FALSE"> <Font family="fredoka_medium" size="35" weight="NORMAL" slant="NORMAL" color="#ff4e4b8f"> <Template>%s, %s %s <Parameter expression="[DAY_OF_WEEK_S]"/> <Parameter expression="[MONTH_S]"/> <Parameter expression="[DAY]"/> </Template> </Font> </Text> </PartText> Here is how the date format is defined: %s, %s %s is the structure (for example, “Mon, Jun 25”) [DAY_OF_WEEK_S] -> abbreviated day (for example, "Mon") [MONTH_S] -> abbreviated month (for example, "Jun") [DAY] -> numeric day (for example, "25") Set up Device and Terminal
If you are not using an emulator, make sure your watch is connected to your computer using Wireless Debugging. For full setup instructions, refer to this blog.
To run the adb command directly from your terminal without navigating to its directory each time, do the following:
On Windows:
Add the path to your adb.exe file to your system’s PATH environment variable. By default, this path is usually:
C:\Users\<your_username>\AppData\Local\Android\Sdk\platform-tools Execute the following command (replace <adb_path> with the actual path):
setx PATH "%PATH%;<adb_path>" NoteIf your adb.exe is located elsewhere, make sure to add that specific path instead. On macOS (zsh):
Open your .zshrc file:
nano ~/.zshrc Add the following path in the file:
export PATH="$PATH:$HOME/Library/Android/sdk/platform-tools" Save the file and restart the terminal.
Run the Project
To generate and install a debug build APK, open the Terminal tool window and run the following command: gradlew installRelease NoteTo prepare your APK for distribution, make sure to build a signed release version of your application. Unsigned or debug builds are not suitable for publishing. To set the watch face directly from the command line, you can execute the following command: adb shell am broadcast -a com.google.android.wearable.app.DEBUG_SURFACE --es operation set-watchface --es watchFaceId <your_package_name > To find the package name, look for applicationId in your application level build.gradle file.
Alternatively, you can apply the watch face from the watch or phone manually.
Memory Footprint and XML Validator
Watch Face Format has memory constraints depending on the mode. In ambient mode, you are limited to 10 MB of memory. In interactive mode, the memory limit is set at 100 MB. For more details, check out the Wear OS app quality guidelines.
In the root directory, create a new directory named libs. Download memory-footprint.jar and wff-validator.jar from here and put them in the libs directory. Generate the app-debug.apk file before executing the next command. To evaluate the memory footprint, execute the following command in the terminal: java -jar libs\memory-footprint.jar --watch-face app\build\outputs\apk\debug\app-debug.apk --ambient-limit-mb 10 --active-limit-mb 100 Here you have set the ambient and active memory limit for the watch face and tested against it.
To know more about each option, you can execute the following command:
java -jar libs\memory-footprint.jar --help When the memory footprint test has been passed, you see a message like this: Figure 8: Memory Footprint result
To validate the watchface.xml file, execute the following command: java -jar libs\wff-validator.jar 2 app\src\main\res\raw\watchface.xml This command validates the watchface.xml file against Watch Face Format version 2.
If the watchface.xml file is valid, you see a message like this: Figure 9: WFF validation result
Sample Project for Test
You can download the sample project using the link below to test it out on your device.
WFF_Sample_Project.zip (22.9 MB) Here is a preview of the project you have just created:
Figure 10: Watch Face Preview on a Galaxy Watch
Conclusion
If you are someone who prefers hands-on control and customization, the Watch Face Format is a solid choice to create a watch face. It is ideal for developers who enjoy building things manually and want to fine-tune their watch face experience from the ground up. For a more user-friendly option, you might want to explore Watch Face Studio.
If you have questions or need help with the information presented in this blog, you can share your queries on the Samsung Developers Forum. You can also contact us directly through the Samsung Developer Support Portal.
View the full blog at its source
-
-
By Daniel
I’m still dealing with persistent UI lag and bugs on my Samsung S95B, and I’m surprised this issue continues even this year with brand new firmware 1661 and resets.
Symptoms:
Menu interface is slow and laggy, especially in Settings and Home screen.
Scrolling causes stutters or jumps/skips lines in some menus.
Delays when switching inputs, opening apps, or using Smart Hub.
UI gradually becomes less responsive the longer the TV stays on.
What I’ve tried (none of these solved it):
Updated to firmware
Multiple cold boots (hold power button until restart)
Smart Hub reset
Disabled TV Plus, Autorun content, ad services, autoplay previews, etc.
Clean install with only core apps
Factory reset → works for a few days then problem returns
Disconect internet
Only “solution” that works (but temporarily):
Using “Device Care > Memory Cleanup”
It improves UI performance significantly...
BUT only for couple hours
After that, lag and line skipping come back just like before.
So far, this is the only reliable way to temporarily fix the sluggish interface.
Likely cause (based on community feedback):
Tizen OS memory mismanagement (leaks, poor RAM recycling, app bloat)
Possibly related to ad-driven Smart Hub tiles or unoptimized background services
UI lag happens even with no streaming apps open and minimal setup
What I’m asking the community:
Has anyone found a real permanent fix????
Any way to disable Smart Hub completely or force a minimal launcher?
Anyone rollback to a more stable firmware (e.g. 1304, 1430) and fixed this?
Did anyone get Samsung to acknowledge or repair it under warranty?
It’s frustrating to have a flagship OLED 2500$ USD with incredible picture quality, but an TIZEN OS that feels like it’s choking on basic tasks. Hoping for any solutions beyond daily memory cleaning.
On my opinion this is a bad memory using that cause this. Memory because saturated over time.
In all case, Tizen team should redo their homework ASAP.
-
-
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.