samsung privileged health sdk the galaxy watch is equipped with samsung’s unique bioactive sensor that drives the next era of digital health monitoring. first introduced on the galaxy watch4 series, the bioactive sensor uses a single unique chip that combines three powerful health sensors — optical heart rate, electrical heart signal, and bioelectrical impedance analysis — to deliver extensive readings that include heart rate and blood oxygen level. what is samsung privileged health sdk the samsung privileged health sdk is specialized for galaxy watch4 devices or later. it provides both raw sensor signal data from the samsung bioactive sensor and processed data with our differentiated features. the sdk supports an improved health tracking capability to allow your applications to track the user's health data accurately with the accelerometer, raw ecg (electrocardiogram), ppg (photoplethysmogram), and heart rate including inter-beat interval. in addition, it provides more advanced health features such as the body composition measurement, to enable compelling use cases for health and fitness applications. the blood oxygen level and sweat loss after a running workout are also useful data to check a user's health status. what you can do a watch application using the samsung privileged health sdk runs on a galaxy watch with wear os powered by samsung. it will help users to monitor their overall health data and to provide an advanced healthy life. the sdk can be utilized in various fields such as fitness, remote patient monitoring, senior care, digital therapy, fatigue risk management, and corporate wellness. what are the advantages let's review more advantages of the samsung privileged health sdk. low watch battery consumption the samsung privileged health sdk's accelerometer data, ppg green data, and heart rate data are all received as a batching event. the sdk's batching operation gathers sensor data in an application processor without waking up the cpu and sends an event at specific periods to a watch application. this minimizes the watch's battery consumption and enables a watch application to track the user's status for the entire day. receiving raw sensor data the accelerometer, ecg, and ppg green data are provided as raw data by the samsung privileged health sdk. this is very useful to conduct various analyses and more in-depth research with your own algorithm. using galaxy watch specific features measuring the user's body composition, blood oxygen level, heart rate including the inter-beat interval, and sweat loss after a running workout is a feature specific to the galaxy watch. using the privileged health sdk, your watch application can easily measure these data. what data is provided the following data types are supported by the samsung privileged health sdk: data type details accelerometer raw x, y, and z axis data. provided as a batching event. bia body composition data. provided as an on-demand event. ecg raw electrocardiogram data. provided as an on-demand event. heart rate heart rate data, including inter-beat interval. provided as a batching event. ppg green raw data from ppg green led. provided as a batching event. ppg ir raw data from ppg infrared led. provided as an on-demand event. ppg red raw data from ppg red led. provided as an on-demand event. skin temperature skin temperature data. provided as a batching and on-demand events. spo2 blood oxygen level. provided as an on-demand event. sweat loss lost water amount after a running workout. provided as an on-demand event. experience samsung privileged health sdk you can practice using the samsung privileged health sdk with our code labs. visit code lab to get started. code labgalaxy watch, health measure blood oxygen level on galaxy watch code labgalaxy watch, health measure blood oxygen level and heart rate on galaxy watch code labgalaxy watch, health measure skin temperature on galaxy watch code labgalaxy watch, health transfer heart rate data from galaxy watch to a mobile device partner app program our partner app program is an exclusive service for the samsung privileged health sdk that allows users to discover engaging health and fitness applications. the samsung privileged health sdk is now available for selected partners and we are reviewing all applications to join. apply for partner app program restrictions the samsung privileged health sdk only works on galaxy watch4 devices or later models running wear os powered by samsung. samsung privileged health sdk does not support an emulator. more content

session wearable, design, android watch face studio's first journey and expectation for next a must-have to create beautiful watch faces! watch face studio (wfs) is now a little over a year old. hear the developers of wsh share the highs and lows of bringing the tool to life and meet the designers responsible for creating the eco watch face. this session is an insight into the year-long journey to create wfs – and the story of where we’re going next. speakers chulheon jeong samsung electronics related video video link video link watch face studio with dark mode create a beautiful watch face that is refined and provides a more comfortable viewing experience in low-light situations. code lab sdc22 apply conditional lines on watch faces learn how to create a watch face that responds to time and notification using conditional lines in watch face studio. 20 mins start sdc22 create a watch face using tag expressions learn how to create a watch face that responds based on the date, time, step count, heart rate, and battery level using tag expressions in watch face studio. 60 mins start

session health, wearable expand health experiences with galaxy watch the galaxy watch’s powerful bioactive sensor, together with the wear os powered by samsung, is transforming mobile health experiences. and now, this technology is even more powerful thanks to the samsung privileged health sdk. find out how the samsung privileged health sdk is allowing developers to retrieve raw or analyzed sensor data for their applications, including bia, ecg, blood oxygen level or sweat loss, and help users’ to accurately monitor their health stats. speakers sungchull lee samsung electronics code lab sdc22 measure blood oxygen level on galaxy watch create a health app for galaxy watches powered by wear os, utilizing the new samsung privileged health sdk to trigger and obtain blood oxygen level (spo2) measurement results. 30 mins start sdc22 measure blood oxygen level and heart rate on galaxy watch create a health app for galaxy watches powered by wear os, utilizing the new samsung privileged health sdk to trigger and obtain results of simultaneous blood oxygen level (spo2) and heart rate measurements. 40 mins start

session ai, iot, smart appliances bixby 2022 what’s new what’s new with bixby in 2022? in this session, you will hear about some of the exciting improvements to the nlu and on-device bixby as well as updates to the bixby developer studio, which introduces a brand new javascript runtime that provides a modern, secure, high-performance environment. we will also take a closer look at the brand new bixby home studio, which allows smart device developers to customize and optimize voice control of smart devices, including allowing a single command to intelligently control multiple smart home devices. speakers roger kibbe samsung electronics related video video link video link bixby home studio introduction video link video link bixby home studio quick start guide code lab sdc22 control a smart bulb control a smart light bulb and change its color using bixby home studio. 30 mins start

session game, ar, mobile ar emoji: your avatar, your experience the ar emoji feature on samsung devices enables users to create a 3d avatar model that can be used in other applications. similar to avatars currently available in games or in the metaverse, our ar emojis are a chance for users to express themselves, their style and their personality, digitally. but this is only the beginning. in this session, we’ll explore the future of ar emojis and how the ar emoji sdk is opening more opportunities for developers to collaborate with samsung to bring to life new services featuring these avatars and optimize them for the metaverse though our collaboration with unity. speakers kihwan kim samsung electronics jeoungju kim samsung electronics related video video link video link trailer game : emoji adventure game made using the galaxy ar emoji sdk for unity. video link video link sdc21 : ar emoji for the metaverse talk about the need for ar emoji in the metaverse. code lab sdc22 use ar emoji on games and 3d apps learn how to use ar emoji as character of games or 3d applications using galaxy ar emoji sdk for unity. 60 mins start

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.

