• Learn
    • Code Lab
    • Foldables and Large Screens
    • One UI Beta
  • Develop
    • Mobile/Wearable
    • Galaxy GameDev
    • Galaxy Themes
    • Galaxy Watch
    • Health
    • Samsung Blockchain
    • Samsung DeX
    • Samsung IAP
    • Samsung Internet
    • Samsung Pay
    • Samsung Wallet
    • View All
      • Galaxy AR Emoji
      • Galaxy Accessory
      • Galaxy Edge
      • Galaxy Z
      • Galaxy Performance
      • Galaxy FM Radio
      • Galaxy S Pen Remote
      • Galaxy Sensor Extension
      • PENUP
      • Samsung Automation
      • Samsung Neural
      • Samsung TEEGRIS
      • Samsung eSE SDK
      • Galaxy Watch for Tizen
      • Watch Face Studio
      • One UI Watch for Tizen
      • Galaxy Watch Studio Converter
      • Samsung IAP for Galaxy Watch (Tizen)
    • Visual Display
    • Smart TV
    • Smart Hospitality Display
    • Smart Signage
    • Digital Appliance
    • Family Hub
    • Platform
    • Bixby
    • Knox
    • SmartThings
    • Tizen.NET
  • Design
    • Design System
    • One UI
    • One UI Watch
    • Smart TV
  • Distribute
    • Galaxy Store
    • TV Seller Office
    • Galaxy Store Games
    • Instant Plays
  • Support
    • Developer Support
    • Remote Test Lab
    • Samsung Android USB Driver
    • Galaxy Emulator Skin
  • Connect
    • Blog
    • News
    • Forums
    • Events
    • Samsung Developer Conference
    • SDC23
    • SDC22
    • SDC21
    • SDC19 and Previous Events
  • Sign In
Top Global Search Form
Recommendation
  • Blog
  • Code Lab
  • Foldable and Large Screen Optimization
  • Forums
  • Galaxy Emulator Skin
  • Galaxy GameDev
  • Health
  • Remote Test Lab
  • SDC22
  • Watch Face Studio
