Search

Filter

Blog 100
Sorry, no results
found for "Blog" on the website

tutorials game, mobile

blog

New Game Changing Vulkan Extensions for Mobile: Buffer Device Address

the samsung developers team works with many companies in the mobile and gaming ecosystems. we're excited to support our partner, arm, as they bring timely and relevant content to developers looking to build games and high-performance experiences. this vulkan extensions series will help developers get the most out of the new and game-changing vulkan extensions on samsung mobile devices. android r is enabling a host of useful vulkan extensions for mobile, with three being key 'game changers'. these are set to improve the state of graphics apis for modern applications, enabling new use cases and changing how developers can design graphics renderers going forward. you can expect to see these features across a variety of android smartphones, such as the new samsung galaxy s21, and existing samsung galaxy s models like the samsung galaxy s20. the first blog explored the first game changer extension for vulkan – ‘descriptor indexing'. this blog explores the second game changer extension – ‘buffer device address.’ vk_khr_buffer_device_address vk_khr_buffer_device_address is a monumental extension that adds a unique feature to vulkan that none of the competing graphics apis support. pointer support is something that has always been limited in graphics apis, for good reason. pointers complicate a lot of things, especially for shader compilers. it is also near impossible to deal with plain pointers in legacy graphics apis, which rely on implicit synchronization. there are two key aspects to buffer_device_address (bda). first, it is possible to query a gpu virtual address from a vkbuffer. this is a plain uint64_t. this address can be written anywhere you like, in uniform buffers, push constants, or storage buffers, to name a few. the key aspect which makes this extension unique is that a spir-v shader can load an address from a buffer and treat it as a pointer to storage buffer memory immediately. pointer casting, pointer arithmetic and all sorts of clever trickery can be done inside the shader. there are many use cases for this feature. some are performance-related, and some are new use cases that have not been possible before. getting the gpu virtual address (va) there are some hoops to jump through here. first, when allocating vkdevicememory, we must flag that the memory supports bda: vkmemoryallocateinfo info = {…}; vkmemoryallocateflagsinfo flags = {…}; flags.flags = vk_memory_allocate_device_address_bit_khr; vkallocatememory(device, &info, null, &memory); similarly, when creating a vkbuffer, we add the vk_buffer_usage_shader_device_address_bit_khr usage flag. once we have created a buffer, we can query the va: vkbufferdeviceaddressinfokhr info = {…}; info.buffer = buffer; vkdevicesize va = vkgetbufferdeviceaddresskhr(device, &info); from here, this 64-bit value can be placed in a buffer. you can of course offset this va. alignment is never an issue as shaders specify explicit alignment later. a note on debugging when using bda, there are some extra features that drivers must support. since a pointer does not necessarily exist when replaying an application capture in a debug tool, the driver must be able to guarantee that virtual addresses returned by the driver remain stable across runs. to that end, debug tools supply the expected va and the driver allocates that va range. applications do not care that much about this, but it is important to note that even if you can use bda, you might not be able to debug with it. typedef struct vkphysicaldevicebufferdeviceaddressfeatures { vkstructuretype stype; void* pnext; vkbool32 bufferdeviceaddress; vkbool32 bufferdeviceaddresscapturereplay; vkbool32 bufferdeviceaddressmultidevice; } vkphysicaldevicebufferdeviceaddressfeatures; if bufferdeviceaddresscapturereplay is supported, tools like renderdoc can support bda. using a pointer in a shader in vulkan glsl, there is the gl_ext_buffer_reference extension which allows us to declare a pointer type. a pointer like this can be placed in a buffer, or we can convert to and from integers: #version 450 #extension gl_ext_buffer_reference : require #extension gl_ext_buffer_reference_uvec2 : require layout(local_size_x = 64) in; // these define pointer types. layout(buffer_reference, std430, buffer_reference_align = 16) readonly buffer readvec4 { vec4 values[]; }; layout(buffer_reference, std430, buffer_reference_align = 16) writeonly buffer writevec4 { vec4 values[]; }; layout(buffer_reference, std430, buffer_reference_align = 4) readonly buffer unalignedvec4 { vec4 value; }; layout(push_constant, std430) uniform registers { readvec4 src; writevec4 dst; } registers; placing raw pointers in push constants avoids all indirection for getting to a buffer. if the driver allows it, the pointers can be placed directly in gpu registers before the shader begins executing. not all devices support 64-bit integers, but it is possible to cast uvec2 <-> pointer. doing address computation like this is fine. uvec2 uadd_64_32(uvec2 addr, uint offset) { uint carry; addr.x = uaddcarry(addr.x, offset, carry); addr.y += carry; return addr; } void main() { uint index = gl_globalinvocationid.x; registers.dst.values[index] = registers.src.values[index]; uvec2 addr = uvec2(registers.src); addr = uadd_64_32(addr, 20 * index); cast a uvec2 to address and load a vec4 from it. this address is aligned to 4 bytes. registers.dst.values[index + 1024] = unalignedvec4(addr).value; } pointer or offsets? using raw pointers is not always the best idea. a natural use case you could consider for pointers is that you have tree structures or list structures in gpu memory. with pointers, you can jump around as much as you want, and even write new pointers to buffers. however, a pointer is 64-bit and a typical performance consideration is to use 32-bit offsets (or even 16-bit offsets) if possible. using offsets is the way to go if you can guarantee that all buffers live inside a single vkbuffer. on the other hand, the pointer approach can access any vkbuffer at any time without having to use descriptors. therein lies the key strength of bda. extreme hackery: physical pointer as specialization constants this is a life saver in certain situations where you are desperate to debug something without any available descriptor set. a black magic hack is to place a bda inside a specialization constant. this allows for accessing a pointer without using any descriptors. do note that this breaks all forms of pipeline caching and is only suitable for debug code. do not ship this kind of code. perform this dark sorcery at your own risk: #version 450 #extension gl_ext_buffer_reference : require #extension gl_ext_buffer_reference_uvec2 : require layout(local_size_x = 64) in; layout(constant_id = 0) const uint debug_addr_lo = 0; layout(constant_id = 1) const uint debug_addr_hi = 0; layout(buffer_reference, std430, buffer_reference_align = 4) buffer debugcounter { uint value; }; void main() { debugcounter counter = debugcounter(uvec2(debug_addr_lo, debug_addr_hi)); atomicadd(counter.value, 1u); } emitting spir-v with buffer_device_address in spir-v, there are some things to note. bda is an especially useful feature for layering other apis due to its extreme flexibility in how we access memory. therefore, generating bda code yourself is a reasonable use case to assume as well. enables bda in shaders. _opcapability physicalstoragebufferaddresses opextension "spv_khr_physical_storage_buffer"_ the memory model is physicalstoragebuffer64 and not logical anymore. _opmemorymodel physicalstoragebuffer64 glsl450_ the buffer reference types are declared basically just like ssbos. _opdecorate %_runtimearr_v4float arraystride 16 opmemberdecorate %readvec4 0 nonwritable opmemberdecorate %readvec4 0 offset 0 opdecorate %readvec4 block opdecorate %_runtimearr_v4float_0 arraystride 16 opmemberdecorate %writevec4 0 nonreadable opmemberdecorate %writevec4 0 offset 0 opdecorate %writevec4 block opmemberdecorate %unalignedvec4 0 nonwritable opmemberdecorate %unalignedvec4 0 offset 0 opdecorate %unalignedvec4 block_ declare a pointer to the blocks. physicalstoragebuffer is the storage class to use. optypeforwardpointer %_ptr_physicalstoragebuffer_writevec4 physicalstoragebuffer %_ptr_physicalstoragebuffer_readvec4 = optypepointer physicalstoragebuffer %readvec4 %_ptr_physicalstoragebuffer_writevec4 = optypepointer physicalstoragebuffer %writevec4 %_ptr_physicalstoragebuffer_unalignedvec4 = optypepointer physicalstoragebuffer %unalignedvec4 load a physical pointer from pushconstant. _%55 = opaccesschain %_ptr_pushconstant__ptr_physicalstoragebuffer_writevec4 %registers %int_1 %56 = opload %_ptr_physicalstoragebuffer_writevec4 %55_ access chain into it. _%66 = opaccesschain %_ptr_physicalstoragebuffer_v4float %56 %int_0 %40_ aligned must be specified when dereferencing physical pointers. pointers can have any arbitrary address and must be explicitly aligned, so the compiler knows what to do. opstore %66 %65 aligned 16 for pointers, spir-v can bitcast between integers and pointers seamlessly, for example: %61 = opload %_ptr_physicalstoragebuffer_readvec4 %60 %70 = opbitcast %v2uint %61 // do math on %70 %86 = opbitcast %_ptr_physicalstoragebuffer_unalignedvec4 %some_address conclusion we have already explored two key vulkan extension game changers through this blog and the previous one. the third and final part of this game changer blog series will explore ‘timeline semaphores’ and how developers can use this new extension to improve the development experience and enhance their games. follow up thanks to hans-kristian arntzen and the team at arm for bringing this great content to the samsung developers community. we hope you find this information about vulkan extensions useful for developing your upcoming mobile games. the samsung developers site has many resources for developers looking to build for and integrate with samsung devices and services. stay in touch with the latest news by creating a free account or by subscribing to our monthly newsletter. visit the marketing resources page for information on promoting and distributing your apps and games. finally, our developer forum is an excellent way to stay up-to-date on all things related to the galaxy ecosystem.