optimize game performance with adaptive performance in unity objective learn how to optimize the performance of a demo game on samsung galaxy devices using the adaptive performance in unity. the adaptive performance package provides you with tools to properly adjust you’re game and improve its overall game performance. overview galaxy gamesdk delivers an interface between game application and device which helps developers optimize their games. integrating unity adaptive performance with galaxy gamesdk allows unity developers to use this feature on unity editor within unity package manager and also customize their game contents by c# scripting. game performance and quality settings can be adjusted in real time by identifying device performance status and heat trends. moreover, using a set of simple ui controls, you can scale the quality of the game to match the device platform. the latest version of adaptive performance, now uses new android apis that gather information from samsung hardware to provide more detailed insights into the device's thermal components and cpu optimization. there are two providers for adaptive performance. the samsung provider 5.0 utilizes apis from the gamesdk, which is supported from samsung galaxy s10 or note10 devices until newer models. on the other hand, the android provider 1.2 uses the android dynamic performance framework (adpf) apis and is supported on devices running android 12 or higher. this code lab focuses on using the samsung provider of adaptive performance. thermal throttling mobile devices lack active cooling systems, causing temperatures to rise. this triggers a warning to the unity subsystems, which lowers hardware demand to control heat and avoid performance degradation. the ideal goal is to make performance stable with low temperature. adaptive performance, primarily for performance and quality balance management, can help achieve this. thermal warning the warning system implemented in gamesdk can trigger both internal unity systems and developer-defined behavior, such as disabling custom scripts and shaders. quality settings it also provides you with the option to adjust the quality of the game to maintain stable performance at different warning levels. you can scale the quality of your game in real time to meet the desired performance. this includes changes in level of detail, animation, physics, and visual effects. scalers with adaptive performance enabled, the game's fps becomes more stable and consistently higher over time. this is because the game adapts its contents based on thermal warnings provided by samsung's thermal callback system. the adaptive performance in unity provides developers with scalers that affect various aspects of the game: frame rate resolution batching level of detail (lod) lookup texture (lut) multisample anti-aliasing (msaa) shadow cascade shadow distance shadow map resolution shadow quality sorting transparency view distance physics decals layer culling these general scalers can be used to scale the content based on your settings in the editor. however, you may also create custom scalers that integrate with your own systems. for instance, your own scalers can disable cpu-expensive scripts from running when thermal warnings are reached. the latest version of adaptive performance, v5.0, includes new additions to the scalers: decal scaler changes the draw distance of decals. it controls how far a decal can be before not being rendered. layer culling scaler adjusts the distance that expensive layers, such as transparency or water, when they start being culled. it’s a useful scaler for scenes with more expensive shader calculations. in every frame, unity calculates how all the physics in a level interacts with everything else, such as when the ball is dropping to the floor. physics scaler adjusts the frequency at which this calculation is performed. a lower frequency means fewer cpu calculations per second. set up your environment you will need the following: unity editor version 2022.3 visual studio or any source code editor supported samsung galaxy device remote test lab (if physical device is not available) requirements: samsung account java runtime environment (jre) 7 or later with java web start internet environment where port 2600 is available sample code here is a sample project for you to start coding in this code lab. download it and start your learning experience! adaptive performance sample code (903.96 mb) demo game the sample project contains a demo game named boat attack. it is an open-source demo game provided by unity. it has the following features: triangles: 800,000 vertices: 771,000 shadow casters: 133 start your project after downloading the sample project, follow the steps to open your project: launch the unity hub. click projects > open. after locating the unzipped project folder, you can open it in unity editor. it initially downloads the needed resources for your project. open benchmark_island-flythrough scene found under assets. notethe project was tested in unity 2022.3. it is recommended to use this version in this code lab. set up adaptive performance components in window > package manager > adaptive performance, you can check if the adaptive performance is already included in the project. go to edit > project settings > adaptive performance. enable the initialize adaptive performance on startup and select samsung android provider. enable the scalers by going to adaptive performance > samsung (android) > indexer settings. check the scaler settings and just use the default values. add adaptive performance script to your project you are going to use a script that contains examples of the adaptive performance api code. it gives you access to the frame time information, thermal information, and cpu/gpu bottlenecks. this script adjusts the performance based on the device's thermal state, allowing longer game time by reducing in-game demands. download the adaptive performance script: adaptiveperformanceconroller.cs (6.15 kb) simply drag and drop the script into assets folder. create a new object and attach the script to the object. change the frame rate based on thermal warnings get to know about thermal warnings throttling warnings allow you to know when your game is about to be forcibly throttled and have sections of lag and lowered frame rate. adaptive performance provides these thermal alerts that allow you to take control and adjust settings before the performance downgrades. check the registered event handler to trigger thermal status: ithermalstatus.thermalstatus.thermalevent then, check thermalmetrics information in the handler. name description value nowarning no warning is the normal warning level during standard thermal state. 0 throttlingimminent if throttling is imminent, the application should perform adjustments to avoid thermal throttling. 1 throttling if the application is in the throttling state, it should make adjustments to go back to normal temperature levels. 2 temperaturelevel (0.0 ~ 1.0) current normalized temperature level in the range of [0, 1]. a value of 0 means standard operation temperature and the device is not in a throttling state. a value of 1 means that the maximum temperature of the device is reached and the device is going into or is already in throttling state. temperaturetrend (-1.0 ~ 1.0) current normalized temperature trend in the range of [-1, 1]. a value of 1 describes a rapid increase in temperature. a value of 0 describes a constant temperature. a value of -1 describes a rapid decrease in temperature. it takes at least 10s until the temperature trend may reflect any changes. adjust the frame rate in the adaptiveperformancecontroller.cs, the following code is responsible for changing the frame rate depending on the current thermal alert: void onthermalevent(thermalmetrics ev) { switch (ev.warninglevel) { case warninglevel.nowarning: application.targetframerate = 30; break; case warninglevel.throttlingimminent: application.targetframerate = 25; break; case warninglevel.throttling: application.targetframerate = 15; break; } } change the quality settings the performance bottleneck api informs you via an enum value if there is a bottleneck so you can adjust the workload: iadaptiveperformance.performancestatus.performancemetrics.performancebottleneck namespace unityengine.adaptiveperformance { public enum performancebottleneck { unknown = 0, cpu = 1, gpu = 2, targetframerate = 3 } } in the adaptiveperformancecontroller.cs script, the code below is responsible for controlling the lod of the models depending on the performance bottleneck. a model with multiple lod is a prime example of a quality setting that can heavily affect the games performance. lowering it lessens the load on the gpu, frees up resources, and eventually prevents thermal throttling. change the quality setting by adjusting lod in real time by using the performancebottleneck api. switch (ap.performancestatus.performancemetrics.performancebottleneck) // iadaptiveperformance.performancestatus.performancemetrics.performancebottleneck { case performancebottleneck.gpu: debug.logformat("[adp] performancebottleneck.gpu "); lowerlod(); break; case performancebottleneck.cpu: debug.logformat("[adp] performancebottleneck.cpu "); break; case performancebottleneck.targetframerate: debug.logformat("[adp] performancebottleneck.targetframerate "); break; case performancebottleneck.unknown: debug.logformat("[adp] performancebottleneck.unknown"); break; } create a custom scaler to create custom scalers, you need to create a new class that inherits from adaptiveperformancescaler. the adaptive performance package includes this class that can be added to the adaptive performance framework, which adjusts quality settings based on unity's thermal settings. download this custom scaler to control the texture quality of the demo game: texturescaler.cs (1.17 kb) simply drag and drop the downloaded file into the project. test using device simulator in unity the device simulator in unity allows you to test out adaptive performance functionality without a physical mobile device. go to window > general > device simulator. go to edit > project settings > adaptive performance. enable the initialize adaptive performance on startup and select device simulator provider. in the device simulator, you can try to send thermal warnings and create artificial bottlenecks to test different behaviors of the demo game. the visual scripts display the scalers available and show if it is enabled. enabling a specific scaler means that the adaptive performance w you can override the scalers to test their impact on the demo game's performance and scene. some scalers may not affect the scene but may improve the performance in the long run. build and launch the apk go to file > build settings. connect your galaxy device. enable development build and select scripts only build option. make sure that the autoconnect profiler is enabled to check the profiler in unity and measure the performance. in build to device, click the patch button to install or update the apk in your device. test using unity profiler unity has also introduced a new module in its profiler that allows you to monitor the scalers changes and extract frame time information to your editor. the profiler allows you to get real-time information from the adaptive performance plugin. navigate to windows > analysis > profiler. set the play mode to your connected galaxy device. once connected, you can analyze the frame time stats and check the state of the scalers during runtime. scalers in this profiler are reacting to the thermal trend and are being raised or lowered in response to the thermal warning. observe the scalers when enabled or disabled texture scaler the texture scaler is the custom script to lower the texture quality based on thermal levels. when enabled and maxed out, the texture fidelity has been lowered. this lowers the gpu load and memory usage. lod scaler you may notice a subtle change in the appearance of the rocks, trees, and umbrella models. this is due to the adaptation of the lod bias that determines which version of the models to use. as the thermal levels rise, lower poly models are selected to reduce the number of triangles rendered. this reduces the gpu load and minimizes thermal build-up. shadow map resolution shadow map resolution creates a blurring effect on the shadows which incidentally lowers the performance load required to render them. basically, lower shadow detail means fewer gpu calculations, which lead to less heat build-up. check the game performance using gpuwatch gpuwatch is a profiling tool for observing gpu activity in your app. the following are the common information shown by the gpuwatch: fps counters current average cpu and gpu load cpu load gpu load it is very helpful in profiling your game during the post-development stage so you can further optimize. to enable gpuwatch on your galaxy device: you can easily reposition the gpuwatch widgets on the screen by enabling unlock widgets under the notification menu of gpuwatch. you’re done! congratulations! you have successfully achieved the goal of this code lab. now, you can improve and optimize your android game on samsung galaxy devices using adaptive performance in unity by learning about scalers, thermal warnings, and bottleneck apis. the performance of your mobile games can be pushed further by utilizing these tools. to learn more, visit: developer.samsung.com/galaxy-gamedev