All Search Form
Recommendation
    Suggestion
      All Search Form
      Filter
      Filter
      Filter
      • ALL (41)
      • DOCS
      • SDK
      • API REFERENCE
      • CODE LAB
      • BLOG
      • NEWS/EVENTS
      • OTHERS
        api reference code lab blog news/events
      1. tutorials | health, galaxy watch

      blog

      Using Health Services on Galaxy Watch

      health services provides an advanced set of apis that allow your application to take full advantage of the powerful hardware available on galaxy watches running wear os powered by samsung. thanks to this careful combination of hardware and software, applications are able to reliably track information from sensors in the watch. this solution allows developers to specify what type of data they are using in their applications, as well as allowing users to decide what data can be processed and accessed. getting things ready to take advantage of health services health services works on devices such as galaxy watch4 and galaxy watch4 classic operating on wear os powered by samsung. health services requires android 11 (api level 30) or above. add required information to your app’s configuration files to start using health services in a new or existing android studio project, you just need to follow a series of steps described below: add the appropriate library dependency to your app’s build.gradle file. dependencies { implementation 'androidx.health:health-services-client:1.0.0-alpha03 // ... } in your app’s android manifest, add the necessary configuration to allow your app to connect with the health service. <queries> <package android:name="com.google.android.wearable.healthservices" /> </queries> add the permissions required by your app. <uses-permission android:name="android.permission.body_sensors" /> <uses-permission android:name="android.permission.activity_recognition" /> <uses-permission android:name="android.permission.foreground_service" /> <uses-permission android:name="android.permission.access_fine_location" /> in order to improve the security of your application and to ensure a good user experience, you should only add the permissions that are required by your application from the list above. additionally, if your application features passive monitoring, you have to add the lines below to your app’s manifest to register the health event broadcast receiver. <receiver android:name="com.samsung.android.eventsmonitor.eventbroadcastreceiver" android:exported="true"> <intent-filter> <action android:name="hs.passivemonitoring.health_event" /> </intent-filter> <receiver/> requesting permissions programmatically apart from being registered in the app’s manifest, permissions have to be requested programmatically to validate and get user consent at runtime. the code below shows how to request these permissions: requestpermissions(new string[] {manifest.permission.body_sensors, manifest.permission.foreground_service, manifest.permission.activity_recognition, manifest.permission.access_fine_location}, 0); at runtime, if your application has requested the permissions correctly, a popup similar to the one below appears after the execution of your application: to get the result of the permission request you have made previously, you should check the result as shown in the code below: @override public void onrequestpermissionsresult(int requestcode, @nonnull string[] permissions, @nonnull int[] grantresults) { if(requestcode == 0) { list<string> notgrantedpermissions= new linkedlist<>(); setpermissiongranted(true); for(int i=0; i<permissions.length; i++) { if(grantresults[i] == permission_denied) { setpermissiongranted(false); notgrantedpermissions.add(permissions[i]); } } if(!getpermissiongranted()) { // handle permission denied here. } } super.onrequestpermissionsresult(requestcode,permissions,grantresults); } checking the device capabilities there is nothing more annoying than an application that does not work as expected, causing a bad user experience or even worse, a crash. fortunately, health services provides a way to verify if the current setup you have configured supports the functionality required. it accomplishes this by using apis to get the capabilities and supported data types for the current configuration. this allows developers to handle errors and decide the best way to notify the users of the app about potential problems. the code below is an example of the usage of such apis for exerciseclient: // connection to the health services healthservicesclient healthclient = healthservices.getclient(this); exerciseclient exerciseclient = healthclient.getexerciseclient(); listenablefuture<exercisecapabilities> capabilitiesfuture = passiveclient.getcapabilities(); futures.addcallback(capabilitiesfuture, new futurecallback<exercisecapabilities>() { @override public void onsuccess(@nullable exercisecapabilities result) { runningcapabilities = result .supporteddatatypesexcercise() .contains(exercisetype.running) } @override public void onfailure(throwable t) { // display an error } }, contextcompat.getmainexecutor(this)); enjoy your adventure creating the ultimate health application now that you have finally set up health services in your app’s project, you are ready to start using the apis to enhance the capabilities of your application. we encourage you to check our next series of posts to discover even more from health services on galaxy watch!

      https://developer.samsung.com/health/blog/en-us/2022/01/14/using-health-services-on-galaxy-watch
      1. tutorials | health, galaxy watch

      blog

      Handling Fitness Goals Using Health Services

      one of the methods for obtaining data from health services running on galaxy watch with wear os powered by samsung is to register notifications for fitness goals. galaxy watch collects physical activity data in real-time and allows the user to sign up for information about achieving their goals. this mechanism allows you to monitor the health services data in the background. a sample application named goalevent shows the above described mechanism. full source code of this application can be downloaded from goalevent. application overview goalevent is a sample application with only one task: it is designed to monitor health services data in the background. its interface allows the user to subscribe to a health event. two buttons make it possible to set the amount of steps to achieve and a third button makes it is possible to subscribe to an event. a toast with information about achieving the goal is shown when the step count is greater than or equal to the set amount of steps. the construction of the most important elements of this application is described in the next sections, step-by-step. the code below comes from the goalevent application. add health services the first step to start using health services is to add the implementation of the service client to application dependencies. there are also necessary changes in the manifest file. to interact with health services, there should be information about this package. more information about adding health services usage to a project is contained in this article: using health services on galaxy watch obtain permissions the second step of the application is to obtain permissions. to use necessary operating system elements, you should place all of the required permissions in the android manifest. there are two types of permissions needed for receiving steps information and for showing an ongoing notification. permissions required by the application: <!-- for receiving steps information. --> <uses-permission android:name="android.permission.activity_recognition" /> <!-- for showing an ongoing notification. --> <uses-permission android:name="android.permission.foreground_service" /> as a next step, these permissions should be requested in the main activity of the application. after receiving the results of the permissions request and making sure that all of them are granted, it is possible to go on and check capabilities. request permission example code: requestpermissions(new string[]{ manifest.permission.foreground_service, manifest.permission.activity_recognition}, 0); check capabilities the next step, after obtaining the permissions, that is necessary to use the health platform and making sure that all permissions have been obtained, is to check that the device can provide passive goals. this takes place in the passive monitoring client where there are data types corresponding to a chosen activity⁠—for example, steps. check capabilities in goal event client: boolean supportsstepsevent = result .getsupporteddatatypesevents() .contains(datatype.steps); if(supportsstepsevent) { registergoal(context); } register a goal after getting information that step goals are supported, it is possible to register a goal. to do this, you need to create a passive goal and register the appropriate callback. the callback, which is received, must be served by a specially designed interface. this class should be appropriately marked in the android manifest as a goal receiver. register a goal in the goal event client: public class goaleventclient { //... public void registergoal(context context) { if(goalregistered) return; goalregistered = true; mpassivegoal = new passivegoal( new datatypecondition(datatype.steps, value.oflong(number_of_steps), comparisontype.greater_than_or_equal), passivegoal.triggertype.once); mpassivemonitoringclient.registerpassivegoalcallback(mpassivegoal, new componentname(context, eventreceiver.class)); } //... } add receiver information inside of the application tag in the android manifest: <application <!--....--> <receiver android:name="com.samsung.android.goalevent.eventreceiver" android:exported="true"> <intent-filter> <action android:name="hs.passivemonitoring.goal" /> </intent-filter> </receiver> <!--...--> </application> receive notification in the receiver code, first you need to check the intent action to ensure that it is a passive goal. then reconstruct the passive goal from the intent to determine that the incoming goal is the same as the goal created earlier. override the receive method in the event receiver: public final class eventreceiver extends broadcastreceiver { private static final string tag = "eventreceiver"; @override public void onreceive(context context, intent intent) { if(!intent.getaction().equals(passivegoal.action_goal)){ return; } passivegoal goal = passivegoal.fromintent(intent); if(goal != null && goal.equals(goaleventclient.getinstance(context).getpassivegoal())){ log.i(tag, "step goal achieved!"); toast.maketext(context, r.string.step_goal_achieved, toast.length_long) .show(); goaleventclient.getinstance(context).unregistergoal(); } } } unregister the goal it is a good practice to unregister the goal when the application is destroyed by the os. to do this, add an additional boolean parameter which holds information about the registration status. this parameter should be set to "true" at the time of registration and to "false" at the time of goal deregistration. add a function to unregister a goal which is triggered at the time of destroying the application: public class goaleventclient { //... public void unregistergoal() { if(!goalregistered) return; goalregistered = false; mpassivemonitoringclient.unregisterpassivegoalcallback(mpassivegoal); mpassivegoal = null; } //... } test the application on a device the application can be tested on the galaxy watch with wear os powered by samsung by running it directly from android studio. to test the application, follow these steps: set the number of steps you want to achieve. push the 'set goal' button. 3. put your watch on your wrist and walk the set number of steps. 4. after reaching the goal, you receive information on the screen about achieving the goal and the watch vibrates. enjoy your adventure creating the ultimate health application now you are ready to start handling fitness goals using health services data in the background in your application on galaxy watch with wear os powered by samsung. check out our next series of posts that cover ways to access exercises using the health services api!

      https://developer.samsung.com/health/blog/en-us/2022/04/27/handling-fitness-goals-using-health-services
      1. tutorials | health, galaxy watch

      blog

      Reading Body Composition Data with Galaxy Watch via Health Connect API

      the body composition measurement is one of the powerful features of samsung galaxy watch. it is an important metric of your overall health. the body composition measurement data is displayed in the samsung health application on the galaxy watch and a compatible smartphone. in this article, we show you how to read the galaxy watch’s body composition data using the android health connect api in a sample application named "bia viewer". you can download the code for this sample application from the link at the bottom of this blog. bia is an abbreviation for bioelectrical impedance analysis, and the bia data measures body composition data. note : the body composition measurement feature is available on galaxy watch4 series and later models. installing health connect api the android health connect api provides interfaces for reading and writing your health and fitness data. the samsung health application exchanges data with the health connect api. to synchronize the data between the samsung health application and the health connect api, you must install the health connect application from google play. for more information, see accessing samsung health data through health connect. note : synchronization of data between the samsung health application and the health connect api is supported on samsung health v6.22.5 and later. measuring body composition with galaxy watch as the first step in developing your ultimate health application, you must collect the body composition data using the samsung health application in galaxy watch. steps to measure bia with galaxy watch: start the samsung health application. ensure that the galaxy watch is worn tightly on your wrist. raise your arms so your armpits are open. place your middle finger on the 2 o’clock key and ring finger on the 4 o’clock key on the watch. touch your watch only. don’t let your hand on the watch’s keys touch your arm or other hand on the watch. maintain the finger positions on the galaxy watch dial until the measurement is completed. example of a result obtained by measuring body composition with the samsung health application: after the bia measurement is completed on the galaxy watch, the data can be synchronized with the samsung health application. synchronizing data with the health connect application once you have data in the samsung health application, it is synchronized with the health connect application. synchronized body composition data can be found directly in the health connect application. basal metabolic rate body fat height weight bia viewer application overview bia viewer is an application that reads the body composition data collected by the samsung health application with the health connect apis. by default, this application loads the data during startup. however, you can manually reload the data using the “refresh” button. the bia viewer application reads the body composition data such as weight, height, body fat, basal metabolic rate. the user's height is not displayed and is only used to calculate bmi. the step-by-step construction of the most important elements of the application are described in the next sections. note : fat mass is calculated using the formula: [fat mass] = [body fat] * [weight] / 100 bmi is calculated using the formula: [bmi] = [weight] / ([height]* [height]) adding health connect api to your project before you start writing your code, you need to import and add the health connect api library to the file application/build.gradle in the dependencies section. implementation 'androidx.health.connect:connect-client:1.0.0-alpha07' now you are ready to use the health connect api. checking health connect availability on your device at the beginning of your application, it's a good idea to ensure that the device running your application actually supports the health connect api library. the library is available only when the health connect application is installed on the device. in our sample application, we set the availability flag, which can take any of the following three values: installed not_installed not_supported availability.value = when { healthconnectclient.isavailable(context) -> healthconnectavailability.installed issupported() -> healthconnectavailability.not_installed else -> healthconnectavailability.not_supported } in the next step, we can check the value of this flag and read the data or display an appropriate message to the user. when (availability) { healthconnectavailability.not_supported -> { val notsupportedtext = getstring( r.string.not_supported_description, min_supported_sdk ) toast.maketext(this, notsupportedtext, toast.length_long).show() } healthconnectavailability.not_installed -> { toast.maketext(this, r.string.not_installed_description, toast.length_long).show() } else -> { … } } get healthconnectclient before going to the next step, you need to get healthconnectclient. healthconnectclient is an entry point to the health connect api. healthconnectclient automatically manages its connection to the underlying storage layer and handles all ipc and serialization of the outgoing requests and the incoming responses. private val healthconnectclient by lazy { healthconnectclient.getorcreate(context) } ask for permissions in the first step, you need to modify the androidmanifest.xml file. add <intent-filter> in the <activity> section: <intent-filter> <action android:name="androidx.health.action_show_permissions_rationale" /> </intent-filter> add <meta-data> in the <activity> section: <meta-data android:name="health_permissions" android:resource="@array/health_permissions"/> add the <queries> element: <queries> <package android:name="com.google.android.apps.healthdata" /> </queries> declare the permissions your application will use. create an array resource in res/values/health_permissions.xml (we used them in androidmanifest.xml file). note that you need to add a line for every permission that your application will use: <resources> <array name="health_permissions"> <item>androidx.health.permission.weight.read</item> <item>androidx.health.permission.height.read</item> <item>androidx.health.permission.bodyfat.read</item> <item>androidx.health.permission.basalmetabolicrate.read</item> </array> </resources> to start the request permissions from your application, first build a set of permissions for the required data types. ensure that the permissions in the set are the same as in the res/values/health_permissions.xml file. val permissions = setof( healthpermission.createreadpermission(weightrecord::class), healthpermission.createreadpermission(heightrecord::class), healthpermission.createreadpermission(bodyfatrecord::class), healthpermission.createreadpermission(basalmetabolicraterecord::class), ) it is a good practice to ask for the required permissions whenever the application tries to use this data type. first, you should check whether the user has consented to use the particular functionality. suspend fun hasallpermissions(): boolean { return permissions == healthconnectclient.permissioncontroller.getgrantedpermissions( permissions ) } if not, you should ask for it before using the api. private fun checkpermissionsandrun() { lifecyclescope.launch { if (healthconnectmanager.hasallpermissions()) { readalldata() } else { requestpermissions.launch(healthconnectmanager.permissions) } } } to ask about permissions, you need to create a request permissions object. private fun createrequestpermissionsobject() { requestpermissions = registerforactivityresult(healthconnectmanager.requestpermissionactivitycontract) { granted -> lifecyclescope.launch { if (granted.isnotempty() && healthconnectmanager.hasallpermissions()) { // permissions successfully granted log.i(tag, "permissions successfully granted") readalldata() } else { // lack of required permissions runonuithread { toast.maketext(this@mainactivity, r.string.permission_denied, toast.length_long) .show() } } } } } sample permission request window: creating a query to read body composition data to read data, build the readrecordsrequest object and in the parameters, specify the time range and the data type. then, read the data by passing the readrecordsrequest object as a parameter. after the request is finished, the result contains the list of returned data that you requested. then you go through the list and read individual records. in our example, we will read only the last value. readrecordsrequest example code for weightrecord data type: suspend fun readweight(start: instant, end: instant): double { val request = readrecordsrequest( recordtype = weightrecord::class, timerangefilter = timerangefilter.between(start, end) ) val response = healthconnectclient.readrecords(request) if (response.records.isnotempty()) { val weightrecord = response.records.last() return weightrecord.weight.inkilograms } return 0.0 } list of all the data types used in the application: basalmetabolicraterecord bodyfatrecord heightrecord weightrecord checking query results now you are ready to run the test application on your phone and compare the results of the application with the samsung health application. the application can be tested on the device by running it directly from android studio. the data in both pictures are identical. you were able to successfully recover the data from the samsung health application using the health connect api. resources this blog is based on the bia viewer application. the entire code in this blog comes from this application. the application can be downloaded from: bia viewer version 1.0 (89,0kb) dec 12, 2022 enjoy your adventure creating the ultimate health application now you are ready to start using the samsung health application with the health connect api to enhance the capabilities of your application.

      https://developer.samsung.com/health/blog/en-us/2022/12/21/reading-body-composition-data-with-galaxy-watch-via-health-connect-api
      1. tutorials | health, galaxy watch

      blog

      Events Monitoring

      the galaxy watch running wear os powered by samsung can detect events like hard falls. to detect the hard falls, the watch uses a built-in accelerometer. using the health services api, you can receive a fall detection event in your watch application. in this blog, we create a wear os application to identify a fall detection event and demonstrate how to use the health services api to achieve this on the galaxy watch. the galaxy watch uses the fall detection event in its sos feature. for more information, see use your samsung smart watch in an emergency situation. it can be used to take care of elderly people or patients. how to trigger a fall detection event in your application on the galaxy watch if the functionality provided with the watch is not sufficient for your solution, you can use the health services api to detect this event in your own application. in this section, we describe all the important steps that you must follow when building an events tracking app. as an example, we use the eventsmonitor sample project. project settings before you start writing your code, you need to import the health services api library in the dependencies section of the app/build.gradle file. implementation androidx.health:health-services-client:1.0.0-beta01 now you are ready to use the health services api. get passivemonitoringclient passivemonitoringclient enables tracking of the data in the background (without requiring an ongoing workout) and the events that can occur. you need to get this client to make your application suscribe to the events. private var healthservicesclient: healthservicesclient private var passivemonitoringclient: passivemonitoringclient init { healthservicesclient = healthservices.getclient(context) passivemonitoringclient = healthservicesclient.passivemonitoringclient } ask for permissions in the first step, you need to modify the androidmanifest.xml file. add the <uses-permission> element in the global section: <uses-permission android:name="android.permission.activity_recognition" /> <uses-permission android:name="android.permission.receive_boot_completed" /> <uses-permission android:name="android.permission.foreground_service" /> add the <queries> element: <queries> <package android:name="com.google.android.wearable.healthservices" /> </queries> it is a good practice to ask for the required permissions whenever the application tries to use this data type. first, you should check whether the user has consented to use the particular functionality. permissiongranted = applicationcontext.checkselfpermission( manifest.permission.activity_recognition) == packagemanager.permission_granted if not, you must ask for it before using the api. private fun requestpermissions() { permissionlauncher.launch(android.manifest.permission.activity_recognition) } to ask about permissions, you need to create a request permissions object. permissionlauncher = registerforactivityresult(activityresultcontracts.requestpermission()) { result -> permissiongranted = result } this is an example of a permission request window: using health services api to get events to asynchronously receive information about a fall detection event, provide the class which inherits from the passivelistenerservice class and override the onhealtheventreceived method. class passivehealtheventservice : passivelistenerservice() { override fun onhealtheventreceived(event: healthevent) { runblocking { log.i(tag, "onhealtheventreceived received with type: ${event.type}") healthservicesmanager.getinstance(applicationcontext).recordhealthevent(event) super.onhealtheventreceived(event) } } } add information about this class with the permissions to the androidmanifest.xml file. <service android:name=".passivehealtheventservice" android:exported="true" android:permission="com.google.android.wearable.healthservices.permission.passive_data_binding" /> when you have the passivemonitoringclient and passivehealtheventservice classes, you can then subscribe to the events. private val healtheventtypes = setof(healthevent.type.fall_detected) suspend fun registerforhealtheventsdata() { log.i(tag, "registering listener") val passivelistenerconfig = passivelistenerconfig.builder() .sethealtheventtypes(healtheventtypes) .build() passivemonitoringclient.setpassivelistenerserviceasync( passivehealtheventservice::class.java, passivelistenerconfig ).await() registered = true } if you no longer want to receive information about the fall detection event, please unregister your application from the service. this can be done using the passivemonitoringclient api. suspend fun unregisterhealtheventsdata() { log.i(tag, "unregistering listeners") passivemonitoringclient.clearpassivelistenerserviceasync().await() registered = false } the healthevent class contains information about the event, such as: type - returns the type of the event (fall_detected, unknown). instant - returns the time of the health event. datapointcontainer - returns the metrics associated with the event. test application on the galaxy watch you can test this functionality in the following two ways: manual test you can simulate a fall by trying to fall on a mat. note : before performing the manual test, ensure that you have taken all safety precautions for yourself. for example, use cushions to soften the fall impact, etc. synthetic data provider use the command line to run and execute commands with the synthetic data provider. for more details about this feature, see synthetic data provider. with adb, you can send subsequent commands to the device. to start the synthetic data provider, run the following command: $ adb shell am broadcast \ -a "whs.use_synthetic_providers" \ com.google.android.wearable.healthservices to simulate a fall, run the following command: $ adb shell am broadcast \ -a "whs.synthetic.user.fall_over" \ com.google.android.wearable.healthservices when the tests are finished, to switch back to using real sensors, run the following command: $ adb shell am broadcast \ -a "whs.use_sensor_providers" \ com.google.android.wearable.healthservices resources this blog is based on the eventsmonitor application. the whole presented code comes from this application. the entire application can be downloaded from: eventsmonitor version 1.0 (86,0kb) dec 12, 2022 enjoy your adventure creating the ultimate health application now you are ready to start the fall detection event in your application. we encourage you to try doing it by yourself and explore other features provided by the health services sdk.

      Samsung Developers

      https://developer.samsung.com/health/blog/en-us/2022/12/14/events-monitoring
      1. tutorials | health

      blog

      Accessing Samsung Health Data through Health Connect

      health connect is a platform that enables you to integrate samsung health data with your applications, creating new opportunities for health applications that enhance the user's journey towards better health. using the health connect apis, you can, for example, retrieve a user's samsung health data, such as their exercise, sleep, and heart rate information, and send data to the samsung health application. this is the first blog post in a series that introduces you to health connect api features and how you can use them in your applications. let's begin by looking at how health connect interacts with samsung health data, and the basic workflow. understanding this is essential for creating applications that use data from samsung health and health connect. samsung health samsung health is an application that can be installed on android smartphones and tablets, and on galaxy watches. it can use the sensors on the device, including the galaxy watch's bioactive sensor, to measure the user's overall health data, including steps, exercises, heart rate, sleep, blood oxygen saturation and body composition. let's consider the most common scenario: the samsung health application is installed on both the galaxy watch and a smartphone. the application synchronizes the measurements between both devices and manages the user's health data securely on them. for example, if the user measures their blood pressure with the samsung health monitor application on their smartphone, the data can be shared to samsung health. health connect since the samsung health application supports various useful health data types and gathers data from all connected devices, developers are very interested in obtaining access to that data. consequently, samsung collaborated with google to build the health connect platform, which was released in may 2022. health connect enables applications to share health and fitness data across android devices with the user's consent. for more information about health connect, see health connect guide and health connect apis. samsung health has supported synchronizing data with health connect since application version 6.22.5, released in october 2022. the health connect apis support devices using android sdk 28 (pie) or higher. once the user has connected samsung health to health connect, new or updated data in samsung health is shared to health connect. this means that your applications can use the health connect apis to access samsung health data. samsung health synchronizes health data with health connect in both directions: when samsung health has new or updated data, it writes the data to health connect. when health connect has updated data, samsung health retrieves it. for example, a blood glucose meter connected to samsung health measures the user's blood glucose level. this data is saved in samsung health and then sent to health connect. similarly, whenever there is new blood glucose data in health connect, samsung health retrieves that data and saves it in samsung health. to demonstrate how data synchronization works, let's walk through an example of adding nutrition information to samsung health. to start data synchronization between samsung health and health connect, you must enable it in the samsung health application on your android device. from the settings menu, select health connect. if health connect is not installed, you are prompted to install it. the first time you access the health connect menu item in samsung health with the health connect application installed, you are asked for permission to share your samsung health data with health connect. select the data you consent to sharing, and select allow. samsung health and health connect are now linked and data is shared between them. to test the data synchronization, in samsung health, go to food tracker and create some nutrition data. in samsung health, go to settings > health connect, and select data and access. if health connect has received nutrition data from samsung health, a nutrition item appears in the browse data list. to view the synchronized data, select nutrition. data synchronization timing data synchronization between samsung health and health connect occurs on the smartphone side. to take advantage of health data collected by a galaxy watch, you must understand at which times the galaxy watch sends its data to the samsung health smartphone application. new or updated health data on each connected device is generally synchronized with samsung health in the following situations: the galaxy watch reconnects with the smartphone the user opens the samsung health application home screen on the smartphone the user pulls down on the samsung health application home screen on the smartphone however, some types of health data are synchronized differently: for battery conservation reasons, continuous heart rate data from the galaxy watch is not sent to the samsung health application on the smartphone immediately. however, manual heart rate measurements on the watch are synchronized immediately. enabling settings in samsung health to synchronize health data between samsung health and health connect please consider: using the latest samsung health and health connect versions. you can check them in google play. if you're interested in galaxy watch's data, check its version too. allowing data permissions through the following path: samsung health > settings > health connect > app permissions > samsung health (note that you must enter from the samsung health settings, not from health connect settings.) synchronizing samsung health data in: samsung health > settings > sync with samsung account > select the 'sync now' button in the bottom. accessing health connect apis if the user has synchronized their samsung health data with health connect, you can use the health connect apis to interact with it in various ways. for example: read and write data: you can retrieve data that has been shared from samsung health to health connect, and send data to health connect to be synchronized to samsung health. delete specific data records: you can remove a specific data point or data of a specific type within a time interval. aggregate and filter data: you can filter the retrieved data by type or tag and analyze it, such as determining the average, maximum, minimum, or sum of the values. session data: you can group data into sessions by time interval, such as to generate a sleep or activity session report. note : for security reasons, health connect data can only be retrieved by applications running in the foreground. the following table lists the various health data that can be synchronized between samsung health and health connect. samsung health data corresponding data type of health connect all steps stepsrecord blood glucose bloodglucoserecord blood oxygen saturation oxygensaturationrecord blood pressure bloodpressurerecord exercise session exercisesessionrecord totalcaloriesburnedrecord distancerecord exercise (heart rate) heartraterecord exercise (power) powerrecord exercise (speed) speedrecord exercise (vo2max) vo2maxrecord heart rate heartraterecord sleep session sleepsessionrecord sleep stage sleepstagerecord weight / body composition weightrecord body composition bodyfatrecord body composition basalmetabolicraterecord to get started with implementing health connect api functionality in your application: add the health connect api library dependencies to your application's "build.gradle" file. declare the health connect application package name in your "androidmanifest.xml" file. check that the user has installed health connect, then create the "healthconnectclient" instance. declare the permissions for the health data types you want to use. now your application is ready to use the health connect apis. other blog posts in this series will explore various health connect api use cases in more detail. related blogs reading body composition data with galaxy watch via health connect api

      https://developer.samsung.com/health/blog/en-us/2022/12/21/accessing-samsung-health-data-through-health-connect
      1. tutorials | health, galaxy watch

      blog

      Tracking Exercises with Galaxy Watch

      galaxy watch offers a convenient way of measuring exercise progress. modern sensors designed specifically for health services provide the most precise readings. after connecting to health services, you can measure certain exercises and track their values. this blog describes all the important steps to build an exercise tracking app using the health services api. we use example code introduced in health code lab for tracking exercise. you can download the source code from this code lab. health services defines a variety of exercise types. for a full exercise type list, take a look at exercisetype. on galaxy watch4 and galaxy watch4 classic, a repetition counter is available for the following exercises: back_extension barbell_shoulder_press bench_press bench_sit_up burpee crunch deadlift forward_twist dumbbell_curl_right_arm dumbbell_front_raise dumbbell_lateral_raise dumbbell_triceps_extension_left_arm dumbbell_triceps_extension_right_arm dumbbell_triceps_extension_two_arm dumbbell_curl_left_arm jump_rope jumping_jack lat_pull_down lunge squat upper_twist in this application, we are going to use deadlift. the example code used for deadlift can be easily adapted to track all repetition-based exercises. the basics of connecting to health services are covered in the blog using health services on galaxy watch. setting up an exercise once connected to the health services api, we are ready to set up the exercise. in this case we use deadlift as a sample exercise. first, we need to get the exercise client: exerciseclient exerciseclient = client.getexerciseclient(); after that, we need to set the exercise type in the configuration builder: exercisetype exercisetype = exercisetype.deadlift exerciseconfigbuilder exerciseconfigbuilder = exerciseconfig.builder() .setexercisetype(exercisetype); to see what can be tracked for our exercise, we need to check its capabilities. we do this by using a listenablefuture object and listening for a callback from health services. listenablefuture<exercisecapabilities> capabilitieslistenablefuture = exerciseclient.getcapabilities(); when we receive a callback, we can receive a set with capabilities: futurecallback<exercisecapabilities>() { @override public void onsuccess(@nullable exercisecapabilities result) { try { exercisetypecapabilities exercisetypecapabilities = result.getexercisetypecapabilities(exercisetype); set<datatype> exercisecapabilitiesset = exercisetypecapabilities.getexercisecapabilities(result); } if you do not want to track some of these values, at this point, you can remove them from a set. by default, all datatypes that a certain exercise can measure are being stored as a set. by removing them before setting up a configuration builder, you can exclude tracking unnecessary values. once we are ready, we can finish configuring an exercise: exerciseconfigbuilder = exerciseconfig.builder() .setexercisetype(exercisetype) .setdatatypes(exercisecapabilitiesset); setting up exercise listener an exercise listener is an object that allows us to get exercise updates from health services, whenever they are available. to set up the listener, we need to override three methods: exerciseupdatelistener exerciseupdatelistener = new exerciseupdatelistener() { @override public void onexerciseupdate(exerciseupdate update) { //processing your update } @override public void onavailabilitychanged(datatype datatype, availability availability) { //processing availability } @override public void onlapsummary(exerciselapsummary summary) { //processing lap summary } }; starting and stopping the exercise we are ready to start tracking our exercise. to do that, we use the listenablefuture object that gets callbacks from the healthservices api whenever an update is available. to build this object, we send our configuration to the exercise client while starting measurement: listenablefuture<void> startexerciselistenablefuture = exerciseclient.startexercise(exerciseconfigbuilder.build()); when we get a callback from the healthservices api, we start our listener: listenablefuture<void> updatelistenablefuture = exerciseclient.setupdatelistener(exerciseupdatelistener); we finish exercise in a similar way, by creating a listenablefuture object that asks the health services api to stop tracking exercise: listenablefuture<void> endexerciselistenablefuture = exerciseclient.endexercise() processing exercise update data exercise update data contains various information about the performed exercise. after setting up a listener, we retrieve it in a callback: public void onexerciseupdate(@nonnull exerciseupdate update) { try { updaterepcount(update); } catch (deadliftexception exception) { log.e(tag, "error getting exercise update: ", exception); } } in this example, we focus on one of most important readings—latest metrics. we store them in a map: map<datatype, list<datapoint>> map = update.getlatestmetrics(); now we can read particular values by looking for their key: list<datapoint> reppoints = map.get(datatype.rep_count); list<datapoint> caloriespoints = map.get(datatype.total_calories); the last value on the list is the latest reading in the current update. we can use it in our application, for example, when updating a label: string repvalue = string.format("%d", iterables.getlast(reppoints).getvalue().aslong()); txtreps.settext(string.format("reps count: %s", repvalue)); this is how exercise data can be accessed and processed using health services on galaxy watch. it’s a quick and convenient way to track its progress that everybody can implement into a watch application.

      https://developer.samsung.com/health/blog/en-us/2022/02/16/tracking-exercises-with-galaxy-watch
      1. tutorials | health, galaxy watch

      blog

      Diving into the Client Types in Health Services

      in our using health services on galaxy watch article, we introduced you to health services and the series of steps you need to follow in order to start using it within your application. now, we present the different client types provided by health services and their core functionality. exerciseclient in recent years, many applications that use and process health data are focused on workouts due to increasing awareness of the importance of maintaining a healthy lifestyle. some of those applications are more complex than others and have a lot of features, from tracking exercise performance to setting daily, weekly or monthly goals. health services provides a specialized client to facilitate tracking ongoing workouts from a wide range of exercise types, such as running, playing soccer and skiing, among others. checking the capabilities on the device as mentioned in our previous post, you have to ensure at runtime that your configuration is supported. remember, there is nothing more confusing to users than dealing with an application that does not work as expected. the code below describes how to check the capabilities of the device for an exercise type for running: healthservicesclient healthclient = healthservices.getclient(this); exerciseclient exerciseclient = healthclient.getexerciseclient(); listenablefuture<exercisecapabilities> capabilitiesfuture = passiveclient.getcapabilities(); futures.addcallback(capabilitiesfuture, new futurecallback<exercisecapabilities>() { @override public void onsuccess(@nullable exercisecapabilities result) { runningcapabilities = result .supporteddatatypesexcercise() .contains(exercisetype.running) } @override public void onfailure(throwable t) { // display an error } }, contextcompat.getmainexecutor(this)); tracking workouts using exerciseclient after ensuring that the device running your application supports the type of exercise(s) you want to track, you must specify the relevant information, such as exercise type, exercise goal, and additional parameters supported by health services. health services provides an exerciseconfig class to help you to define a configuration for an exercise tracked by your application. with the help of this class, you can define and have access to information related to the exercise such as: exercise type exercise goals data type of the exercise flags to indicate the exercise state once you set up your configuration, you can start your exercise and then listen for its progress using an update listener. the basic setup flow should be something like: set up exerciseconfig call exerciseclient.startexercise set up an update listener listen for progress and update your app finally, health services provides a useful class to set goals and keep track of them. the exercisegoal class allows you to set goals based on certain parameters, so the users of your application can create milestones or one-time goals. an example of a milestone could be a hiking app that sets a goal that is achieved multiple times when the user has covered a distance of 200m. the event is triggered every 200m. in contrast, a one-time goal could be defined as a goal that sets a milestone with a threshold equivalent to the height of mount everest. the ability to work with exercise goals in health services will be described in more detail in a separate post. note: when using exerciseclient, make sure your app requests and maintains the necessary permissions. if your app uses location data, you should consider permissions on the device, like checking that gps is enabled. also, you should ensure that a foregroundservice with the appropriate foregroundservicetype is maintained throughout the workout, as shown in the code below: <!-- add foreground service location permission for exercise tracking --> <service android:name=".exerciseservice" android:foregroundservicetype="location" android:exported="false" /> measureclient using this client is highly recommended if your application requires constant updates. in a real-world scenario, your application should use this client when its ui is in the foreground. as a good practice, your application should minimize the amount of time reading data with this client. registering callbacks to read health data can increase sensor sampling rates, increasing power consumption. use this client carefully, having user experience in mind and taking into account that users want to extend the power of the device as much as possible. checking the capabilities on the device healthservicesclient healthclient = healthservices.getclient(this); listenablefuture<measurecapabilities> capabilitiesfuture = healthclient.getcapabilities(); futures.addcallback(capabilitiesfuture, new futurecallback<capabilities>() { @override public void onsuccess(@nullable capabilities result) { boolean supportsheartrate = result .supporteddatatypesmeasure() .contains(datatype.heart_rate_bpm) } @override public void onfailure(throwable t) { // handle error here. } }, contextcompat.getmainexecutor(this)); passivemonitoringclient this client is suitable for applications that monitor health data in the background. this client makes it easier to keep track of activities during longer periods of time, taking advantage of the fact that it does not require your application to be in the foreground. some examples of activities tracked by this client are step count or floors climbed during the day, week or month. checking the capabilities on the device healthservicesclient healthclient = healthservices.getclient(this); passivemonitoringclient passiveclient = healthclient.getpassivemonitoringclient(); listenablefuture<passivemonitoringcapabilities> capabilitiesfuture = passiveclient.getcapabilities(); futures.addcallback(capabilitiesfuture, new futurecallback<passivemonitoringcapabilities>() { @override public void onsuccess(@nullable passivemonitoringcapabilities result) { supportsheartrate = result .getsupporteddatatypespassivemonitoring() .contains(datatype.heart_rate_bpm) supportsstepsevent = result .supporteddatatypesevents() .contains(datatype.steps) } @override public void onfailure(throwable t) { // display an error } }, contextcompat.getmainexecutor(this)); choosing the right health services client having a clear understanding of every client type and their applications help you to make informed decisions when creating your application. this information helps you avoid unexpected results while interacting with the sensors on the device and it improves the overall user experience of your application. receiving health data updates in the background to receive data updates in the background, your application must have a broadcastreceiver declared in its androidmanifest.xml, as we mentioned in our previous post. the updates from health services regarding passive data is delivered to this receiver. so far, we have presented the key features for every client. you can make a more informed and confident decision of how to make the most of health services within your application. we encourage you to check health services to take advantage of all of these features.

      https://developer.samsung.com/health/blog/en-us/2022/01/18/diving-into-the-client-types-in-health-services
      1. tutorials | health, galaxy watch

      blog

      Exercise statistics monitoring

      tracking exercise progress throughout its duration can be a problematic task requiring a lot of work from the developer. health services available on a samsung galaxy watch provide a precise and convenient way to gather statistics. in this blog post we cover different ways to gather exercise data. we created an example application called exercise monitor which gathers statistics about your heart rate and speed while running on a treadmill. in the application we use two ways to gather statistics: statisticaldatapoint for speed and manual heart rate tracking for comparison. you can download it here. we also include an example in this blog using cumulativedatapoint to gather statistics. the basics of connecting to health services are covered in the blog using health services on galaxy watch. let's start by setting up your exercise then continue by working with the exercise data. tracking data with statisticaldatapoint to obtain a statisticaldatapoint object, we need to read aggregated metrics in the exercise configuration builder: exercisecapabilitiesset = result.getexercisetypecapabilities(exercisetype).getsupporteddatatypes(); exerciseconfigbuilder = exerciseconfig.builder() .setexercisetype(exercisetype) .setdatatypes(exercisecapabilitiesset) .setaggregatedatatypes(exercisecapabilitiesset); after that we can read these metrics from exerciseupdate: map<datatype, aggregatedatapoint> aggregatemap = update.getlatestaggregatemetrics(); then we have to read the appropriate datatype from the map. in this case—speed: aggregatedatapoint aggregatespeed = aggregatemap.get(datatype.speed); the aggregatedatapoint object that is obtained can be an instance of two classes—either statisticaldatapoint or cumulativedatapoint (which we cover later): statisticaldatapoint sdpspeed = (statisticaldatapoint) aggregatespeed; from there we can easily read all important statistical data: double minspeed = sdpspeed.getmin().asdouble(); double maxspeed = sdpspeed.getmax().asdouble(); double avgspeed = sdpspeed.getaverage().asdouble(); and use them however we like in the application, for example updating text on labels: txtminspeed.settext(string.format("min speed: %.1f km/h", minspeed)); txtmaxspeed.settext(string.format("max speed: %.1f km/h", maxspeed)); txtavgspeed.settext(string.format("average speed: %.1f km/h", avgspeed)); that’s all we need to do—easy to read and fast to implement. in this case we have only read exercise data, but statistics can be obtained from other health services areas as well. tracking data manually now let's compare tracking data with statisticaldatapoint to tracking heart rate manually. first we need to create appropriate global variables required to track data—especially for the average heart rate that requires information about count samples we gather throughout exercising: double hrmin = 1000, hrmax = 0, hrsum = 0; int hrcount = 0; since our application assumes that we can exercise multiple times, we need to reset these global variables each time we stop and start an exercise. therefore, we need a separate function that resets the variables each time we start an exercise: void init() { hrcount = 0; hrmin = 1000; hrmax = 0; hrsum = 0; txtminhr = binding.txtminhr; txtminspeed = binding.txtminspeed; txtmaxhr = binding.txtmaxhr; txtmaxspeed = binding.txtmaxspeed; txtavghr = binding.txtavghr; txtavgspeed = binding.txtavgspeed; } we are ready to work on reading data from exerciseupdate. first we get the latest readings: map<datatype, list<datapoint>> datamap = update.getlatestmetrics(); then we read heartrate datatype from the map: list<datapoint> hrpoints = datamap.get(datatype.heart_rate_bpm); this returns a list of heart rates registered since the previous exerciseupdate callback. we have to iterate through every element and compare its values to our statistical points: for (int i = 0; i < hrpoints.size(); i++) { double curval = hrpoints.get(i).getvalue().asdouble(); if (curval == 0) continue; hrcount++; hrsum += curval; if (curval < hrmin) hrmin = curval; if (curval > hrmax) hrmax = curval; } this covers min and max values. as for the average, we have to remember that not every exerciseupdate may contain heart rate readings. if it doesn’t, we need to prevent division by 0: if (hrcount == 0) return; double avghr = hrsum / hrcount; now we are ready to update our text labels—with the exception of the minimum heart rate. if there were no readings, we leave it at 0 instead of updating it to the initialized value: txtavghr.settext(string.format("average hr: %.0f bpm", avghr)); if (hrmin < 1000) txtminhr.settext(string.format("min hr: %.0f bpm", hrmin)); txtmaxhr.settext(string.format("max hr: %.0f bpm", hrmax)); tracking data with cumulativedatapoint the third option to gather data statistics is using cumulativedatapoint. it is not used in the exercise monitor sample application, but we present an example application in this post. one example cumulativedatapoint can be used for is repetition statistics, like counting deadlift or dumbbell curl repetitions throughout sets. we start similarly to statisticaldatapoint by gathering the latest aggregate metrics. but, this time we read the repetition count and cast it to cumulativedatapoint: map<datatype, aggregatedatapoint> aggregatemap = update.getlatestaggregatemetrics(); cumulativedatapoint cdprepetitions = (cumulativedatapoint) aggregatereps; now we can measure total repetitions done throughout sets, as well as the workout start and end time: long totalreps = cdprepetitions.gettotal().aslong(); instant starttime = cdprepetitions.getstarttime(); instant endtime = cdprepetitions.getendtime(); enjoy your adventure creating an application that will track anything you want! we have shown you three ways of gathering exercise statistics. we encourage you to use statisticaldatapoint or cumulativedatapoint whenever possible, as they are well-designed to track exercise progress and might significantly simplify development of your fitness app. now you are ready to start gathering aggregated exercise statistics using health services data in the background in your application on galaxy watch with wear os powered by samsung. we encourage you to experiment on your own with data you wish to track and exercises you want to perform and see how easy and convenient it is!

      https://developer.samsung.com/health/blog/en-us/2022/06/22/exercise-statistics-monitoring
      1. featured | web, mobile, galaxy watch

      blog

      Browsing the Web on the Samsung Galaxy Watch4

      the new samsung galaxy watch4 is my first smartwatch in a long time. the smaller model is small enough to fit on my wrist and it’s powerful enough to take over from my phone for small tasks. by far the most used app on my phone is the web browser. obviously i use the samsung internet web browser (which in my opinion is clearly the best) and now my watch can run it too. most web browser apps on smart watches run tethered to a device which sends over pictures of the web pages you browse but not samsung internet for the galaxy watch4. here samsung internet runs entirely on the watch itself totally independently of the smart phone. installing the browser you can install the watch version of the browser from the main samsung internet page on the galaxy store or google play store: https://galaxy.store/internet and the performance is superb! the first thing i tried after installing the browser is running is one of my more complex webgl tests to see if it would even run at all. and not only does it run! it runs at 60fps with no glitches! at the request of a friend on twitter i ran one of his demos which had a frame rate counter which let us confirm the 60fps rate of the display!! the next demo i tried was the aframe.io home page to see if the gyroscope works (spoiler: it does). i tried to run a webgl benchmark test but the screen was too small it didn’t want to start the test because it assumed the device isn’t in landscape mode. compatibility testing the watch is a chromium based browser so it should score highly on https://html5test.com/ and it does. it scores 518 points, whereas latest desktop chrome scores 528 points. so incredible web compatibility. a smart watch running html5 test and getting 518 points. in the background is another web page getting 528 points. the user interface the easiest way to open a web page is to search for it, the modes for entering text are handwriting on the watch face’s touch pad, a t9 keyboard or voice recognition. i grew up in the 90s so for me the t9 keyboard is fastest but depending on what you are used to voice or handwriting maybe easier. it’s still the very first version so there is not a lot of integration with the phone browser yet but stay tuned — ux improvements are coming in future versions.

      Ada Rose Cannon

      https://developer.samsung.com/internet/blog/en-us/2021/10/25/browsing-the-web-on-the-samsung-galaxy-watch4
      1. tutorials | galaxy watch, health

      blog

      Check Which Sensor You Can Use in Galaxy Watch Running Wear OS Powered by Samsung

      samsung has introduced galaxy watch4, a new wearable device that is integrated with google’s wear os, unleashing a new era of wearable technology. the device’s vast sensor lineup provides the user with everyday health related data, resulting in better user experiences and improved capabilities. sensors are one of the main attractions for all developers of wearable applications. there are two special cases that can happen during sensor implementation. firstly, a device may or may not support a particular sensor. secondly, some sensors may not be accessible by third-party applications on a particular device. therefore, you need to check whether a particular sensor is accessible or not before launching the application. if the application cannot receive data from a particular sensor, you must inform the user. the application layout can also be modified for a better user experience. the body sensors of wearable devices provide highly advanced data that helps to monitor the condition of the human body. health applications collect health data from these sensors. the body_sensors package allows an application to access body sensors, such as heart rate. although wear os android apis are available for galaxy watch4, you might be unsure if specific body sensor data is accessible for your application on galaxy watch. in this article, i show you how to check if a particular body sensor is accessible on galaxy watch4. get started in the following example, i develop a wearable app for galaxy watch4 that shows whether a particular sensor is accessible or not. environment wear os applications have to be developed using the android studio ide. here, i am assuming you have already successfully installed android studio on your pc. to start developing a new wearable application, open android studio and select new project > wear os > blank activity > finish. the new application project is now ready for you to create your application. step-by-step example of checking sensor accessibility step 1: galaxy watch4 only supports api level 28 and above. therefore, you need to set the target api level at 28 or higher to develop a wearable application for it. to do this, you can set the minimum sdk version while creating your project, or you can modify the value in build.gradle > minsdk after the project has been created. step 2: the most important part of sensor implementation is to set the appropriate permission. to do this, you have to add the body_sensors permission in the android manifest. <uses-permission android:name="android.permission.body_sensors" /> step 3: starting from android version 6 (api level 23), an application has to request runtime permission from the user to access any sensor data. if the user grants the permission, the application is then able to access the data. add the following code to the oncreate() method to request user permission: if (checkselfpermission(manifest.permission.body_sensors) != packagemanager.permission_granted) { requestpermissions( new string[]{manifest.permission.body_sensors}, 1); } else { log.d(tag, "already granted"); } in the output, a pop-up is shown while installing the application for the first time. if the user selects “allow,” the application gets permission to access the body_sensors library information and the pop-up does not reappear when the application is launched again. if the user selects “deny,” the application is not able to get the sensor data. figure 1: sensor data access permission requested from the user during installation for more details about runtime permissions, check here. note : to use the step counter or step detector sensor, you also need the activity_recognition runtime permission. for more information, you can check the following links: https://developer.android.com/guide/topics/sensors/sensors_motion#sensors-motion-stepcounter https://developer.android.com/guide/topics/sensors/sensors_motion#sensors-motion-stepdetector step 4: import the following libraries to access sensor data in the java class: import android.hardware.sensor; import android.hardware.sensormanager; you can also press alt + enter when selecting a particular function to import the required packages automatically. step 5: create an object of the sensormanager class and instantiate it: sensormanager msensormanager = ((sensormanager)getsystemservice(sensor_service)); step 6: to check the list of sensors integrated with galaxy watch4, add the following code: list<sensor> sensors = msensormanager.getsensorlist(sensor.type_all); arraylist<string> arraylist = new arraylist<string>(); for (sensor sensor : sensors) { arraylist.add(sensor.getname()); } arraylist.foreach((n) -> system.out.println(n)); output of the above code snippet: figure 2: list of available sensors in logcat (partial view) in the output, you can see all the sensors available in galaxy watch4 (but remember that sensors which appear in the logcat output may not be accessible for third-party developers) and you can also see the names of private sensors integrated within the watch. some particular sensors are only accessible from third-party applications. note that the only real, hardware sensors in galaxy watch4 are the accelerometer, gyroscope, pressure, light, magnetic, and heart rate sensor (ppg). all other sensors are composites of actual hardware sensors. for example, the pedometer sensor combines data from the accelerometer and gyroscope sensors. the legacy sensormanager apis only work for real physical sensors; composite sensors will not work. step 7: check the accessibility of a particular sensor using the following code: if ((msensormanager.getdefaultsensor(sensor.type_heart_rate)) != null) { // if the sensor is accessible, then do something } else { // if the sensor is inaccessible, then do something } if the sensor is not accessible on galaxy watch4 from a third-party application, the method returns a null value. in this example, we have checked the heart rate sensor using the sensor.type_heart_rate api. you can check any other sensor by placing your sensor type in this function. note that the above process is a way of getting raw sensor data directly from the watch. if you want to get processed sensor data using an api, you can use the samsung privileged health sdk instead. moreover, as all sensors are not open for third-party developers and only the actual physical sensors are accessible using sensormanager, it is recommended to use the samsung privileged health sdk. through this sdk, you can also get some rare sensor data (processed) like spo2, body composition, ecg, ppg and so on, which is not accessible through sensormanager. testing you can check out the sample app (download it using the link below) and try it out on your galaxy watch4. check sensor availability (408kb) to import the sample application, open android studio and go to file > open > checksensoravailability > build.gradle. to run the sample application, connect your galaxy watch4 with your pc and run the application. make sure the usb debugging is set to on in your watch. in this sample application, we have checked four sensors. here, the heart rate and pressure sensors (marked in green) are accessible from a third-party application on galaxy watch4. the other two sensors, proximity and heartbeat (marked in red), are not accessible. figure 3: output of the sample application on galaxy watch4 conclusion we have demonstrated a way you can check the accessibility of sensors on galaxy watch4. if you want to develop any wearable app for wear os devices using body sensor data, it is recommended to first check if the data is accessible to third-party applications on the device.

      Shamima Nasrin

      https://developer.samsung.com/sdp/blog/en-us/2022/05/25/check-which-sensor-you-can-use-in-galaxy-watch-running-wear-os-powered-by-samsung
      No Search Results
      No Search results. Try using another keyword.
      • <<
      • <
      • 1
      • 2
      • 3
      • 4
      • 5
      • >
      • >>
      Samsung Developers
      Samsung Developers
      Quick Link
      • Android USB Driver
      • Code Lab
      • Galaxy Emulator Skin
      • Foldables and Large Screens
      • One UI Beta
      • Remote Test Lab
      • Developer Support
      Family Site
      • Bixby
      • Knox
      • Samsung Pay
      • SmartThings
      • Tizen
      • Samsung Research
      • SamsungOpen Source
      • Samsung Dev Spain
      • Samsung Dev Brazil
      Legal
      • Terms
      • Privacy
      • Open Source License
      • Cookie Policy
      Social Communications
      • Facebook
      • Instagram
      • Twitter
      • YouTube
      • Buzzsprout
      • Rss
      • Linkedin
      • System Status
      • Site Map
      • System Status
      • Site Map
      • facebook
      • instagram
      • twitter
      • youtube
      • buzzsprout
      • rss
      • linkedin

      Copyright © 2023 SAMSUNG. All rights reserved.