Arm Developers

https://developer.samsung.com/galaxy-gamedev/blog/en-us/2021/07/06/new-game-changing-vulkan-extensions-for-mobile-buffer-device-address

Develop GameDev

web

Galaxy GameDev | Samsung Developers

galaxy gamedev galaxy gamedev provides various technical support options to assist game developers. related materials get support via our technical documents and online resources. galaxy gamedev learn about joining galaxy gamedev and best practices for game developers best practices find useful tips, know-hows and gamedev's stories in our technical blogs adaptive performance adaptive performance provides that way to manage both the thermals and performance of a game on a mobile device gpuwatch gpuwatch is a tool for observing gpu activity in your apps. you can find out how to use it and which devices support it here resources articles, white papers, and interesting code samples for game developers event archive videos and slides of key technical presentations from a variety of developer events what is galaxy gamedev and what do we do? through this program, we collaborate with many key partners in the gaming industry to support game developers with early engagement of new technologies for better gaming experiences read more adaptive performance the adaptive performance package provides an api to get feedback about the thermal and power state of mobile devices, enabling applications to make performance-relevant adaptions at runtime. read more code lab looking for a community? meet other developers. ask questions. find answers. read more

https://developer.samsung.com/galaxy-gamedev/

announcement web

blog

Samsung Internet 12.1