customize flex window using good lock plugin on watch face studio objective learn to customize a clock face for your flex window using watch face studio's good lock plugin called clockface. overview watch face studio (wfs) is a graphic authoring tool that enables you to create watch faces for wear os smartwatches. using good lock plugins, you can also create a cover screen design for galaxy z flip4 and z flip5. wfs good lock plugins enable watch face studio to create customization elements for a specific good lock application. good lock is a family of applications that allows users to customize various aspects of their galaxy mobile device, such as the lock screen, home screen, and clock face. clockface plugin, one of the good lock plugins, allows you to create clock faces that you can use on a mobile device through the clockface module of good lock app. clockface enables users to customize the clock face on their mobile device's lock screen, always on display (aod), and cover screen. it is part of the good lock family of applications. for detailed information, see good lock plugin. set up your environment you will need the following: watch face studio (latest version) clockface plugin installation file galaxy z flip5 with good lock app installed clockface module installed within good lock app sample project here is a sample project for this code lab. download it and start your learning experience! flex window customization sample project (473.53 kb) initial setup from the main menu ☰, choose preferences. go to the plugins tab and click the install plugin button. you can click the download plugin button to download the installation file. locate the installation file and click ok after adding clockface plugin to plugins list. install the good lock app in galaxy z flip5. then, download and install the clockface module from good lock app. start your project to load the sample project in watch face studio: click open project. locate the downloaded file, then click open. the sample project is a premade watch face design with preloaded images, including a background, trees, clouds, and more. it also contains analog hands and a progress bar to represent step count. in the style tab, you can see the watch face's different theme color palette. you can see other options for background, analog hands, and color when you click the customization editor button. noteto learn how to create different watch face designs in one project, see customize styles of a watch face. create a rectangular clock face design from a circular watch face the usual shape of a watch face design that you can create in watch face studio is circular. using the clockface plugin, you can set the project type as coverscreen, which allows the creation of rectangular designs for galaxy z flip4 and z flip5's cover screen. the sample project is a circular watch face. to change the design to rectangle: click the watch face studio logo to go back to the dashboard. click the three dots menu next to the sample project you added to show additional options. select create project from. enter your project name, keep coverscreen as type, and select galaxy z flip5 for size. some features of a watch face design made for a smartwatch, such as showing step count data, might not work for the flex window. it is suggested to delete unsupported features when you modify the project. after clicking ok in the dialog box, you can now see a new project with a rectangle canvas. right-click on the step_count group and choose delete to remove all components related to step count. redesign the project for flex window you need to adjust some components of the newly created project to fit with the flex window. to do this: resize all images as a group. select the background group. hold down the shift key. move the mouse pointer over one of the corner handles, then click and drag the mouse to resize the images. or, you can change the dimension's width and height of the background group in the properties tab. adjust the x and y placements to reposition the images. replace analog hands with digital clock depending on your preference, you can display analog hands or digital clocks on your flex window. but for this code lab activity, change the time display with a digital clock: remove the time group, which includes analog hands and an index. click add component > digital clock > time. in text appearance properties, change font type and size. edit the tag expression in text field with [hour_1_12_z]:[min_z] to only show the current time in 12-hour format and minutes. to indicate whether the time is am or pm, add a text component and adjust font type and size. in text field, enter the [ampm] tag as value. lastly, move the month component anywhere in the canvas and adjust its text appearance. display the clock design on flex window to install and display the cover screen design on your flex window, you need to: connect the galaxy z flip5 to the computer using usb or wifi in watch face studio, select project > run on device. select the connected galaxy z flip5 you want to test with. if your device is not detected automatically, click scan devices to see your device or enter its ip address manually by clicking the + button. open the good lock app on your device and click the clockface module. choose cover screen as clock style and select your clock design. choose the edit button to customize the style or tap the check button to apply the design. you're done! congratulations! you have successfully achieved the goal of this code lab. now, you can customize a clock face for your flex window by yourself! if you face any trouble, you may download this file: flex window customization complete project (420.44 kb) to learn more about watch face studio, visit: developer.samsung.com/watch-face-studio

