Report

Watch Face Studio (WFS) allows designers to create custom watch faces for Galaxy Watches running Wear OS powered by Samsung with powerful visual and interactive features. One of the newest additions to the software is the Photo slot feature, which lets users personalize watch faces by adding images from their phones through the companion app (Galaxy wearable), making designs more dynamic and customizable.
This blog demonstrates how designers can implement the Photo slot feature in a watch face project and allow users to customize backgrounds directly from their phones. The blog covers:
• Adding a background image using a Photo slot
• Setting the Photo slot properties
• Customizing the Photo slot using the companion app
The sample project includes some images that requires the use of the Photo slot feature.
Adding a background image using Photo slot
To begin, create a new watch face project in WFS. Instead of adding a Preset image, use the Photo slot component.
The Photo slot component allows adding only one image to the project. However, after deploying the watch face on a real device, the Photo slot enables the inclusion of multiple images within it.
NoteThe Photo slot feature allows only one slot per project, and adding another turns off the feature in the components. In the sample project, different times of the day are used to display the background image. This ensures that the watch face has a ready-to-use appearance when it first loads.
Additional background images are provided with the sample project file, such as:
● Noon
● Evening
● Night
In this project, the Morning theme is already added within the watch face design. The other themes are demonstrated later through customization using the companion app.
Setting Photo slot properties
The Photo slot component has two options in the "WHEN TO CHANGE PHOTO" section of the properties:
• When watch face is tapped (the default value)
• When watch wakes
In this project, the When watch face is tapped option is selected. This option allows the user to quickly and interactively change the watch face background by tapping the watch screen to cycle through the available images in the slot.
The Photo slot also includes another property called When watch wakes. When enabled, the background automatically changes whenever the watch screen turns on.
Deploying the watch face
After configuring the Photo slot and watch face elements, the project can be deployed to a real Galaxy Watch.
For guidance on deploying the watch face to a real device, refer to Connecting Galaxy Watch to Watch Face Studio over Wi-Fi.
Customizing the Photo slot
One of the main advantages of the Photo slot feature is that it allows end users to customize the watch face with their own photos.
Once the watch face has been deployed, the user can then customize it with their own background images by following the steps below:
Open the companion app on the connected phone. Tap the Customize button. Click on the ‘+’ sign to add images. NoteThree sample images are included with the sample project. To use these images, download and store them with your phone's photos. The process opens the phone's photos and provides options to select images. After images have been added, they are displayed on this screen, along with an option to delete them. The first added image is automatically set as the background image.
Testing on a real device ensures that the Photo slot interaction behaves correctly and the tap-based background switching works smoothly.
Conclusion
The Photo slot feature in Watch Face Studio introduces a powerful way to create customizable watch faces. By combining the built-in background image with user-selected images through the companion app, designers can deliver watch faces that are both visually appealing and highly customizable.
If you have questions or need help with the information presented in this article, you can share your queries on the Samsung Developers Forum. You can also contact us directly for more specialized support through the Samsung Developer Support Portal.
View the full blog at its source

Health and fitness are the most popular features for Galaxy Watches running Wear OS powered by Samsung. Implementing these features requires a continuous data stream to work effectively and seamlessly.
One of the most common challenges third-party developers face is keeping a sensor like the heart rate monitor active, even when the watch screen is off.
By default, Wear OS efficiently optimizes power consumption to extend usage time. As part of this optimization, sensor data collection may stop when the screen is off. This presents a challenge for applications that require continuous monitoring, such as health trackers, workout assistants, or medical-grade wearables.
What Happens When the Screen Turns Off
When a Galaxy Watch screen turns off, the system enters a low-power state to preserve battery. During this time:
The CPU may slow down or suspend execution of background threads. Registered sensor listeners can stop receiving updates. Any active work in your Activity pauses. To keep sensor data flowing, your application needs two things:
A foreground service to keep your code running in the background. A wake lock to prevent the CPU from going into a deep sleep state. This tutorial shows how to create a simple Galaxy Watch application that continuously collects heart rate data, even when the screen is off, using a foreground service and a wake lock and all the code examples are provided in a downloadable sample application.
Let's Start Coding
Step 1: Create a New Wear OS Project
Open Android Studio and create new project from scratch:
Go to File > New > New Project > Wear OS Tab > Empty Wear App. Fill in the project details in the New Project window.
Figure 1: Create a new wearable application in Android Studio