lots of small quality of life improvements one benefit of using samsung internet is regular updates to improve your browsing experience. samsung internet 12.1 focuses on improving the experience on specific devices and improving the tab bar and tab switcher. you can test these out right now by downloading the beta from the galaxy or play stores: there is a new layout on tablet devices to move the toolbar, usually at the bottom on mobile to sit next to the address bar so it behaves like a desktop browser. we’ve also added a new feature for devices which can ‘flex’ like the z flip, shown below. when you are watching video, if you flex the device we will play the video on the top half and the controls on the bottom half giving a lovely viewing experience. the tab bar is a feature which has been present for a few versions. it’s an optional tab bar like you would get in a desktop browser. the tab bar in samsung internet the first new feature is a context menu to let you control your tabs easily without needing to open up the tab switcher: the context menu. the final feature is one i am very excited about which is support for augmented reality websites with the webxr device api. this feature will get an entire blog post on it’s own so stay tuned.

Ada Rose Cannon

https://developer.samsung.com/internet/blog/en-us/2020/07/07/samsung-internet-121

tutorials galaxy watch, health

blog

Workout, a Tizen Sample App for Monitoring Health Sensors

the workout app was created to show how to implement a fully working application that supports running on wearable devices with tizen. workout is written in c# and uses the xamarin.forms and tizen.circularui frameworks. text workout overview this version of the application allows you to measure the following parameters while running: running time distance traveled heart rate pace present effort in the summary of the training, the application also shows the most common range of effort. read more in a series of blogs publishing this week, we will describe and show how key functionalities of the application are implemented, such as: distance traveled heart rate (intensity) workout summary a detailed tutorial describing the application can be found on tizenschool.org distance intensity you can download and test the app from the link below: https://github.com/samsung/tizen-csharp-samples/tree/master/wearable/workout in the next release of the application, it will collect workout data and give an insight into the history. it will also allow you to edit user profile settings such as age or the distance measurement unit. if you have an idea for functionality or have any comments about the application, let us know!

