Search

Filter

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

tutorials mobile, game

blog

Vulkan Mobile Best Practice: How To Configure Your Vulkan Swapchain

at gdc 2019, arm and samsung were joined on stage in the “all-in-one guide to vulkan on mobile” talk to share their learning from helping numerous developers and studios in optimizing their vulkan mobile games. in tandem, arm released vulkan best practices for mobile developers to address some of the most common challenges faced when coding vulkan applications on mobile. it includes an expansive list of runnable samples with full source code available online. this blog series delves in detail into each sample, investigates individual vulkan features, and demonstrates best practices of how to use them. overview setting up a vulkan swapchain involves picking between options that don’t have a straightforward connection to performance. the default options might not be the most efficient ones, and what works best on a desktop may be different from what works on mobile. looking at the vkswapchaincreateinfokhr struct, we identified three options that need a more detailed analysis: presentmode: what does each present mode imply in terms of performance? minimagecount: which is the best number of images? pretransform: what does it mean, and what do we need to do about it? this blog post covers the first two points, as they are both tied to the concept of buffering swapchain images. surface transform is quite a complex topic that we'll cover in a future post on the arm community. choosing a present mode vulkan has several present modes, but mobile gpus only support a subset of them. in general, presenting an image directly to the screen (immediate mode) is not supported. the application will render an image, then pass it to the presentation engine via vkqueuepresentkhr. the presentation engine will display the image for the next vsync cycle, and then it will make it available to the application again. the only present modes which support vsync are: fifo: vk_present_mode_fifo_khr mailbox: vk_present_mode_mailbox_khr we will now each of these in more detail to understand which one is better for mobile. figure 1 shows an outline of how the fifo present mode works. the presentation engine has a queue (or “fifo”) of images, in this case, three of them. at each vsync signal, the image in front of the queue displays on screen and is then released. the application will acquire one of the available ones, draw to it and then hand it over to the presentation engine, which will push it to the back of the queue. you may be used to this behavior from other graphics apis, double or triple buffering – more on that later! an interesting property of the fifo present mode is that if the gpu can process images really fast, the queue can become full at some point. when this happens, the cpu and the gpu will idle until an image finishes its time on screen and is available again. the framerate will be capped at a stable 60 fps, corresponding to vsync. this idling behavior works well on mobile because it means that no unnecessary work is performed. the extra cpu and gpu budget will be detected by the dvfs (dynamic voltage and frequency scaling) system, which reduces their frequencies to save power at no performance cost. this limits overheating and saves battery life – even a small detail such as the present mode can have a significant impact on your users' experience! let us take a look at mailbox now. the main difference, as you can see from figure 2 below, is that there is no queue anymore. the presentation engine will now hold a single image that will be presented at each vsync signal. the app can acquire a new image straight away, render to it, and present it. if an image is queued for presentation, it will be discarded. mobile demands efficiency; hence, the word "discarded" should be a big red flag when developing on mobile – the aim should always be to avoid unnecessary work. since an image was queued for presentation, the framerate will not improve. what is the advantage of mailbox then? being able to keep submitting frames lets you ensure you have the latest user input, so input latency can be lower versus fifo. the price you pay for mailbox can be very steep. if you don't throttle your cpu and gpu at all, one of them may be fully utilized, resulting in higher power consumption. unless you need low-input latency, our recommendation is to use fifo. choosing the number of images it is now clear that fifo is the most efficient present mode for mobile, but what about minimagecount? in the context of fifo, minimagecount differentiates between double and triple buffering, which can have an impact on performance. the number of images you ask for needs to be bound within the minimum and maximum images supported by the surface (you can query these values via surface capabilities). you will typically ask for 2 or 3 images, but the presentation engine can decide to allocate more. let us start with double buffering. figure 4 outlines the expected double-buffering behavior. double buffering works well if frames can be processed within 16.6ms, which is the interval between vsync signals at a rate of 60 fps. the rendered image is presented to the swapchain, and the previously presented one is made available to the application again. what happens if the gpu cannot process frames within 16.6ms? double buffering breaks! as you can see from figure 5, if no images are ready when the vsync signal arrives, the only option for the presentation engine is to keep the current image on screen. the app has to wait for another whole vsync cycle before it acquires a new image, which effectively limits the framerate to 30 fps. a much higher rate could be achieved if the gpu could keep processing frames. this may be ok for you if you are happy to limit framerate to 30 fps, but if you're aiming for 60 fps, you should consider triple buffering. even if your app can achieve 60 fps most of the time, with double buffering the tiniest slowdown below 60 fps results in an immediate drop to 30 fps. figure 6 shows triple buffering in action. even if the gpu has not finished rendering when vsync arrives, a previous frame is queued for presentation. this means that the presentation engine can release the currently displayed image and the gpu can acquire it as soon as it is ready. in the example shown, triple buffering results in ~50 fps versus 30 fps with double buffering. the sample our vulkan best practice for mobile developers project on github has a sample on swapchain images, that specifically compares double and triple buffering. you can check out the tutorial for the swapchain images sample. as you can see from figures 7 and 8, triple buffering lets the app achieve a stable 60 fps (16.6 ms frame time), providing x2 higher frame rate. when switching to double buffering the framerate drops. we encourage you to check out the project on the vulkan mobile best practice github page and try this or other samples for yourself! the sample code gives developers on-screen control to demonstrate multiple ways of using the feature. it also shows the performance impact of the different approaches through real-time hardware counters on the display. you are also warmly invited to contribute to the project by providing feedback and fixes and creating additional samples. please also visit the arm community for more in-depth blogs on the other vulkan samples.