Click Finish and wait for Gradle sync to complete. Step 2: Configure Permissions in AndroidManifest.xml
In the AndroidManifest.xml file, add the following permissions to access the heart rate sensor, foreground service, and wake lock.
<uses-permission android:name="android.permission.BODY_SENSORS" /> <uses-permission android:name="android.permission.FOREGROUND_SERVICE" /> <uses-permission android:name="android.permission.FOREGROUND_SERVICE_HEALTH" /> <uses-permission android:name="android.permission.WAKE_LOCK" /> <uses-permission android:name=" android.permission.BODY_SENSORS_BACKGROUND " /> <uses-feature android:name="android.hardware.type.watch" /> NoteThe BODY_SENSORS_BACKGROUND permission is required on Android 12 (API 31) and above for collecting sensor data when the application is not in the foreground. Register the SensorService in the manifest:
<service android:name=".SensorService" android:enabled="true" android:exported="false" android:foregroundServiceType="health" /> NoteIf you forget foregroundServiceType="health" in the manifest, your application will crash with a SecurityException on Android 10 (API 29) and above when trying to read sensors from a foreground service. Step 3: Design Your Watch UI Layout
The watch UI can be designed entirely according to your preference. In this content, only two buttons have been used to start and stop the service and a TextView to show the result to keep it simple. Wear OS screens are small, so keeping the layout simple is the best practice.
To implement the UI, edit app/res/layout/activity_main.xml.
The following code implements a sample UI:
<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:padding="16dp" tools:context=".MainActivity" tools:deviceIds="wear"> <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent" android:gravity="center" android:orientation="vertical"> <TextView android:id="@+id/heart_rate_text" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="--" android:textColor="#90EE90" android:textSize="24sp" android:layout_marginBottom="16dp"/> <Button android:id="@+id/start_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/start_sensors" /> <Button android:id="@+id/stop_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="8dp" android:text="@string/stop_sensors" /> </LinearLayout> </androidx.constraintlayout.widget.ConstraintLayout> Step 4: Edit MainActivity.java
Inside MainActivity.java, sensor permissions must be requested at runtime.