Patryk Falba

https://developer.samsung.com/tizen/blog/en-us/2020/09/04/workout-a-tizen-sample-app-for-monitoring-health-sensors

Develop Galaxy Themes

web

Galaxy Themes | Samsung Developers

galaxy themes design ui themes for galaxy mobile devices using themes studio and sell to the world, all without coding. get started get started what is galaxy themes? galaxy themes is a premium decorative content service available on samsung galaxy device all around the world. the galaxy themes studio tool helps designers to create compelling ui experience and content easily. become a themes designer new theme designers to become a themes designer, you must submit an application with at least three mock-up theme designs. applications are only accepted during certain times of the year, the themes submission open window. your design will be reviewed by the themes team, and if approved you will receive access to galaxy themes studio. learn more already a partner? already an approved samsung themes partner? click the link below to access the themes partner page. partner page learn from the pros! here's tony morelan, senior developer advocate at samsung developers, describing how to create and submit galaxy themes. video thumbanil in-depth learning go to blogs find technical content written by professional designers and developers looking for a community? meet other designers. ask questions. find answers. read more

https://developer.samsung.com/galaxy-themes/

tutorials game, web, mobile

blog

Developing Mobile Games with Phaser

phaser is an excellent option for game developers that want to reach different platforms using their front-end skills. it is the most popular javascript-based gaming framework and, because it is open-source, it has additional plugins, samples, and snippets shared by the developer community. this is the first in a series of blog posts that will include short and helpful videos that will guide you through creating your first video game with phaser. in this video we will cover of what is phaser, where to download it and the minimum requirements to start developing your games with it. in upcoming videos we will cover basic concepts, so you can build games from zero and adapt them to your own style and needs. i will focus on games for mobile devices that will be able to publish in the samsung galaxy store, but you can easily adapt these topics to any web or desktop games. useful links phaser’s official page download phaser photonstorm’s github repository documentation phaser’s discord community over 1500 examples follow up this site has many resources for developers looking to build for and integrate with samsung devices and services. stay in touch with the latest news by creating a free account or by subscribing to our monthly newsletter. visit the marketing resources page for information on promoting and distributing your apps. finally, our developer forum is an excellent way to stay up-to-date on all things related to the galaxy ecosystem.

Diego Lizarazo Rivera

https://developer.samsung.com/sdp/blog/en-us/2021/04/07/developing-mobile-games-with-phaser

announcement mobile, marketplace, galaxy watch, game, ai, design

blog

Save the Date for the 2020 Best of Galaxy Store Awards

the 2020 best of galaxy store awards are just around the corner. for the first two years, these awards were announced during the annual samsung developer conference. however, the awards show has moved online for 2020 which means more people can tune in to see who this year's winners are. the best of galaxy store awards recognize the top games, apps, themes, watch faces, and new this year, bixby capsules. last month, in the season one finale of the samsung developers podcast we talked about the history of the awards, past highlights of previous awards, exciting new changes to galaxy store, and our upcoming 2020 best of galaxy store awards show. be sure to tune in and listen. curious what makes our past winners stand out? we have interviewed a number of past winners on our blog. read what inspires them and what their tips are for finding success on galaxy store. get a sneak peak of this year's awards and save the date for wednesday, decemeber 9 at 5pm pst. the awards show will premiere on our youtube channel so be sure to subscribe and hit the notification bell.