Attilio Provenzano

https://developer.samsung.com/sdp/blog/en-us/2019/07/26/vulkan-mobile-best-practice-how-to-configure-your-vulkan-swapchain

featured marketplace, mobile

blog

Strategies for Success: Building Your Fan Base

the key to successful marketing is building your brand and creating a loyal customer base that returns to your store to purchase again. you want consumers to recognize your brand, trust the quality, and anticipate new releases. building your brand takes time and effort. from designing compelling consumer marketing assets to expanding your customer reach, in this blog series, i offer suggestions to help grow your customer base and ultimately reach your marketing goals. please note: this article links to a number of products, services, and online groups. the links are for the readers' convenience, but do not represent an endorsement of the products, services, or online groups. build a fan base the number one common factor for all successful app developers is building a fan base. this is the best way for consumers to discover your app collection, learn about your latest releases, take advantage of your marketing promotions, and to stay up-to-date with your brand. one easy way to start building your fan base is to collect email addresses to be used in marketing campaigns or newsletters. there are many ways you can encourage your customers to share their email. coupons a great way to reward your fans and promote your apps is with coupons. however, you should limit the use of coupons so that your paid apps maintain value. if you offer large quantities of coupons, your customer base will not be as likely to purchase your apps. downloads from coupons should be less than 15% of your total downloads. a few ways to leverage the power of coupons: buy one, get one free. create a marketing campaign for current customers to post a review of the app they purchased. email a screenshot as proof and get a free coupon for another app from your collection. share on social media. customers post a photo/video of their purchased app on social media and tag your brand handle. you’ll receive a tagged notification and can send the customer a message with their coupon code. ask subscribers of your youtube channel to post comments on your videos. award a lucky subscriber with a free coupon. shoot videos or take photos? the answer to that question is, both. photos are needed for marketing your apps on galaxy store and can easily be posted to your website and social sites. if you need help creating photos for watch apps, check out asset creator and lifestyle photos. these free templates will help you quickly create great photos for use in marketing. photos are great for a quick view and can get you a fast like. however, with video sharing sites becoming extremely popular, studies have shown that users are more likely to post comments on videos than photos. this type of engagement helps boost your posts to the top of the algorithm and can raise your ranking within search results. videos are also a fantastic way to show your apps in action, giving consumers confidence before deciding to purchase. videos give you the ability to not only show the features of your app but also set the mood to help inspire customers to purchase. rather than simply animate a series of screenshots, filming an actual device can make videos more compelling. however, if you do not have access to a device, here are a few alternatives that can help: purchase a video template that you can edit in a program like adobe premiere. one popular site for templates is video hive. download a 3d device and animate using a program like adobe after effects. 3d objects of samsung devices can be purchased at hum3d. watch face designer urarity creates promotional videos that highlight their work. website give your brand a home by creating a website. with services like wix, squarespace, and divi for wordpress, building an engaging website can be smooth and simple. having a website gives your brand credibility and builds trust with consumers. your website can include your complete library of apps, the latest news, and make it easy for consumers to contact you. newsletters one of the most critical tools for success is offering a newsletter that consumers can subscribe to. delivering a newsletter is the quickest and most direct way to reach consumers. services like mailchimp and constant contact offer email marketing solutions for distributing newsletters. instant messaging services like telegram, wechat, and whatsapp also offer a way for you to build a community and reach your fans. facebook groups finding like-minded samsung fans is easy on facebook. a few groups you can join are watch face samsung, samsung galaxy watch group, themes for samsung, and samsung themes. groups like these allow you to not only discover what other designers are creating but provide you a platform for showcasing your work and receiving feedback from members. youtube subscribers being one of the largest media platforms, youtube is an extremely important channel for you to market on. posting videos of your apps not only help to be discovered by an extremely large global audience but youtube's simple subscribe and notify feature makes it easy for you to build a strong fanbase. social media platforms there are many social media platforms to leverage. truthfully, the more platforms you are on will increase the visibility of your content, helping to boost traffic on search engines like google. reddit, twitter & medium – social news, discussion, and micro-blogging websites. follow developers and designers, join groups, post about your latest apps, and start a dialogue with people having similar interests. instagram, tiktok, dribbble & pinterest – all can be used by designers for self-promotion and social networking. post your latest photos and videos, search to discover what other designers are creating, excite your audience, or become inspired yourself. galaxy store badges the best way to point consumers to your apps and track activity is with galaxy store badges. just one click and consumers can access your marketplace. creating a badge generates a link to your app detail page or brand page. use badges to promote your apps on websites, videos, social media, and more. badges are also a great way to determine the effectiveness of your marketing efforts. read how to get started with galaxy store badges here. marketing info and resources additional reads: strategies for success look for new releases of my blog series, strategies for success, where i continue to deep-dive into the many areas that can influence your market growth. additional topics to include: brand names building your fan base (this post) consumer trends selling your apps samsung galaxy store: tips for marketing your apps check out my video, samsung galaxy store: tips for marketing your apps to learn more about creating brands, designing marketing graphics, social media tips, badges, and banner promotions. marketing resources looking for even more info about promoting your apps? our marketing resources page contains helpful information on promoting your apps. you can view lists of relevant hashtags to use on social media, learn more about discounts and coupons, as well as download guidelines and kits to help you get started. developer forums post questions, search for answers, or just see what are the latest topics for discussion. visiting our developer forum is an excellent way to stay up-to-date on all things related to the galaxy ecosystem. to see the latest marketing topics, be sure to view the marketing thread.