onCreate() :
You need to initialize all the UI components inside the onCreate() method. This example uses two Button instances, for starting and stopping the service, and one TextView , for showing the result. Before staring the service, you have to check all the runtime permissions.
heartRateTextView = findViewById(R.id.heart_rate_text); //initialize globally to use it outside of the method Button startButton = findViewById(R.id.start_button); Button stopButton = findViewById(R.id.stop_button); if (startButton != null) { startButton.setOnClickListener(v -> { if (checkPermissions()) { if (checkBackgroundPermission()) { startSensorService(); } else { requestBackgroundPermission(); } } else { requestPermissions(); } }); } if (stopButton != null) { stopButton.setOnClickListener(v -> stopSensorService()); } In this application, when the user taps the start button, the application checks both permissions in sequence, and the stop button stops the service.
NoteOn Android 11 (API 30) and above, BODY_SENSORS_BACKGROUND must be requested as a separate step after foreground sensor permission is granted. The system does not grant this permission automatically.
checkPermissions() :
This method checks at runtime whether the BODY_SENSORS permission has been granted. On Galaxy Watch, the user must explicitly grant this permission on their device.
private boolean checkPermissions() { return ContextCompat.checkSelfPermission(this, Manifest.permission.BODY_SENSORS) == PackageManager.PERMISSION_GRANTED; }
checkBackgroundPermission() :
This method checks for the BODY_SENSORS_BACKGROUND permission, which is essential for Wear OS 3+ devices (like Galaxy Watch 5, 6, 7) to access sensor data in all power states.
private boolean checkBackgroundPermission() { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { return ContextCompat.checkSelfPermission(this, Manifest.permission.BODY_SENSORS_BACKGROUND) == PackageManager.PERMISSION_GRANTED; } return true; }
startForegroundService() :
On Android 8 (Oreo) and above, you must call this method instead of startService() when starting a foreground service.
private void startSensorService() { Intent intent = new Intent(this, SensorService.class); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { startForegroundService(intent); } else { startService(intent); } Toast.makeText(this, "Sensor Service Started", Toast.LENGTH_SHORT).show(); }
stopSensorService() :
Once the task is completed, call this method to reduce battery drain.
private void stopSensorService() { Intent intent = new Intent(this, SensorService.class); stopService(intent); if (heartRateTextView != null) { heartRateTextView.setText("--"); } Toast.makeText(this, "Sensor Service Stopped", Toast.LENGTH_SHORT).show();
requestPermissions() :
This method prompts the user for the BODY_SENSORS permission before starting the service.
private void requestPermissions() { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.BODY_SENSORS}, PERMISSION_REQUEST_CODE); }
requestBackgroundPermission() :
This method prompts the user for the BODY_SENSORS_BACKGROUND permission. Since the sample application targets Android 13 (API level 33) or higher (currently set to 34), this permission is required if you want to access sensor data in the background, even when using a foreground service. Without it, the system can restrict or stop sensor data delivery when the application is not in the immediate foreground for an extended period.
private void requestBackgroundPermission() { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { Toast.makeText(this, "Please allow 'All the time' sensor access in settings",Toast.LENGTH_LONG).show(); // On API 30+, background permission MUST be requested separately and // the user must be directed to settings manually in many cases, or through a system dialog. ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.BODY_SENSORS_BACKGROUND}, BACKGROUND_PERMISSION_REQUEST_CODE); } } Override the onRequestPermissionsResult() method to handle the user's response to each permission request:
@Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { if (checkBackgroundPermission()) { startSensorService(); } else { requestBackgroundPermission(); } } else { Toast.makeText(this, "Permission denied to read sensors", Toast.LENGTH_SHORT).show(); } } else if (requestCode == BACKGROUND_PERMISSION_REQUEST_CODE) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { startSensorService(); } else { Toast.makeText(this, "Background permission denied. Data collection may stop when app is not in foreground.", Toast.LENGTH_LONG).show(); // Optionally start service anyway, knowing it might be limited startSensorService(); } } } Even if the background permission is denied, the service is started. This allows heart rate collection to continue while the application is visible, though data collection may pause when it moves to the background.


BroadcastReceiver:
Send an intent with the heart rate value to update the UI components in real time. This should be outside of the onCreate() method.
private final BroadcastReceiver heartRateReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (SensorService.ACTION_HEART_RATE_UPDATE.equals(intent.getAction())) { float heartRate = intent.getFloatExtra(SensorService.EXTRA_HEART_RATE, 0); if (heartRateTextView != null) { heartRateTextView.setText(String.format(Locale.getDefault(), "%.0f", heartRate)); } } } };
onResume() :
Register a BroadcastReceiver inside this method to catch updates and display them in a TextView element.
@Override protected void onResume() { super.onResume(); IntentFilter filter = new IntentFilter(SensorService.ACTION_HEART_RATE_UPDATE); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { registerReceiver(heartRateReceiver, filter, Context.RECEIVER_NOT_EXPORTED); } else { registerReceiver(heartRateReceiver, filter); } }
onDestroy() :
This method stops the service when the activity is destroyed, preventing a dangling service.
@Override protected void onDestroy() { stopSensorService(); super.onDestroy(); }
Step 5: Edit SensorService.java
This is the core of the tutorial. SensorService is a foreground service that registers a heart rate sensor listener and acquires a wake lock to keep the CPU active when the screen turns off.