implement flex mode on an unreal engine game objective learn how to implement flex mode on an unreal engine game using android jetpack windowmanager and raw java native interface (jni). overview the flexible hinge and glass display on galaxy foldable devices, such as the galaxy z fold4 and galaxy z flip4, let the phone remains propped open while you use apps. when the phone is partially folded, it will go into flex mode. apps will reorient to fit the screen, letting you watch videos or play games without holding the phone. for example, you can set the device on a flat surface, like on a table, and use the bottom half of the screen to navigate. unfold the phone to use the apps in full screen mode, and partially fold it again to return to flex mode. to provide users with a convenient and versatile foldable experience, developers need to optimize their apps to meet the flex mode standard. set up your environment you will need the following: epic games launcher with unreal engine 4 or later visual studio or any source code editor samsung galaxy foldable device: galaxy z fold2, z fold3, or newer galaxy z flip, z flip3, or newer remote test lab (if physical device is not available) requirements: samsung account java runtime environment (jre) 7 or later with java web start internet environment where port 2600 is available create and set up your project after launching unreal engine from the epic games launcher, follow the steps below to start your project: in the select or create new project window, choose games as a new project category and click next. select third person as template, then click next to proceed. noteyou can implement flex mode on any template or existing projects and use this code lab activity as a reference. in the project settings window, set the following: type of project: c++ target platform: mobile / tablet performance characteristics: scalable 3d or 2d real-time raytracing: raytracing disabled include an additional content pack: no starter content project name: tutorial_project click create project. wait for the engine to finish loading and open the unreal editor. once the project is loaded, go to edit > project settings > platforms > android. click the configure now button if the project is not yet configured for the android platform. then, proceed with the following apk packaging and build settings: a. apk packaging set target sdk version to 30. set orientation to full sensor. change the maximum supported aspect ratio to 2.8 (aspect ratio of galaxy z fold3 in decimal) to prevent black bars from appearing on the cover display. leave it if your game does not need to use the cover display. enable use display cutout region?, to prevents black bars at the edge of the main screen. otherwise, leave it unchecked. b. build disable support opengl es3.1 and enable support vulkan. notecurrently, there is a problem with opengl es and the split-screen system being investigated. the only option right now is to turn off opengl es and use vulkan instead. enable native resize event the resize event of a game when switching between displays is disabled in the engine by default. however, this behavior can be easily enabled by setting android.enablenativeresizeevent=1 in the deviceprofile. currently, the only way to create a profile for foldable devices is by creating a specific rule for each device. to save time in this code lab, enable the native resize event for all android devices instead. locate and open the tutorial_project > config folder in file explorer. inside the config folder, create a new folder named android. create a new file called androiddeviceprofiles.ini and open this file in a text editor, such as visual studio. copy below deviceprofile code to the newly created androiddeviceprofiles.ini file. [deviceprofiles] +deviceprofilenameandtypes=android,android [android deviceprofile] devicetype=android baseprofilename= +cvars=r.mobilecontentscalefactor=1.0 +cvars=slate.absoluteindices=1 +cvars=r.vulkan.delayacquirebackbuffer=2 +cvars=r.vulkan.robustbufferaccess=1 +cvars=r.vulkan.descriptorsetlayoutmode=2 ; don't enable vulkan by default. specific device profiles can set this cvar to 0 to enable vulkan. +cvars=r.android.disablevulkansupport=1 +cvars=r.android.disablevulkansm5support=1 ; pf_b8g8r8a8 +cvars=r.defaultbackbufferpixelformat=0 +cvars=android.enablenativeresizeevent=1 ; previewallowlistcvars and previewdenylistcvars are arrays of cvars that are included or excluded from being applied in mobile preview. ; if any previewallowlistcvars is set, cvars are denied by default. previewallowlistcvars=none this is a copy of the default android deviceprofile from the existing basedeviceprofiles.ini file but with the enabled nativeresizeevent console variable (cvars). notethis step is not required when you only want to implement flex mode. yet, it's recommended, to allow applications to run seamlessly from main to cover display without stretching and squashing the game, by enabling the nativeresizeevent. create a new plugin and import the foldablehelper foldablehelper is a java file that you can use in different projects. it provides an interface to the android jetpack windowmanager library, enabling application developers to support new device form factors and multi-window environments. before proceeding, read how to use jetpack windowmanager in android game dev and learn the details of how foldablehelper uses windowmanager library to retrieve information about the folded state of the device (flat for normal mode and half-opened for flex mode), window size, and orientation of the fold on the screen. download the foldablehelper.java file here: foldablehelper.java (5.64 kb) to import the foldablehelper.java file to the project, follow the steps below: go to edit > plugins in the unreal editor. click the new plugin button and select blank to create a blank plugin. in the name field, type foldables_tutorial and click the create plugin button. in file explorer, locate and open tutorial_project > plugins folder. go to plugins > foldables_tutorial > source> foldables_tutorial > private and create a new folder called java. copy the foldablehelper.java file into java folder. open the tutorial_project.sln file in visual studio. in the same private folder path, add a new filter called java. right-click on the java filter and click add > existing item. locate the foldablehelper.java file, then click add to include this java file in the build. modify java activity to use foldablehelper unreal plugin language (upl) is a simple xml-based language created by epic games for manipulating xml and returning strings. using upl, you can utilize the foldablehelper.java file by modifying the java activity and related gradle files as follows: in visual studio, right-click on source > foldables_tutorial folder, then click add > new item > web > xml file (.xml). create an xml file called foldables_tutorial_upl.xml. ensure that the file location is correct before clicking add. in the newly created xml file, include the foldablehelper.java file in the build by copying the java folder to the build directory. <root xmlns:android="http://schemas.android.com/apk/res/android"> <prebuildcopies> <copydir src="$s(plugindir)/private/java" dst="$s(builddir)/src/com/samsung/android/gamedev/foldable" /> </prebuildcopies> set up the gradle dependencies in the build.gradle file by adding the following in the xml file: <buildgradleadditions> <insert> dependencies { implementation filetree(dir: 'libs', include: ['*.jar']) implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.0" implementation "androidx.core:core:1.7.0" implementation "androidx.core:core-ktx:1.7.0" implementation "androidx.appcompat:appcompat:1.4.0" implementation "androidx.window:window:1.0.0" implementation "androidx.window:window-java:1.0.0" } android{ compileoptions{ sourcecompatibility javaversion.version_1_8 targetcompatibility javaversion.version_1_8 } } </insert> </buildgradleadditions> next, modify the gameactivity: <gameactivityimportadditions> <insert> <!-- package name of foldablehelper --> import com.samsung.android.gamedev.foldable.foldablehelper; </insert> </gameactivityimportadditions> <gameactivityoncreateadditions> <insert> foldablehelper.init(this); </insert> </gameactivityoncreateadditions> <gameactivityonstartadditions> <insert> foldablehelper.start(this); </insert> </gameactivityonstartadditions> <gameactivityonstopadditions> <insert> foldablehelper.stop(); </insert> </gameactivityonstopadditions> </root> gameactivityimportadditions adds the com.samsung.android.gamedev.foldable.foldablehelper into the gameactivity with the existing imports. gameactivityoncreateadditions adds the code to the oncreate() method inside the gameactivity. gameactivityonstartadditions adds the code to the onstart() method inside the gameactivity. gameactivityonstopadditions adds the code to the onstop() method inside the gameactivity. save the xml file. then, ensure that the engine uses the upl file by modifying the foldables_tutorial.build.cs script, located in the same folder as the foldables_tutorial_upl.xml file. after the dynamicallyloadedmodulenames.addrange call, add the following: if (target.platform == unrealtargetplatform.android) { additionalpropertiesforreceipt.add("androidplugin", moduledirectory + "\\foldables_tutorial_upl.xml"); } this means that the game engine will use the upl file if the platform is android. otherwise, the foldablehelper won’t work. implement a storage struct the next thing to implement is a struct, the native version of java’s foldablelayoutinfo class. to store the data retrieved from the java code using a struct, do the following: in content browser of unreal editor, right-click on c++ classes > add/import content. then, click new c++ class. select none for the parent class and click next. name the new class as foldablelayoutinfo. assign it to the foldables_tutorial plugin. then, click create class. delete the created foldablelayoutinfo.cpp file and only keep its header file. in the header file called foldablelayoutinfo.h, set up a struct to store all needed data from the windowmanager. #pragma once #include "core.h" enum efoldstate { undefined_state, flat, half_opened }; enum efoldorientation { undefined_orientation, horizontal, vertical }; enum efoldocclusiontype { undefined_occlusion, none, full }; struct ffoldablelayoutinfo { efoldstate state; efoldorientation orientation; efoldocclusiontype occlusiontype; fvector4 foldbounds; fvector4 currentmetrics; fvector4 maxmetrics; bool isseparating; ffoldablelayoutinfo() : state(efoldstate::undefined_state), orientation(efoldorientation::undefined_orientation), occlusiontype(efoldocclusiontype::undefined_occlusion), foldbounds(-1, -1, -1, -1), currentmetrics(-1, -1, -1, -1), maxmetrics(-1, -1, -1, -1), isseparating(false) { } }; implement jni code to implement jni, create a new c++ class with no parent and name it foldables_helper. assign the class to the same plugin, then modify the c++ header and source files as follows: in the created header file (foldables_helper.h), include foldablelayoutinfo.h. #include "foldablelayoutinfo.h" then, declare a multicast_delegate to serve as a listener for passing the data from the java implementation to the rest of the engine. declare_multicast_delegate_oneparam(fonlayoutchangeddelegate, ffoldablelayoutinfo); lastly, set up the methods and member variables. class foldables_tutorial_api ffoldables_helper { public: static void init(); static bool haslistener; static fonlayoutchangeddelegate onlayoutchanged; }; moving to the source file (foldables_helper.cpp), set up the definitions for the methods and member variables created in the header file. bool ffoldables_helper::haslistener = false; fonlayoutchangeddelegate ffoldables_helper::onlayoutchanged; void ffoldables_helper::init() { haslistener = true; } now, in the same source file, create the native version of the onlayoutchanged() function created in the foldablehelper.java file. since the java onlayoutchanged() function only works on android, surround the function with an #if directive to ensure that it compiles only on android. #if platform_android #endif within this directive, copy the code below to use the jni definition of the java onlayoutchanged() function. extern "c" jniexport void jnicall java_com_samsung_android_gamedev_foldable_foldablehelper_onlayoutchanged(jnienv * env, jclass clazz, jobject jfoldablelayoutinfo) { create the ffoldablelayoutinfo to store the data retrieved from java. ffoldablelayoutinfo result; retrieve the field ids of the foldablelayoutinfo and rect objects created in the java file. //java foldablelayoutinfo field ids jclass jfoldablelayoutinfocls = env->getobjectclass(jfoldablelayoutinfo); jfieldid currentmetricsid = env->getfieldid(jfoldablelayoutinfocls, "currentmetrics", "landroid/graphics/rect;"); jfieldid maxmetricsid = env->getfieldid(jfoldablelayoutinfocls, "maxmetrics", "landroid/graphics/rect;"); jfieldid hingeorientationid = env->getfieldid(jfoldablelayoutinfocls, "hingeorientation", "i"); jfieldid stateid = env->getfieldid(jfoldablelayoutinfocls, "state", "i"); jfieldid occlusiontypeid = env->getfieldid(jfoldablelayoutinfocls, "occlusiontype", "i"); jfieldid isseparatingid = env->getfieldid(jfoldablelayoutinfocls, "isseparating", "z"); jfieldid boundsid = env->getfieldid(jfoldablelayoutinfocls, "bounds", "landroid/graphics/rect;"); jobject currentmetricsrect = env->getobjectfield(jfoldablelayoutinfo, currentmetricsid); //java rect object field ids jclass rectcls = env->getobjectclass(currentmetricsrect); jfieldid leftid = env->getfieldid(rectcls, "left", "i"); jfieldid topid = env->getfieldid(rectcls, "top", "i"); jfieldid rightid = env->getfieldid(rectcls, "right", "i"); jfieldid bottomid = env->getfieldid(rectcls, "bottom", "i"); retrieve the current windowmetrics and store it in the ffoldablelayoutinfo as an fintvector4. // currentmetrics int left = env->getintfield(currentmetricsrect, leftid); int top = env->getintfield(currentmetricsrect, topid); int right = env->getintfield(currentmetricsrect, rightid); int bottom = env->getintfield(currentmetricsrect, bottomid); // store currentmetrics rect to fvector4 result.currentmetrics = fintvector4{ left, top, right, bottom }; do the same for the other variables in the java foldablelayoutinfo. // maxmetrics jobject maxmetricsrect = env->getobjectfield(jfoldablelayoutinfo, maxmetricsid); left = env->getintfield(maxmetricsrect, leftid); top = env->getintfield(maxmetricsrect, topid); right = env->getintfield(maxmetricsrect, rightid); bottom = env->getintfield(maxmetricsrect, bottomid); //store maxmetrics rect to fvector4 result.maxmetrics = fintvector4{ left, top, right, bottom }; int hingeorientation = env->getintfield(jfoldablelayoutinfo, hingeorientationid); int state = env->getintfield(jfoldablelayoutinfo, stateid); int occlusiontype = env->getintfield(jfoldablelayoutinfo, occlusiontypeid); bool isseparating = env->getbooleanfield(jfoldablelayoutinfo, isseparatingid); // store the values to an object for unreal result.orientation = tenumasbyte<efoldorientation>(hingeorientation + 1); result.state = tenumasbyte<efoldstate>(state + 1); result.occlusiontype = tenumasbyte<efoldocclusiontype>(occlusiontype + 1); result.isseparating = isseparating; // boundsrect jobject boundsrect = env->getobjectfield(jfoldablelayoutinfo, boundsid); left = env->getintfield(boundsrect, leftid); top = env->getintfield(boundsrect, topid); right = env->getintfield(boundsrect, rightid); bottom = env->getintfield(boundsrect, bottomid); // store maxmetrics rect to fvector4 result.foldbounds = fintvector4{ left, top, right, bottom }; broadcast the result via the onlayoutchanged delegate for use in the engine. if (ffoldables_helper::haslistener) { ue_log(logtemp, warning, text("broadcast")); ffoldables_helper::onlayoutchanged.broadcast(result); } } create a player controller and two ui states this section focuses on adding a player controller and creating two user interface (ui) states for flat and flex modes. these objects are needed for the flex mode logic implementation. following are the steps to add a player controller and create two ui states : add a new player controller blueprint. in content browser, go to content > thirdpersoncpp and right-click on blueprints > add/import content > blueprint class. pick player controller as its parent class. rename it as flexplayercontroller. notethe flexplayercontroller added is generic and can be replaced by your custom player controller in an actual project. add a new c++ class with actor component as its parent class. name it as foldables_manager and assign it to the foldables_tutorial plugin. click the create class button. open the flexplayercontroller blueprint by double-clicking it. click open full blueprint editor. attach the actor component to the flexplayercontroller. in the left pane, click add component, then find and select the foldables_manager. next, create a pair of userwidget classes for the ui layouts needed: flat mode ui for the full screen or normal mode; and flex mode ui for split-screen. in add c++ class window, select the show all classes checkbox. find and pick userwidget as the parent class. then, click next. name the new user widget as flatui and attach it to the plugin. click next. repeat the process but name the new user widget as flexui. you might get an error when trying to compile stating that the userwidget is an undeclared symbol. to fix this, open the foldables_tutorial.build.cs file, and in the publicdependencymodulenames.addrange call, add "inputcore" and "umg" to the list. create a pair of blueprints made from subclasses of these two user widgets. right-click on content and create a new folder called foldui. inside the newly created folder, right-click to add a new blueprint class. in all classes, choose flatui and click the select button. rename the blueprint as bp_flatui. in the same folder, repeat the process but choose the flexui class and rename the blueprint as bp_flexui. double-click on bp_flatui and bp_flexui, then design your two uis like below to visualize switching between flat and flex mode: flat ui flex ui notethis code lab activity does not cover the steps on how to create or design ui. if you want to learn about how to create your own game design in unreal engine 4, refer to unreal motion graphics ui designer guide. implement the flex mode logic after creating the flexplayercontroller and the two ui states (bp_flatui and bp_flexui), you can now implement flex mode logic in the foldables_manager. open the foldables_manager.h and include the necessary c++ header files: #pragma once #include "coreminimal.h" #include "components/actorcomponent.h" #include "engine.h" #include "flatui.h" #include "flexui.h" #include "foldables_helper.h" #include "foldables_manager.generated.h" remove the line below to save a little bit of performance as this component doesn't need to tick. public: // called every frame virtual void tickcomponent(float deltatime, eleveltick ticktype, factorcomponenttickfunction* thistickfunction) override; set up the functions needed in foldables_manager: the constructor, a function to create the ui widgets the implementation of onlayoutchanged delegate public: // sets default values for this component's properties ufoldables_manager(); void createwidgets(); protected: // called when the game starts virtual void beginplay() override; protected: void onlayoutchanged(ffoldablelayoutinfo foldablelayoutinfo); then, set up the variables needed: references to the flat and flex ui classes references to the flat and flex ui objects mark the pointers as uproperty to ensure that garbage collection does not delete the objects they point to. tsubclassof<uuserwidget> flatuiclass; tsubclassof<uuserwidget> flexuiclass; uproperty() class uflatui* flatui; uproperty() class uflexui* flexui; finally, define a new private function restoreflatmode(), to disable flex mode and return to normal mode. private: void restoreflatmode(); moving over to foldables_manager.cpp, implement the constructor. using the constructorhelpers, find the ui classes and set the variables to store these classes. also, set the bcanevertick to false to prevent the component from ticking and remove the code block of tickcomponent() function. // sets default values for this component's properties ufoldables_manager::ufoldables_manager() { primarycomponenttick.bcanevertick = false; static constructorhelpers::fclassfinder<uflatui> flatuibpclass(text("/game/foldui/bp_flatui")); static constructorhelpers::fclassfinder<uflexui> flexuibpclass(text("/game/foldui/bp_flexui")); if (flatuibpclass.succeeded()) { flatuiclass = flatuibpclass.class; } if (flexuibpclass.succeeded()) { flexuiclass = flexuibpclass.class; } } next, set up the beginplay() function to link the delegate to the onlayoutchanged() function, to initialize the foldables_helper, and to create the widgets ready for use in the first frame. // called when the game starts void ufoldables_manager::beginplay() { super::beginplay(); ffoldables_helper::onlayoutchanged.adduobject(this, &ufoldables_manager::onlayoutchanged); ffoldables_helper::init(); createwidgets(); } set up the createwidgets() function to create the widgets using the ui classes acquired in the constructor. add the flatui widget to the viewport, assuming the app opens in normal mode until it receives the foldablelayoutinfo. void ufoldables_manager::createwidgets() { flatui = createwidget<uflatui>((aplayercontroller*)getowner(), flatuiclass, fname(text("flatui"))); flexui = createwidget<uflexui>((aplayercontroller*)getowner(), flexuiclass, fname(text("flexui"))); flatui->addtoviewport(); } afterward, create the onlayoutchanged() function, which will be called via a delegate. inside this function, check whether the device’s folded state is half_opened. if so, check whether the orientation of the fold is horizontal. void ufoldables_manager::onlayoutchanged(ffoldablelayoutinfo foldablelayoutinfo) { //if state is now flex if (foldablelayoutinfo.state == efoldstate::half_opened) { if (foldablelayoutinfo.orientation == efoldorientation::horizontal) { notefor this third person template, splitting the screen vertically isn’t ideal from a user experience (ux) point of view. for this code lab activity, split the screen only on the horizontal fold (top and bottom screen). if you want it vertically, you need to use the same principle in the next step but for the x-axis instead of the y-axis. you must also ensure that you have a flex ui object for the vertical layout. if the device is both on flex mode and horizontal fold, change the viewport to only render on the top screen using the normalized position of the folding feature. then in an asynctask on the game thread, disable the flatui and enable the flexui. however, if the device is on normal mode, then return to flat ui using restoreflatmode() function. //horizontal split float foldratio = (float)foldablelayoutinfo.foldbounds.y / (foldablelayoutinfo.currentmetrics.w - foldablelayoutinfo.currentmetrics.y); gengine->gameviewport->splitscreeninfo[0].playerdata[0].sizex = 1.0f; gengine->gameviewport->splitscreeninfo[0].playerdata[0].sizey = foldratio; asynctask(enamedthreads::gamethread, [=]() { if (flatui->isinviewport()) { flatui->removefromparent(); } if (!flexui->isinviewport()) { flexui->addtoviewport(0); } }); } else { restoreflatmode(); } } else { restoreflatmode(); } } reverse the flex mode implementation logic to create the restoreflatmode() function by setting the viewport to fill the screen, then disable the flexui and enable the flatui. void ufoldables_manager::restoreflatmode() { gengine->gameviewport->splitscreeninfo[0].playerdata[0].sizex = 1.0f; gengine->gameviewport->splitscreeninfo[0].playerdata[0].sizey = 1.0f; asynctask(enamedthreads::gamethread, [=]() { if (!flatui->isinviewport()) { flatui->addtoviewport(0); } if (flexui->isinviewport()) { flexui->removefromparent(); } }); } set up a game mode and attach the flexplayercontroller the game mode defines the game rules, scoring, and any game-specific behavior. set up the game mode in unreal editor by creating a blueprint class in the content > thirdpersoncpp > blueprints folder. pick game mode base as the parent class and rename it as flexgamemode. double-click on flexgamemode. in the drop-down menu next to player controller class, choose the flexplayercontroller. lastly, go to edit > project settings > project > maps & modes and select flexgamemode as the default gamemode. build and run the app go to edit > package project > android to build the apk. ensure that the android development environment for unreal is already set up to your computer. noteif the build failed due to corrupted build tools, consider downgrading the version to 30 or lower using the sdk manager. or, simply rename d8.bat to the name of the missing file (dx.bat) in (sdk path) > build-tools > (version number) directory and, in lib folder of the same directory, rename d8.jar to dx.jar. after packaging your android project, run the game app on a foldable galaxy device and see how the ui switches from normal to flex mode. if you don’t have any physical device, you can also test it on a remote test lab device. tipwatch this tutorial video and know how to easily test your app via remote test lab. you're done! congratulations! you have successfully achieved the goal of this code lab. now, you can implement flex mode in your unreal engine game app by yourself! if you're having trouble, you may download this file: flex mode on unreal complete code (20.16 mb) to learn more, visit: www.developer.samsung.com/galaxy-z www.developer.samsung.com/galaxy-gamedev

measure blood oxygen level and heart rate on galaxy watch objective create a health app for galaxy watch, operating on wear os powered by samsung, utilizing samsung privileged health sdk to trigger and obtain results of simultaneous blood oxygen level (spo2) and heart rate measurements. partnership request in this code lab, you will use a specially prepared mock library. it has limited functionality and uses dummy data instead of real-time data. to get real values, you will need the full version of the samsung privileged health sdk library, which is available to samsung partners. apply as a partner by checking out the partner app program to get exclusive access to the samsung privileged health sdk. overview samsung privileged health sdk provides means of accessing and tracking health information contained in the health data storage. its tracking service gives raw and processed sensor data such as accelerometer and body composition data sent by the samsung bioactive sensor. the latest bioactive sensor of galaxy watch runs powerful health sensors such as photoplethysmogram (ppg), electrocardiogram (ecg), bioelectrical impedance analysis (bia), sweat loss, and spo2. see samsung privileged health sdk 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! measuring blood oxygen level and heart rate sample code (135.23 kb) 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. 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 in developer options find wireless debugging turn on wireless debugging check always allow on this network and tap allow go back to developer options and click turn off automatic wi-fi notethere may be differences in settings depending on your one ui version. connect your galaxy watch to android studio go to settings > developer options > wireless debugging and choose pair new device. take note of the wi-fi pairing code, ip address & port. in android studio, go to terminal and type: adb pair <ip address>:<port> <wi-fi pairing code> when prompted, tap always allow from this computer to allow debugging. after successfully pairing, type: adb connect <ip address of your watch>:<port> 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. turn on developer mode for health platform this step is only applicable to registered partners of samsung privileged health sdk. you can replace priv-health-tracking-mock-2023.aar in app/libs with the real library to receive real sensor data with the application. this requires health platform to be set in developer mode: on your watch go to settings > apps > health platform. quickly tap health platform title for 10 times. this enables developer mode and displays [dev mode] below the title. to stop using developer mode, quickly tap health platform title for 10 times to disable it. start your project after downloading the sample code containing the project files, in android studio click open to open existing project. locate the downloaded android project from the directory and click ok. establish service connection and check capabilities for the device to track data with the samsung privileged health sdk, it must connect to the service by healthtrackingservice api. after establishing a connection, verify if the required tracker type is available. to check this, get the list of available tracker types and verify that the tracker is on the list. in this code lab, you will utilize blood oxygen level and heart rate trackers. the healthtrackingservice api usage is in the table below. healthtrackingservicehealthtrackingservice initiates a connection to samsung's health tracking service and provides a healthtracker instance to track a healthtrackertype. public void connectservice() establish a connection with samsung's health tracking service. public void disconnectservice() release a connection for samsung's health tracking service. public healthtrackercapability gettrackingcapability() provide a healthtrackercapability instance to get a supporting health tracker type list. initialize multiple trackers before the measurement starts, initialize the spo2 tracker by obtaining the proper health tracker object. in the connectionmanager.java file, navigate to initspo2(), create an oxygen saturation healthtracker instance, and pass it to the spo2listener instance. get the healthtracker object using the healthtrackingservice api. use the healthtrackertype.spo2 type as parameter. healthtrackingservicehealthtrackingservice initiates a connection to samsung's health tracking service and provides a healthtracker instance to track a healthtrackertype. public healthtracker gethealthtracker(healthtrackertype healthtrackertype) provide a healthtracker instance for the given healthtrackertype. pass the healthtracker object to the spo2listener instance object. spo2listener public void sethealthtracker(healthtracker tracker) set healthtracker instance for the given tracker. /******************************************************************************************* * [practice 1] create blood oxygen level health tracker object * - get health tracker object * - pass it to spo2listener ------------------------------------------------------------------------------------------- * - (hint) replace todo 1 with parts of code * (1) get healthtracker object using healthtrackingservice.gethealthtracker() * use healthtrackertype.spo2 type as parameter * (2) pass it to spo2listener using sethealthtracker function ******************************************************************************************/ public void initspo2(spo2listener spo2listener) { //"todo 1 (1)" //"todo 1 (2)" sethandlerforbaselistener(spo2listener); } next, in the connectionmanager.java file, in the initheartrate() function, create a heart rate healthtracker instance, and pass it to the heartratelistener instance. get the healthtracker object using the healthtrackingservice api. use the healthtrackertype.heart_rate type as parameter. pass the healthtracker object to the heartratelistener instance object. heartratelistener public void sethealthtracker(healthtracker tracker) set healthtracker instance for the given tracker. /******************************************************************************************* * [practice 2] create heart rate health tracker object * - get health tracker object * - pass it to heartratelistener ------------------------------------------------------------------------------------------- * - (hint) replace todo 2 with parts of code * (1) get healthtracker object using healthtrackingservice.gethealthtracker() * use healthtrackertype.heart_rate type as parameter * (2) pass it to heartratelistener using sethealthtracker function ******************************************************************************************/ public void initheartrate(heartratelistener heartratelistener) { //"todo 2 (1)" //"todo 2 (2)" sethandlerforbaselistener(heartratelistener); } start and stop trackers for the client app to start obtaining the data through the sdk, set a listener method on healthtracker. this method will be called every time there is new data. after the measurement completes, the listener has to be disconnected. to start measurement in the baselistener.java file, navigate to starttracker() function, and set trackereventlistener as listener healthtracker object. set an event listener on healthtracker object using healthtracking api. use the healthtracker.trackereventlistener object instance as parameter. healthtrackerhealthtracker enables an application to set an event listener and get tracking data for a specific healthtrackertype. public void seteventlistener(healthtracker.trackereventlistener listener) set an event listener to this healthtracker instance. /******************************************************************************************* * [practice 3] start health tracker by setting event listener * - set event listener on health tracker ------------------------------------------------------------------------------------------- * - (hint) replace todo 3 with parts of code * set event listener on healthtracker object using healthtracker.seteventlistener() * use trackereventlistener object as parameter ******************************************************************************************/ public void starttracker() { log.i(app_tag, "starttracker called "); log.d(app_tag, "healthtracker: " + healthtracker.tostring()); log.d(app_tag, "trackereventlistener: " + trackereventlistener.tostring()); if (!ishandlerrunning) { handler.post(() -> { //"todo 3" sethandlerrunning(true); }); } } to stop measurement, unset the trackereventlistener from the healthtracker object in the stoptracker() function. unset the event listener on healthtracker object using healthtracking api. healthtrackerhealthtracker enables an application to set an event listener and get tracking data for a specific healthtrackertype. public void unseteventlistener() stop the registered event listener to this healthtracker instance. /******************************************************************************************* * [practice 4] stop health tracker by removing event listener * - unset event listener on health tracker ------------------------------------------------------------------------------------------- * - (hint) replace todo 4 with parts of code * unset event listener on healthtracker object using healthtracker.unseteventlistener() ******************************************************************************************/ public void stoptracker() { log.i(app_tag, "stoptracker called "); log.d(app_tag, "healthtracker: " + healthtracker.tostring()); log.d(app_tag, "trackereventlistener: " + trackereventlistener.tostring()); if (ishandlerrunning) { //"todo 4" sethandlerrunning(false); handler.removecallbacksandmessages(null); } } process obtained and batching data the response from the platform will be asynchronous with the results you want to obtain. follow the steps below to get blood oxygen level and heart rate data. in the spo2listener.java file, navigate to updatespo2() function, and read spo2 data from datapoint: get the oxygen saturation status using the datapoint api (key: valuekey.spo2set.status). get the oxygen saturation value using the datapoint api (key: valuekey.spo2set.spo2). datapointdatapoint provides a map of valuekeyand value with a timestamp. public <t>t getvalue(valuekey<t> type) get data value for the given key. /******************************************************************************************* * [practice 5] read values from datapoint object * - get blood oxygen level status * - get blood oxygen level value ------------------------------------------------------------------------------------------- * - (hint) replace todo 5 with parts of code * (1) remove spo2status.calculating and * set status from 'datapoint' object using datapoint.getvalue(valuekey.spo2set.status) * (2) set spo2value from 'datapoint' object using datapoint.getvalue(valuekey.spo2set.spo2) * if status is 'spo2status.measurement_completed' ******************************************************************************************/ public void updatespo2(datapoint datapoint) { int status = spo2status.calculating; //"todo 5 (1)" int spo2value = 0; //"todo 5 (2)" trackerdatanotifier.getinstance().notifyspo2trackerobservers(status, spo2value); log.d(app_tag, datapoint.tostring()); } in the heartratelistener.java file, navigate to readvaluesfromdatapoint() function, and read the heart rate data from datapoint: get heart rate status using datapoint api (key: valuekey.heartrateset.heart_rate_status). get heart rate value using datapoint api (key: valuekey.heartrateset.heart_rate). get heart rate ibi value using datapoint api (key: valuekey.heartrateset.ibi_list). get ibi quality using datapoint api (key: valuekey.heartrateset.ibi_status_list). /******************************************************************************************* * [practice 6] read values from datapoint object * - get heart rate status * - get heart rate value * - get heart rate ibi value * - check retrieved heart rate’s ibi and ibi quality values ------------------------------------------------------------------------------------------- * - (hint) replace todo 6 with parts of code * (1) set hrdata.status from 'datapoint' object using datapoint.getvalue(valuekey.heartrateset.heart_rate_status) * (2) set hrdata.hr from 'datapoint' object using datapoint.getvalue(valuekey.heartrateset.heart_rate) * (3) set local variable 'list<integer> hribilist' using datapoint.getvalue(valuekey.heartrateset.ibi_list) * (4) set local variable 'final list<integer> hribistatus' using datapoint.getvalue(valuekey.heartrateset.ibi_status_list) * (5) set hrdata.ibi with the last of 'hribilist' values * (6) set hrdata.qibi with the last of 'hribistatus' values ******************************************************************************************/ public void readvaluesfromdatapoint(datapoint datapoint) { heartratedata hrdata = new heartratedata(); //"todo 6 (1)" //"todo 6 (2)" //"todo 6 (3)" //"todo 6 (4)" //"todo 6 (5)" //"todo 6 (6)" trackerdatanotifier.getinstance().notifyheartratetrackerobservers( hrdata); log.d(app_tag, datapoint.tostring()); } run unit tests for your convenience, you can find an additional unit tests package. this lets you verify your code changes even without using a physical watch. see instructions below on how to run unit tests: right click on com.samsung.health.multisensortracking (test) and execute run 'tests in 'com.samsung.health.multisensortracking'' command. if you completed all the tasks correctly, you can see that all the unit tests passed successfully. run the app after building the apk, you can run the application on a connected device to see blood oxygen level and heart rate values. right after the app is started, it requests for user permission. allow the app to receive data from the body sensors. afterwards, it shows the application's main screen and automatically display the heart rate. to get the blood oxygen level (spo2) value, tap on the measure button. to stop the measurement, tap on the stop button. tap on the details label to see more heart rate data. you're done! congratulations! you have successfully achieved the goal of this code lab. now, you can create a health app that measures blood oxygen level and heart rate by yourself! if you're having trouble, you may download this file: measuring blood oxygen level and heart rate complete code (134.82 kb) to learn more about samsung health, visit: developer.samsung.com/health