Tony Morelan

https://developer.samsung.com/sdp/blog/en-us/2021/02/01/strategies-for-success-building-your-fan-base

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

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, galaxy watch

blog

Reading Body Composition Data with Galaxy Watch via Health Connect API

the body composition measurement is one of the powerful features of samsung galaxy watch. it is an important metric of your overall health. the body composition measurement data is displayed in the samsung health application on the galaxy watch and a compatible smartphone. in this article, we show you how to read the galaxy watch’s body composition data using the android health connect api in a sample application named "bia viewer". you can download the code for this sample application from the link at the bottom of this blog. bia is an abbreviation for bioelectrical impedance analysis, and the bia data measures body composition data. notethe body composition measurement feature is available on galaxy watch4 series and later models. installing health connect api the android health connect api provides interfaces for reading and writing your health and fitness data. the samsung health application exchanges data with the health connect api. for more information, see accessing samsung health data through health connect. notesynchronization of data between the samsung health application and the health connect api is supported on samsung health v6.22.5 and later. measuring body composition with galaxy watch as the first step in developing your ultimate health application, you must collect the body composition data using the samsung health application in galaxy watch. steps to measure bia with galaxy watch: start the samsung health application. ensure that the galaxy watch is worn tightly on your wrist. raise your arms so your armpits are open. place your middle finger on the 2 o’clock key and ring finger on the 4 o’clock key on the watch. touch your watch only. don’t let your hand on the watch’s keys touch your arm or other hand on the watch. maintain the finger positions on the galaxy watch dial until the measurement is completed. example of a result obtained by measuring body composition with the samsung health application: after the bia measurement is completed on the galaxy watch, the data can be synchronized with the samsung health application. synchronizing data with the health connect application once you have data in the samsung health application, it is synchronized with the health connect application. synchronized body composition data can be found directly in the health connect application. basal metabolic rate body fat height weight bia viewer application overview bia viewer is an application that reads the body composition data collected by the samsung health application with the health connect apis. by default, this application loads the data during startup. however, you can manually reload the data using the “refresh” button. the bia viewer application reads the body composition data such as weight, height, body fat, basal metabolic rate. the user's height is not displayed and is only used to calculate bmi. the step-by-step construction of the most important elements of the application are described in the next sections. note fat mass is calculated using the formula: [fat mass] = [body fat] * [weight] / 100 bmi is calculated using the formula: [bmi] = [weight] / ([height]* [height]) adding health connect api to your project before you start writing your code, you need to import and add the health connect api library to the file application/build.gradle in the dependencies section. implementation 'androidx.health.connect:connect-client:1.1.0-alpha06' now you are ready to use the health connect api. checking health connect availability on your device at the beginning of your application, it's a good idea to ensure that the device running your application actually supports the health connect api library. the library is available only when the health connect application is installed on the device. notesince android 14 health connect is part of the system and is installed by default. however in earlier versions, it's necessary to check, if health connect is present on the device. private fun checkavailability(): boolean { when (healthconnectclient.getsdkstatus(this)) { healthconnectclient.sdk_unavailable -> { //error message – unable to install health connect } return false } healthconnectclient.sdk_unavailable_provider_update_required -> { //error message – health connect not present on device, but can be installed } return false } else -> { return true } } } get healthconnectclient before going to the next step, you need to get healthconnectclient. healthconnectclient is an entry point to the health connect api. healthconnectclient automatically manages its connection to the underlying storage layer and handles all ipc and serialization of the outgoing requests and the incoming responses. private val healthconnectclient by lazy { healthconnectclient.getorcreate(context) } ask for permissions in the first step, you need to modify the androidmanifest.xml file. add <intent-filter> in the <activity> section: <intent-filter> <action android:name="androidx.health.action_show_permissions_rationale" /> </intent-filter> add <activity-alias> element required in android 14: <activity-alias android:name="viewpermissionusageactivity" android:exported="true" android:targetactivity=".mainactivity" android:permission="android.permission.start_view_permission_usage"> <intent-filter> <action android:name="android.intent.action.view_permission_usage" /> <category android:name="android.intent.category.health_permissions" /> </intent-filter> </activity-alias> add <uses-permission> elements: <uses-permission android:name="android.permission.health.read_basal_metabolic_rate" /> <uses-permission android:name="android.permission.health.read_body_fat" /> <uses-permission android:name="android.permission.health.read_height" /> <uses-permission android:name="android.permission.health.read_weight" /> add <queries> elements: <queries> <package android:name="com.google.android.apps.healthdata" /> </queries> to start the request permissions from your application, first build a set of permissions for the required data types. make sure to only ask for permissions mentioned in the manifest file. val permissions = setof( healthpermission.getreadpermission(basalmetabolicraterecord::class), healthpermission.getreadpermission(bodyfatrecord::class), healthpermission.getreadpermission(heightrecord::class), healthpermission.getreadpermission(weightrecord::class), ) it is a good practice to ask for the required permissions whenever the application tries to use this data type. first, you should check whether the user has consented to use the particular functionality. suspend fun hasallpermissions(): boolean { return healthconnectclient.permissioncontroller.getgrantedpermissions() .containsall(permissions) } if not, you should ask for it before using the api. private fun checkpermissions() { lifecyclescope.launch { if (healthconnectmanager.hasallpermissions()) { readalldata() } else { requestpermissions.launch(healthconnectmanager.permissions) } } } to ask for permissions, you need to create a request permissions object. private fun createrequestpermissionsobject() { requestpermissions = registerforactivityresult(healthconnectmanager.requestpermissionactivitycontract) { granted -> lifecyclescope.launch { if (granted.isnotempty() && healthconnectmanager.hasallpermissions()) { toast.maketext( this@mainactivity, r.string.permission_granted, toast.length_short, ).show() } else { alertdialog.builder(this@mainactivity) .setmessage(r.string.permission_denied) .setpositivebutton(r.string.ok, null) .show() } } } } sample permission request window: creating a query to read body composition data to read data, build the readrecordsrequest object and in the parameters, specify the time range and the data type. then, read the data by passing the readrecordsrequest object as a parameter. after the request is finished, the result contains the list of returned data that you requested. then you go through the list and read individual records. in our example, we will read only the last value. readrecordsrequest example code for weightrecord data type: suspend fun readweight(start: instant, end: instant): double { val request = readrecordsrequest( recordtype = weightrecord::class, timerangefilter = timerangefilter.between(start, end) ) val response = healthconnectclient.readrecords(request) if (response.records.isnotempty()) { val weightrecord = response.records.last() return weightrecord.weight.inkilograms } return 0.0 } list of all the data types used in the application: basalmetabolicraterecord bodyfatrecord heightrecord weightrecord checking query results now you are ready to run the test application on your phone and compare the results of the application with the samsung health application. the application can be tested on the device by running it directly from android studio. the data in both pictures are identical. you were able to successfully recover the data from the samsung health application using the health connect api. resources this blog is based on the bia viewer application. the entire code in this blog comes from this application. the application can be downloaded from: bia viewer version 1.1 (84,0kb) dec 08, 2023 enjoy your adventure creating the ultimate health application now you are ready to start using the samsung health application with the health connect api to enhance the capabilities of your application.

