Search

Filter

ExerciseClient 4
Sorry, no results
found for "ExerciseClient" on the website

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

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

Learn Code Lab

codelab

Track Deadlift Exercise on Galaxy Watch

track deadlift exercise on galaxy watch objective create a native app for galaxy watch, operating on wear os powered by samsung, using health services to track deadlift exercise this app measures repetition count, calories burned, and time spent during the exercise overview health services provides a simple and unified way for accessing a wide range of health and wellness related data with health services api, you will no longer need to develop your own algorithms processing sensors data in order to compute metrics like heart rate, steps counts, distance, calories burned, and other more these are now accessible through health services embedded on wearables operating on wear os powered by samsung see health platform descriptions for detailed information set up your environment you will need the following galaxy watch4 or newer android studio latest version recommended java se development kit jdk 11 or later sample code here is a sample code for you to start coding in this code lab download it and start your learning experience! health track deadlift sample code 132 83 kb turn on developer mode and adjust its settings on your watch, go to settings > about watch > software and tap on software version 5 times upon successful activation of developer mode, a toast message will display as on the image below afterwards, developer options will be visible under settings tap developer options and enable the following options adb debugging debug over wi-fi turn off automatic wi-fi connect your galaxy watch to wi-fi go to settings > connection > wi-fi and make sure that wi-fi is enabled from the list of available wi-fi networks, choose and connect to the same one as your pc when successfully connected, tap a wi-fi network name, swipe down, and note the ip address you will need this to connect your watch over adb from your pc connect your galaxy watch to android studio in android studio, go to terminal and type adb connect <ip address as mentioned in previous step> when prompted, tap always allow from this computer to allow debugging upon successful connection, you will see the following message in android studio’s terminal connected to <ip address of your watch> now, you can run the app directly on your watch start your project after downloading the sample code containing the project files, open your android studio and click open to open an existing project locate the downloaded android project deadlift from the directory and click ok check dependency and app manifest in the dependencies section of gradle scripts > build gradle module app file, see the appropriate dependency for health services dependencies { implementation 'androidx health health-services-client 1 0 0-beta03' // } notesince the library might update from time to time, it is recommended to choose the version suggested by android studio in androidmanifest xml file, note the following <queries> element <queries> <package android name="com google android wearable healthservices" /> </queries> section with requests for necessary permissions <uses-permission android name="android permission body_sensors" /> <uses-permission android name="android permission activity_recognition" /> check capabilities to check what can be measured during an exercise, you need to check its capabilities go to app > java > com samsung sdc21 deadlift open the deadliftutil java file and navigate to the checkcapabilities method an inner class c definition implements the methods of the futurecallback interface within this definition, define the onsuccess method to retrieve the exercise type capabilities public void onsuccess exercisecapabilities result { objects requirenonnull result ; log i tag, "got exercise capabilities" ; /*********************************************************************************** * [practice 1] define the onsuccess method * * - hint uncomment lines below and replace todo 1 * call getexercisetypecapabilities method of result object, * passing already initialized t as an argument **********************************************************************************/ final exercisetype t = exercisetype deadlift; // final exercisetypecapabilities capabilities = "todo 1" // final exerciseconfig builder builder = exerciseconfig builder t ; // builder setdatatypes capabilities getsupporteddatatypes ; // exerciseconfigbuilder = builder; } next, implement the findcapabilitesfuture method to get a callback with exercisecapabilities getcapabilitiesasync returns the exercisecapabilities of the exerciseclient for the device static listenablefuture<exercisecapabilities> findcapabilitiesfuture exerciseclient client { /******************************************************************************************* * [practice 1] create a listenablefuture object that will get a callback with * with exercise capabilities choose the correct method from exerciseclient * * - hint uncomment line and replace null with todo 2 * for checking capabilities use getcapabilitiesasync method ******************************************************************************************/ return null; //"todo 2"; } start the exercise inside the startexercise method, there is a call to the futures addcallback method this method adds a callback function that executes when the asynchronous operation of starting the exercise completes set an update callback for the exercise client within the onsuccess method of the callback function public void onsuccess void result { log i tag, "successfully started" ; /*************************************************************************** * [practice 2] set an update callback * * - hint uncomment lines below and fill todos * 1 make appropriate call of setupdatecallback method * and pass exerciseupdatelistener object as an argument * 2 change ismeasurementrunning flag value to true **************************************************************************/ // exerciseclient setupdatecallback "todo 3 1 " ; log i tag, "successfully set update listener" ; // "todo 3 2 " } in the deadlift java file, call the startexercise method in onbuttonclickhelper public void onbuttonclickhelper { /******************************************************************************************* * [practice 2] start the exercise using a method from deadliftutil java * * - hint uncomment line below and fill todo 4 * call startexercise method on util object * ****************************************************************************************/ // "todo 4" } get the results go to the deadliftutil java file, and in the getnewrepsvalue method, call the getlatestmetrics method from the exerciseupdate class to get the data collected during the exercise store the data in the resultlist, where the last element holds the most up-to-date value of all your repetitions public long getnewrepsvalue exerciseupdate update, deltadatatype<long, intervaldatapoint<long>> datatype { /******************************************************************************************* * [practice 3] get the data collected during exercise * * - hint uncomment lines below and fill todo 5 * call getlatestmetrics method of exerciseupdate object * then, get the data of appropriate type * for this, you can use dedicated method getdata , passing datatype as an argument * ****************************************************************************************/ // final list<intervaldatapoint<long>> resultlist = "todo 5" // if !resultlist isempty { // final int lastindex = resultlist size - 1; // return resultlist get lastindex getvalue ; // } return no_new_value; } run unit tests for your convenience, you will find an additional unit tests package this will let you verify your code changes even without using a physical watch see instruction below on how to run unit tests right click on com samsung sdc21 deadlift test > deadliftunittest and execute run 'deadliftunittest' command if you completed all the tasks correctly, you will see all the unit tests passed successfully run the app after building the apk, you can run the application on a connected device to measure actual deadlift parameters right after the app is started, it will request for the user permission allow the app to receive data of the activity afterwards, the application main screen will be shown before doing deadlifts, press the start button to track your exercise when done, tap on the stop button you're done! congratulations! you have successfully achieved the goal of this code lab now, you can create a deadlift exercise tracker app by yourself! if you're having trouble, you may download this file health track deadlift complete code 132 42 kb learn more by going to health platform

https://developer.samsung.com/codelab/health/deadlift-tracker.html

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

Didn’t find what you were looking for?

FAQ

Search frequently asked
questions
by keywords.

Join the Forum

Visit the Forum to ask
questions and exchange
ideas with other developers.

Get Support

Submit a 1:1 Support request
and receive a response
within 2 business days.

Preferences Submitted

You have successfully updated your cookie preferences.