onCreate() :
Initialize the SensorManager instance and request the wake-up sensor. Here, do not use the default sensor. Instead, request the wake-up version:
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); if (sensorManager != null) { // Attempt to get the wake-up version of the sensor heartRateSensor = sensorManager.getDefaultSensor(Sensor.TYPE_HEART_RATE, true); if (heartRateSensor == null) { Log.i(TAG, "Wake-up heart rate sensor not available, falling back to non-wake-up."); heartRateSensor = sensorManager.getDefaultSensor(Sensor.TYPE_HEART_RATE); } } Standard sensors stop sending data when the screen turns off. The true parameter ensures the sensor can wake up the processor to deliver data even in deep sleep.


onStartCommand() :
Execute the foreground service notification.
Promoting your service to the foreground is mandatory for the tracking to stay alive. This prevents Galaxy Watch from pausing your application after 60 seconds of screen-off time.
Promote Immediately: In onStartCommand(), promote the service to the foreground immediately to satisfy Android’s background limitations.
Build the Notification: Create a persistent notification that informs the user that heart rate tracking is active.
Specify Service Type: Android 10+ requires the FOREGROUND_SERVICE_TYPE_HEALTH type for health sensors.
Register Listener: Register the sensor listener to begin receiving heart rate events.
Check the code here:
@Override public int onStartCommand(Intent intent, int flags, int startId) { Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID) .setContentTitle(getString(R.string.sensor_notification_title)) .setContentText(getString(R.string.sensor_notification_text)) .setSmallIcon(android.R.drawable.ic_menu_info_details) .setPriority(NotificationCompat.PRIORITY_DEFAULT) .build(); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_HEALTH); } else { startForeground(1, notification); } if (heartRateSensor != null) { sensorManager.registerListener(this, heartRateSensor, SensorManager.SENSOR_DELAY_UI); Log.d(TAG, "Heart rate sensor registered."); } else { Log.e(TAG, "Heart rate sensor not available."); } return START_STICKY; }
onSensorChanged() :
To process sensor data and broadcast updates, implement this method to handle the actual data.
Capture Value: Extract the heart rate from event.values[0].
Broadcast Result: Send a local broadcast with the heart rate value so your UI components can update in real-time.
Here is the code:
@Override public void onSensorChanged(SensorEvent event) { if (event.sensor.getType() == Sensor.TYPE_HEART_RATE) { float heartRate = event.values[0]; Log.d(TAG, "_________Heart Rate: " + heartRate); // Broadcast the result to update the UI Intent intent = new Intent(ACTION_HEART_RATE_UPDATE); intent.putExtra(EXTRA_HEART_RATE, heartRate); intent.setPackage(getPackageName()); // Ensure only this app receives the broadcast sendBroadcast(intent); } }
onDestroy() :
In this method, unregister the sensor listener to prevent excessive battery drain after the user is finished.
@Override public void onDestroy() { if (sensorManager != null) { sensorManager.unregisterListener(this); //Stop sensor } Log.d(TAG, "Sensor service destroyed and listener unregistered."); super.onDestroy(); } Step 6: Download the Sample Application
You may download the final projects here:
SensorReadConExample (556.0 KB) 04/23/2026 Step 7: Run the Sample Application on Galaxy Watch
To run the sample application on a Galaxy Watch:
Connect Galaxy Watch to Android Studio over Wi-Fi. Run the sample application on your device. Tap START SENSORS and grant the sensor permission when prompted. When you see the second prompt (or toast), go to the System Settings > Apps > Permissions > Sensors and select All the time. Once granted, the data collection continues even if you close the application UI or the watch screen goes dark.
When the screen turns off, heart rate logs continue in Android Studio Logcat. Tap STOP SENSORS when you want to stop data collection. This stops the service.
Figure 2: Sample application output on a real device



Figure 3: Data collection output in Logcat



In Logcat, filter by the SensorService tag to see the collected heart rate readings. New readings arrive even while the watch screen is off.
NoteYou need to wear the watch to read the heart rate data. Otherwise, it shows 0.0 as the value. Conclusion
Following the steps above, you can build a Galaxy Watch application that collects heart rate data continuously—even when the screen turns off. This same approach applies to other sensors as well, allowing you to read any sensor data continuously in the background.
If you have any questions about or need help with the information in this article, you can reach out to us on the Samsung Developers Forum or contact us through Developer Support.
View the full blog at its source

Samsung Wallet provides an e-wallet service to its customers through wallet cards, as well as offering features designed to enhance user engagement and drive business growth for partners. Sending push notifications to users is such a feature. Partners can send push notifications to users' wallet cards directly, using pre-approved message templates.
These notifications can be used to send promotional messages or alert users about important updates. This article demonstrates a complete implementation of the Send Notification API.
In the example scenario, we send a notification to a user's wallet card from a partner's server using this API.
System requirements
The Notification API has the following prerequisites:
Complete the onboarding procedure to obtain the required security certificates if you are new to Samsung Wallet.
Now create your wallet card. Follow the Step 1 - Create Wallet Card Template section of the documentation.
Create your notification template and request for approval. Follow the Notification Workflow Overview to complete this step. Remember to check the template to detect prohibited content. No additional approval is required if it passes.


Get permission from Samsung to use the Send Notification API. Reach out to Samsung Developer Support for further support. API fundamentals
As an authorized partner, you can send notifications to the users linked to your card, using the Send Notification API from your server.
Endpoint: The endpoint below processes the notification requests.
URL https://tsapi-card.walletsvc.samsung.com/{cc2}/wltex/cards/{cardId}/notifications/{templateId}/send Headers: Header information is required to ensure secure communication between the Samsung server and the partner server.
Authorization: Bearer token for authentication. Refer to JSON Web Token documentation for specifications. x-smcs-partner-id: Unique partner identifier required for API access. x-request-id: A unique UUID string that identifies each request. Body: A payload including a parameter named ndata possessing a JWT token that contains the relevant data to identify the card user.
See the official documentation for detailed API specifications.
API implementation process
The Send Notification API allows you to send personalized push notifications to users. Download the sample source code and follow the step-by-step process below for a better understanding of the implementation of the API.
Step 1: Managing cryptographic keys
Cryptographic keys are needed for authorization purposes. In this step, use the certificate you obtained during the onboarding process to extract the necessary keys. These keys are needed for JWT token generation.
Extracting the public keys
Extract the public keys from the partner.crt and samsung.crt certificate files.
def getPublicKey(crt_path): try: with open(crt_path, "rb") as f: crt_data = f.read() certificate = x509.load_pem_x509_certificate(crt_data, default_backend()) public_key = certificate.public_key() public_key_pem = public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ) return public_key_pem except Exception as error: print(f"Error reading public key from {crt_path}: {error}") return None Extracting the private key
Extract the private key from the .pem file generated during the onboarding process.
def getPrivateKey(pem_path): try: with open(pem_path, "rb") as data: private_key = serialization.load_pem_private_key( data.read(), password=None, backend=default_backend() ) return private_key except Exception as error: print(f"Error reading private key from {pem_path}: {error}") return None Step 2: Constructing the authorization token
An authorization token is needed to validate the API request. Construct an authorization header with AUTH as the payload content type and include the certificate and partner IDs. Retrieve these IDs from My account > Encryption Management in the Wallet Partner Portal, then build the payload and construct the authorization token.
The following code snippet implements the actions described.
def generateAuthToken(partnerId, certificateId, utcTimestamp, privateKey, cardId, cc2, templateId): auth_header = { "cty": "AUTH", "ver": 3, "certificateId": certificateId, "partnerId": partnerId, "utc": utcTimestamp, "alg": "RS256" } auth_payload = { "API": { "method": "POST", "path": f"/wltex/cards/{cardId}/notifications/{templateId}/send" }, } auth_token = jwt.encode( payload=auth_payload, key=privateKey, algorithm='RS256', headers=auth_header ) return auth_token Step 3: Constructing the notification data token
The request payload requires the ndata parameter, which is a JWT token that contains information about the notification data and the cards’ identifiers. Follow these steps to construct the ndata token.
Defining the notification object
The notification object is a JSON structured data object containing a list of reference IDs and the data. The reference IDs identify the specific cards to send the push notification to. You can use a list of reference IDs to send the push notification to multiple recipients at a time. The data contains the name-value pairs used in the notification template. In our sample notification template, we used two name-value pairs (name and insert_end_date).
notifcationObject = { "refIds": [ "4afb049c-efef-43ca-8f03-1df55243477c" ], "data": { "name": "Premium", "insert_end_date": "12/12/2026" } } Constructing the notification data JWT token
Next, construct the JWT token for notification data (ndata). You can get more information about the JWT format in the "Card Data Token" section of this documentation.
def generateCDataToken(partnerId, samsungPublicKey, partnerPrivateKey, certificateId, utcTimestamp, data): jwe_header = { "alg": "RSA1_5", "enc": "A128GCM" } jwe_token = jwe.encrypt( data, samsungPublicKey, encryption=jwe_header["enc"], algorithm=jwe_header["alg"] ) print(f"jwe_token: \n{jwe_token}\n") jws_header = { "alg": "RS256", "cty": "NOTIFICATION", "ver": 3, "certificateId": certificateId, "partnerId": partnerId, "utc": utcTimestamp, } jws_token = jws.sign( jwe_token, key=partnerPrivateKey, algorithm='RS256', headers=jws_header ) print(f"jws_token: \n{jws_token}\n") return jws_token Step 4: Building and executing the POST request
Construct the HTTP POST request to send the push notification using the following code structure.
# --- Prepare JSON body (Python dictionary) --- payload = { "ndata": nData } # --- Build HTTP Request --- headers = { "Authorization": "Bearer " + authToken, "x-smcs-partner-id": partnerId, "x-request-id": requestId, "Content-Type": "application/json" } # --- Execute HTTP Request --- try: response = requests.post(endpoint, json=payload, headers=headers) response.raise_for_status() print("Wallet Card Template Notificatiom: " + json.dumps(response.json())) except requests.exceptions.RequestException as e: print("Failed to notify the Wallet Card user:") print(f"Error: {e}") if response: print("Response body:", response.text) Running the sample application
Once the four steps described above are implemented, open the sample project and do the following:
Update the partner_id, certificate_id, card_id, and template_id values in src/main.py with your actual values. Place your partner.crt, samsung.crt and private_key.pem files in the /cert directory. Install all dependent libraries listed in the requirements.txt file. Run the main script in the terminal. After the script is executed successfully, a push notification is sent to the user's wallet.


Conclusion
Now that you have implemented the Send Notification API sample application successfully, you can implement this API with your server to send customized push notifications.
Additional resources
For more information on this topic, consult the following resources:
Complete source code Official Samsung Wallet API documentation View the full blog at its source

Samsung TV Plus, Samsung Electronics’ free ad-supported streaming (FAST) service, has surpassed 100 million monthly active users (MAU) worldwide. After reaching 88 million in October 2024, the figure has increased by 12 million in about a year and two months, highlighting how Samsung’s longstanding hardware dominance in the global TV market — maintained for the past 19 years — has evolved into a robust media platform ecosystem.
As the global media market shifts increasingly toward paid subscriptions, Samsung TV Plus provides a unique viewing experience that allows users to access content instantly, without requiring additional sign-ups or payment. Surpassing the milestone of 100 million users underscores the success of this model as an appealing alternative for viewers.
Samsung Newsroom takes a look at the transformative journey of Samsung TV Plus as it evolves into a global media platform amidst the changing landscape of television viewing.

Lost in a Flood of OTTs: Authentic TV Experience Regains Attention
With paid OTT services becoming the norm in today’s media market, the explosion of content has led to viewer fatigue. As subscription fees continue to rise and platforms have become more fragmented, many find themselves overwhelmed by the sheer number of choices, making it increasingly difficult to locate the content they actually want to watch.
In this context, FAST services are gaining recognition as a new viewing method. By merging the straightforwardness of traditional television — where viewers can jump right into content as soon as they turn on their TVs — with the vast selection offered by OTT platforms that allow viewers to choose content tailored to their preferences, FAST services are appealing to viewers worldwide looking for a simpler, hassle-free viewing experience.

The Beginning of Samsung TV Plus: A Viewing Method Faithful to the Basics
Samsung TV Plus has evolved into a prominent FAST service, but it isn’t new. Launched in 2015 — before the concept of FAST even existed — the platform has been delivering free channel services that come pre-installed on Samsung smart TVs. The core feature allows users to enjoy live content simply by turning on their TVs, without the need for separate subscriptions, payments or extra equipment.
In its early days, Samsung TV Plus was often viewed more like the pre-installed free TV channels available in some regions, rather than as a standalone media platform. Recently, however, with American broadcasters flooding into the FAST market, the idea of ad-supported free services has become well-established. Recognizing this shift in the media landscape, Samsung has begun to cultivate Samsung TV Plus as a distinct, independent media platform.
Today, Samsung TV Plus is broadening its content offerings beyond traditional entertainment and dramas, as well as incorporating content enhancement utilizing AI technology. One innovative feature is the “All-in-One AI Integrated Channel,” which revives popular dramas from the 2000s. These classics have been remastered in high definition using AI-driven picture and sound quality enhancements, providing viewers with a fresh take on beloved content while utilizing the existing video assets. Additionally, the platform has bolstered its travel and fitness-focused lifestyle web entertainment content by adding popular creators’ channels like “Pani Bottle” and “Hip Euddeum.”
In efforts to expand its K-content offerings, Samsung TV Plus has partnered with leading Korean media companies to enhance its premium K-content lineup, making it one of the largest K-content providers in the United States. By streaming various live concerts, the platform draws in fans who want to engage with Korean entertainment and culture.

Beyond Hardware: Establishing a Global Media Platform
Currently, Samsung TV Plus boasts around 4,300 channels and 66,000 videos on demand (VOD) across 30 countries — all for free. By partnering with local broadcasters and content creators, the service continues to develop content that meets regional viewing demands, shaping a global FAST ecosystem. Moving beyond being merely a hardware manufacturer, the company is establishing itself as a major media platform.
In Korea, major channels and content typically consumed via terrestrial broadcasts and existing IPTV services can now also be accessed on Samsung TV Plus. Offering live channels and vast content libraries without additional subscriptions or fees, this platform has become a practical alternative for those wishing to reduce their reliance on paid broadcasting services. Users can enjoy an intuitive experience without the hassle of extra equipment or complicated setups and the burden of discovering new content is significantly eased.

Achieving Major Broadcaster-Level Viewership: Solidifying Leadership in the Global FAST Competition
Samsung TV Plus has achieved impressive 100 million monthly viewership numbers, placing it on par with the three major global broadcasting networks. This notable milestone signifies that the service has evolved from being just an additional feature on Samsung TVs into a robust platform that competes alongside leading global media companies.
Samsung is committed to expanding its presence within the global media ecosystem through Samsung TV Plus. The strategy focuses on continuously enhancing the platform’s value by setting standards for enjoyable TV viewing experiences for users — driven by three key factors: instant viewing capabilities without the need for a separate set-top box, AI-based content curation and constantly updated competitive offerings.
“Samsung TV Plus has transformed into a global media platform that seamlessly integrates into the daily lives of viewers worldwide,” said Choi Joon-hun, Head of the TV Plus Group from Visual Display Business at Samsung Electronics. “Moving forward, we will continue to strengthen our distinct competitive edge in the FAST market by diversifying channels and securing premium content.”
Built on its strong hardware leadership, Samsung Electronics is positioning itself as a key player in the global media ecosystem. Samsung TV Plus is ushering in a new, user-centric lifestyle of content consumption, reshaping the way viewers interact with media.
View the full article

Samsung Electronics today announced that they are working to bring Google Photos to Samsung TVs to give users a seamless way to enjoy the moments that matter most, from trips and hobbies to everyday memories with loved ones — now on an immersive and larger screen. The experience aims to offer families a delightful and meaningful way to rediscover their favorite memories together.1
“Samsung TVs have always brought people together, and bringing Google Photos to the big screen makes that experience even more personal,” said Kevin Lee, Executive Vice President of the Customer Experience Team at the Visual Display (VD) Business of Samsung Electronics. “We’re giving users an intuitive and engaging way to enjoy the stories behind their photos — right from the comfort of their living room.”

A More Meaningful Way To Enjoy Personal Photos
Google Photos makes reliving and sharing special memories easy. With the planned integration, it will seamlessly bring the photos people capture on their phones to Samsung TVs, where they can appear in a larger, cinematic format.
Through the proposed integration, users can explore curated memories on their TVs organized by people, places, and meaningful moments. Google Photos will also expand the suite of photo-driven experiences that integrate with Samsung’s Vision AI Companion (VAC), enriching how memories are highlighted and enjoyed throughout the day.
Samsung wants Google Photos to be deeply woven into the TV experience. Imagine Photos surfacing naturally through Daily+ and Daily Board, ensuring that meaningful memories2 greet users throughout their day in contextual and convenient moments. The setup should be simple — users sign in with their Google Account, and their photo memories instantly appear on the big screen.3

Three Ways To Relive and Rediscover: Memories, Create and Personalized Results
Memories (planned to launch exclusive in early 2026): Shows curated stories based on people, locations, and meaningful moments for the first time on TV, available first and exclusively on Samsung TVs for six months.4 Create with AI (planned to launch later in 2026): Introduces themed templates5 built on Nano Banana, Google DeepMind’s image generation and editing model, featuring playful and fun transformation. Users can also utilize Remix to transform the art style of an image or Photo to Video to bring still moments to life as short videos. Personalized Results (planned to launch later in 2026): Users may view related photos as a slideshow based on topics or contents of memories e.g. ocean, hiking, Paris, etc.
A Seamless Way To Experience Memories on Samsung TV
Samsung and Google Photos want to bring a cinematic gallery experience to the heart of the home, enabling Samsung TV users to browse and relive their most important moments in stunning detail. This integration will transform personal photo libraries into a space where users are invited to explore their journey, create new stories and reminisce over cherished memories with depth and simplicity.
“Google Photos is a home for people’s photos and videos, helping them organize and bring their memories to life,” said Shimrit Ben-Yair, Vice President, Google Photos and Google One. “We’re excited to bring Google Photos to Samsung TVs — helping people enjoy their favorite photos on a larger screen and reconnect with their memories in new ways.”
Features and availability may vary by model and region. ︎ Available on Samsung TV models launched 2026 with a Google Account and backed-up photos/videos. For in market models, experience will be available following the OS update schedule. ︎ Memories must not be turned off in Google Photos settings. ︎ Memories available beginning March 2026; Create and Search available in the second half of 2026. ︎ Select creative AI templates will be available exclusively on Samsung TVs. ︎ View the full article