https://developer.samsung.com/health/blog/en-us/health/blog/reading-body-composition-data-with-galaxy-watch-via-health-connect-api

tutorials mobile

blog

Seamless UI Experience of Your App for Samsung Galaxy Z Fold2

maintaining the legacy of foldable technology, samsung recently released the new galaxy z fold2. this device is designed to provide a new and seamless experience to users with its infinity flex display. as a developer, you can adjust your app to provide the best ui experience to your users. in this blog, we will demonstrate how a stopwatch app can be modified to adjust with galaxy z fold2 devices. the stopwatch app is pretty simple, having three functionalities—start, pause and reset the time. figure 1: stopwatch app example in order to provide a seamless experience to the user, we have to ensure app continuity, adjust the activity according to the ui, support multi-resume in multi-window, and check the display cutout. so let’s get started. app continuity like the previous galaxy z fold, the new galaxy z fold2 has two separate physical screens. the cover display is 2260 x 816 pixels and the main display is 2208 x 1768 pixels. to provide a seamless experience to the user while folding and unfolding the device, the app must maintain its continuity by preventing data loss. you can ensure continuity by using the onsaveinstancestate() method. first, save the data of the current state with onsaveinstancestate(). for the stopwatch app, the time that has passed is saved in seconds before the activity is paused. @override public void onsaveinstancestate(bundle savedinstancestate) { savedinstancestate.putint("seconds", seconds); savedinstancestate.putboolean("running", running); savedinstancestate.putboolean("wasrunning", wasrunning); } then restore the data of the activity using the oncreate() function. @override protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); if (savedinstancestate != null) { seconds = savedinstancestate.getint("seconds"); running = savedinstancestate.getboolean("running"); wasrunning = savedinstancestate.getboolean("wasrunning"); } } figure 2: continuity of the stopwatch while folding and unfolding the device ensure dynamic resizing of your app if you want your app to support multi-window mode, define the activity as resizable. this can be done by setting the resizableactivity attribute to true in manifest.xml. this ensures the maximum compatibility with both the cover screen and the main screen of the device. <activity android:name=".mainactivity" android:resizeableactivity="true"> … </activity> another approach is to define an aspect ratio for your app. galaxy z fold2’s cover screen has a ratio of 25 : 9 whereas the main screen has a ratio of 22.5 : 18. to be compatible with the device, you should test your apps for these ratios and that they fill up the entire display. you can use the minaspectratio or the maxaspectratio flag to constrain your app within the feasible aspect ratios. please note that, if the resizableactivity attribute is set to true, the minaspectratio and the maxaspectratio flag are ignored. figure 3: dynamically resizable app in pop-up view and split-window view multi-resume for multi-window up to android 9, only one of the activities visible in the multi-window operation is allowed to stay in the resumed state. all other activities are put into the paused state. therefore, you have to force your app to be in the resumed state by adding the following in the manifest.xml file. <meta-data android:name="android.allow_multiple_resumed_activities" android:value="true" /> however, starting from android 10, all activities visible in multi-window are allowed to stay in the resumed state. you no longer need to force your app to have multi-resume behavior. however, there are some cases where an app can be in the paused state in android 10, in which case you need to enforce the multi-resume behavior: • in a minimized split-screen (with launcher on the side), the top activity isn't resumed because it's not focusable • in picture-in-picture mode, the activity isn't resumed because it's not focusable • when activities are covered by other transparent activities in the same stack figure 4: multi-resume in multi-window display cutout the main display of the galaxy z fold2 has a punch hole in the upper right side. you can set a display cutout mode according to your content style. by default, the content is rendered into the cutout area while in portrait mode and letterboxed while in landscape mode. if you want your content to be rendered into the cutout area in both portrait and landscape modes, you can define the mode as shortedges. in the sample app, the cutout mode is set to shortedges in the style.xml file. the sample app is set to full screen and display cutout mode is set to shortedges. <item name="android:windowlayoutindisplaycutoutmode">shortedges</item> <item name="android:windowtranslucentnavigation">true</item> figure 5: display cutout default mode figure 6: display cutout in shortedges mode hopefully this blog helps you to update your app for the galaxy z fold2 and give the user a better ui experience. to check out the sample app, click here. you can also view samsung’s official documentation for galaxy z devices. if you have any questions regarding foldable ui, feel free to post it in the samsung developers forums.

