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

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

best of galaxy store awards celebrating the year’s top performing apps. the 2022 best of galaxy store awards are here! watch the awards on youtube, as we celebrate the acheivements of these great developers, designers, and content creators. video thumbanil 2022 award winners view previous award winners these are the categories that were honored with the 2022 best of galaxy store awards. we thank these partners for their hard work and innovations. best theme collection pengtai interactive advertising co. best wallpaper collection bergen best icon pack collection cogul planet best music app sirius xm streaming by sirius xm radio, inc. best entertainment app vudu by fandango media best bixby capsule scorestream best bixby developer farefirst by amahop technologies best podcast partner acast best podcast solar by curtco media best strategy game pokémon go by niantic, inc. best tower defense game kingdom guard by tap4fun best mmo game evony: the king’s return by top games inc. game of the year catalyst black by super evil megacorp success stories go to blog learn how previous award winners have been successful

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

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

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

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

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!

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

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.