Lori Fraleigh

https://developer.samsung.com/sdp/blog/en-us/2020/11/10/save-the-date-for-the-2020-best-of-galaxy-store-awards

news uiux, design, mobile, galaxy watch, marketplace

news

October Design Submission Window is Now Open for Galaxy Devices

looking to show off your design chops? you can now submit your portfolio to samsung and apply to become a galaxy watch face or galaxy themes seller. the submission window is open october 14 - october 27. galaxy watch check out our latest how-to blog and read up on the new process for watch face design reviews. then head over to the submission page and complete your application. galaxy themes watch our video for an overview of the process and what you need to prepare. then download the themes submission starter kit and let the creative juices flow. once you've assembled everything, complete your application here. while you're working on your portolfio, listen to tony show diego how to use galaxy themes studio. it will livestream on thursday, october 15 at 10am pt and will be available on youtube for replay. submit now the application process is very selective, and only the best of the best are selected. think you have what it takes? we can't wait to find out.

https://developer.samsung.com/sdp/news/en-us/2020/10/14/october-design-submission-window-is-now-open-for-galaxy-devices

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

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 introducing you to the 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. 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. figure 1: samsung health on galaxy watch and android smartphone health connect since the samsung health application supports various useful health data types and gathers data from all connected devices, developers have been interested in obtaining access to that data. 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. 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. notesince android 14, health connect is a system application and is supported by the health connect api versions 1.1.0 and higher. make sure your samsung health application version is up to date, to enable support for the latest health connect features. for more information on health connect as a system application, see: migrate health connect. 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. figure 2: accessing samsung health data through health connect 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, tap get started. figure 3: get started screen you are asked to grant permissions to share your samsung health data with health connect. select the data you consent to sharing and tap allow. note“read” and “write” permissions are granted separately. figure 4: data sharing consent 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. figure 5: nutrition data input 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. figure 6: synchronized nutrition data to view the synchronized data, select nutrition. figure 7: nutrition data in health connect 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. figure 8: data synchronization between watch and smartphone 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 application. if you're interested in galaxy watch's data, check its version too. allowing required data permissions in health connect through the following path: samsung health > settings > health connect noteif you allow permissions in the android phone's settings > search "health connect" > health connect > app permissions > samsung health, launch the samsung health application after granting the permissions. synchronizing samsung health data in: samsung health > settings > sync with samsung cloud > switch to 'on'. 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. notefor 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 health connect data type all steps stepsrecord blood glucose bloodglucoserecord blood oxygen oxygensaturationrecord blood pressure bloodpressurerecord exercise, session exercisesessionrecord exercise, calories totalcaloriesburnedrecord exercise, distance distancerecord exercise, heart rate heartraterecord exercise, power powerrecord exercise, speed speedrecord exercise, vo2max vo2maxrecord heart rate heartraterecord nutrition nutritionrecord sleep session sleep stage sleepsessionrecord weight weightrecord weight, body fat bodyfatrecord weight, basial metabolic rate basalmetabolicraterecord weight, height heightrecord notea synchronized data scope can be changed depending on the samsung health version. notethe health connect's total calories burned, distance, power, speed, and vo2max in the table above are matched with the samsung health exercise tracker's data. the samsung health’s activity tracker data are not synchronized with health connect. to get started with implementing health connect api functionality in your application: add the latest version of the health connect api library dependencies to your application's "build.gradle" file, for example: implementation "androidx.health.connect:connect-client:1.1.0-alpha10" declare the health connect package name in your "androidmanifest.xml" file. 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 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/accessing-samsung-health-data-through-health-connect

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.