Ummey Habiba Bristy

https://developer.samsung.com/sdp/blog/en-us/2020/12/03/seamless-ui-experience-of-your-app-for-samsung-galaxy-z-fold2

tutorials galaxy watch

blog

Understanding Sensor Ranges for Galaxy Watch

a sensor's maximum and minimum values are crucial for calibration, data interpretation, threshold setting, user interface, error handling, sensor selection, and performance optimization. understanding the expected range of values helps identify and handle sensor errors or anomalies, and selecting the right sensor for the intended use case is essential. efficient use of sensor data, especially in resource-constrained environments like mobile devices, can optimize data processing algorithms. the maximum and minimum values of sensors play a crucial role in the accurate and efficient functioning of sensor-based applications across various domains. in this tutorial, a wearable application is developed to collect the maximum and minimum ranges of sensors from a galaxy watch running wear os powered by samsung. this tutorial shows how to retrieve all sensor ranges together, as well as from one specific sensor separately. environment android studio ide is used for developing the wear os application. in this tutorial, java is used, but kotlin can also be used. let’s get started the sensormanager library is used here to collect sensor data from a galaxy watch running wear os powered by samsung. retrieve the maximum range of a sensor to get access and retrieve the maximum ranges from the sensor: in android studio, create a wearable application project by selecting new project > wear os > blank activity > finish. to access the sensor, add the body sensor in the application’s “manifests” file. <uses-permission android:name="android.permission.body_sensors" /> to run the application on devices with android version 6 (api level 23) or later, you need runtime permission from the user to use the body_sensors apis. add the following code snippet to the oncreate() method before calling any sensor operations: if (checkselfpermission(manifest.permission.body_sensors) != packagemanager.permission_granted) { requestpermissions(new string[]{manifest.permission.body_sensors}, 1); } else { log.d("tag___", "already granted"); } after this code executes, a pop-up window appears and requests permission from the user. the sensor apis return values only if the user grants permission. the application asks for permission only the first time it is run. once the user grants permission, the application can access the sensors. figure 1: permission screen more details about runtime permissions can be found here. create an instance of the sensormanager library before using it in the code. private sensormanager sensormanager; sensormanager = (sensormanager)getsystemservice(context.sensor_service); to retrieve the maximum range of all sensors, create a sensor list using api sensor.type_all. list<sensor> sensors = sensormanager.getsensorlist(sensor.type_all); arraylist<string> arraylist = new arraylist<string>(); for (sensor sensor : sensors) { if (sensor != null) { arraylist.add(sensor.getname()); arraylist.add(sensor.getmaximumrange() + ""); arraylist.add(sensor.getresolution() + ""); } } arraylist.foreach((n) -> system.*out*.println(n)); the above code shows the sensor name, maximum range, and resolution. you can get all the available data from the sensors, such as type, vendor, version, resolution, maximum range, and power consumption, by applying this same approach. remember, sensor information may vary from device to device. additionally, not every sensor that appears in the logcat view is accessible. third-party applications are still not allowed to access samsung's private sensors using the android sensormanager. you get a “null” value if you try to access the private sensors. moreover, there are no plans to make these sensors available to the public in the near future. you can check my blog check which sensor you can use in galaxy watch running wear os powered by samsung to find out which sensors are accessible on your galaxy watch and which are not. retrieve the minimum range of a sensor the minimum range is the complement of maximum range. if the maximum range is x, then the minimum range can be calculated like this: x*(-1) = -x. if a specific sensor value should always be absolute, then the minimum range is zero (0). there is no direct api available to retrieve the minimum range of sensors from galaxy watch. get a specific sensor value to get specific sensor values from a galaxy watch, you can filter the sensor list or use the getdefaultsensor() method. here is an example that demonstrates how to do this. add the necessary permission in the “manifests” file for the accelerometer sensor: <uses-feature android:name="android.hardware.sensor.accelerometer" /> use the following code in your activity or fragment to retrieve the accelerometer data: sensor = sensormanager.getdefaultsensor(sensor.type_accelerometer); if (sensor != null) { textview_maxv.settext(textview_maxv.gettext() + "" + sensor.getmaximumrange() + ""); textview_resolution.settext(textview_resolution.gettext() + "" + sensor.getresolution() + ""); } ensure you have added the textview element to your xml file. output of the above code: figure 2: maximum range and resolution of the accelerometer remember, sensor ranges may vary from device to device. you may get different values for different galaxy watch models. download the example from this blog: sensorminxmax (313.2kb) sep 10, 2024 summary this article demonstrates how you can retrieve the maximum and minimum ranges of sensors from your galaxy watch running wear os powered by samsung. you can also use the above approaches to get other necessary available information from the watch that can be used for the precise and effective operation of sensor-based applications in a variety of fields. if you have any questions about or need help with the information in this article, you can reach out to us on the samsung developers forum or contact us through developer support.

Shamima Nasrin

https://developer.samsung.com/sdp/blog/en-us/2024/09/10/understanding-sensor-ranges-for-galaxy-watch

tutorials health, galaxy watch

blog

Tracking Exercises with Galaxy Watch

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

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

Develop GameDev

doc

Resources

adaptive performance resources the following is a collection of documents and resources for adaptive performance announcements, articles, and blogs unity forums announcement - adaptive performance package best practices for mobile game developers and artists, 2021 may build stunning mobile games that run smoothly with adaptive performance, 2021 mar android game analysis with arm mobile studio, 2020 sep create astc textures faster with the new astcenc 2 0 open source compression tool, 2020 sep higher fidelity and smoother frame rates with adaptive performance, 2019 apr vulkan extensions for mobile new game changing vulkan extensions for mobile timeline semaphores, 2021 jul new game changing vulkan extensions for mobile buffer device address, 2021 jul new game changing vulkan extensions for mobile descriptor indexing, 2021 jun new vulkan extensions for mobile legacy support extensions, 2021 jun new vulkan extensions for mobile maintenance extensions, 2021 jun video sessions and talks gdc 2021 - galaxy gamedev bringing high quality gaming experiences to mobile unite now 2020 - build better aaa mobile games with adaptive performance sdc19 - a deep look inside games gamesdk and unity adaptive performance unite 2019 - bringing call of duty to mobile gdc 2019 keynote - improve mobile game performance in real time with adaptive performance gdc 2019 - megacity on mobile how we optimized it with adaptive performance unity documentation android game development mobile solutions optimize your mobile game performance release marketing user guide, v2 1 1

https://developer.samsung.com/galaxy-gamedev/adaptive-performance-resources.html

tutorials

blog

What's New for Tizen on Xamarin.Forms 4.1.0

this blog introduces the many new ui features that were added on xamarin.forms 4.0, including shell, collectionview and material visual. tizen support for these features was added on xamarin.forms 4.1.0, which has been released on nuget. shell the xamarin.forms shell feature reduces the complexity of building mobile apps by providing fundamental app architecture features. for more details on shell, see shell navigation documentation shell provides three types of common mobile navigation: flyout bottom tabs top tabs collectionview collectionview is used to present lists of data using different layout specifications. it provides a more flexible and performant alternative to listview. for more details on collectionview, see collectionview documentation material visual material design is an opinionated design system created by google, which prescribes the size, color, spacing, and other aspects of how views and layouts should look and behave. xamarin.forms provides the way to apply material design across the platforms to controls in xamarin.forms apps. this is achieved with material renderers that apply the material design rules. for more details on collectionview, see material visual documentation because xamarin.forms 4.1.0 includes material renderers for tizen, you can implement a material look and feel in your tizen .net app without any custom renderers. supported controls in tizen are: activityindicator button frame entry progressbar slider checkbox stay up to date with the latest tizen .net developments at the samsung developers tizen.

Sunghyun Min

https://developer.samsung.com/tizen/blog/en-us/2019/07/15/whats-new-for-tizen-on-xamarinforms-410

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.