Jump to content

Sign in to follow this  
STF News

Vulkan Mobile Best Practice: How To Configure Your Vulkan Swapchain

Recommended Posts

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.


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:


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.

View the full blog at its source

Share this post

Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Sign in to follow this  

  • Similar Topics

    • By STF News
      Blockchain, an emerging technology, is a distributed database for storing and managing records of transactions. It has already created a huge impact in the financial sector.
      The transaction is the main feature in any blockchain-based system. In Ethereum, one of the better-known blockchain systems, every transaction is executed by either an account or a smart contract. When an account tries to execute a transaction, it creates one and publishes it in the Ethereum blockchain. Every transaction needs to pass the consensus process. Some nodes in the Ethereum blockchain, known as miners, validate and authenticate the transaction. “Gas” is an incentive that is paid out for executing transactions. On the Ethereum platform, gas is paid to miners for completing the consensus process.
      The Samsung Blockchain Platform SDK enables Android developers to develop applications that interact with the Etherum blockchain platform. In addition to transactions, the Samsung Blockchain Platform SDK also supports operations related to smart contracts and tokens.
      Through a sample application, this blog describes how to use the Samsung Blockchain Platform SDK to transfer Ether, which is the base coin for the Ethereum platform.
      Before the application can make a transaction, it must first perform the following actions in order:
      Initialize and create the instance Connect to the hardware wallet Get the account Let’s associate each of these actions with a button in our sample application.

      1. Initialize and create the instance
      In the Android project, integrate the Samsung Blockchain Platform SDK with the application and mention all the dependencies in build.gradle. Next, create an instance of the Sblockchain class.
      2. Connect to the hardware wallet
      The Samsung Blockchain Platform provides an interface to connect to hardware wallets, which are special devices that securely store private keys. Samsung mobile devices have an integrated hardware wallet, the Samsung Blockchain Keystore. Besides the Samsung Blockchain Keystore, the Samsung Blockchain Platform also supports USB-connected Ledger devices and BLE-connected Nano X devices.
      The sample application connects to the Samsung Blockchain Keystore hardware wallet. Before you run the sample application on your device, check that the device is supported. You can also modify the sample application and test it with other supported hardware wallets.
      3. Get the account
      An account is a gateway for interacting with the Ethereum blockchain. Each account consists of a private and public key pair, for which the shortened public key is the account address. Every initial action in the Ethereum blockchain must be initiated by an account.
      The Samsung Blockchain Platform SDK enables the user to create a new account or to restore their accounts from the Ethereum network. Account management features in the Samsung Blockchain Platform SDK include generating, restoring and fetching accounts. Because they are network operations, the create account and restore accounts operations must perform asynchronously.
      After creating a new account, the user must utilize the account to receive or send Ether before the Samsung Blockchain Platform SDK allows them to create another account.
      If you do not have any Ether to use with the sample application, you can use test Ether.

      Performing Ether Transactions
      The sendTransaction API of the Samsung Blockchain Platform SDK initiates a transaction between two accounts. It requires the following information in its parameters:
      wallet: connected hardware wallet fromAccount: sender’s Ethereum account address gasPrice: price of each gas unit, which defines how quickly someone wants to execute the transaction gasLimit: maximum number of gas units to spend on the transaction toAddress: recipient’s Ethereum account address value: amount of Ethereum to transfer, in wei (1 eth = 10^18 wei). nonce: transaction counter for the account. The CoinService class named EthereumService provides methods needed to create transactions on the Ethereum platform. For example, the getFeeInfo() and estimateGasLimit() methods can retrieve the values for use with the gasPrice and gasLimit parameters, respectively.
      To communicate with the Ethereum node, RPC is also needed. In the sample application, the Infura node is used to access the Ethereum blockchain. Learn about integrating the Infura API with the JSON RPC.
      CoinType coinType = CoinType.ETH; NetworkType networkType = (NetworkType) EthereumNetworkType.ROPSTEN; //might use your own rpc String rpc = "https://ropsten.infura.io/v3/71cf9f88c5b54962a394d80890e41d5b"; // creating coinNetworkInfo CoinNetworkInfo mCoinNetworkInfo = new CoinNetworkInfo(coinType, networkType, rpc); //Creating CoinService CoinService mCoinService = CoinServiceFactory.getCoinService (getApplicationContext(), mCoinNetworkInfo); //Creating EthereumService EthereumService ethereumService = (EthereumService) mCoinService; //Access TextView and EditTexts on UI private RadioGroup transactionSpeedGroup = findViewById(R.id.transaction_speed_radio_group); private TextView gasLimitText = findViewById(R.id.gas_limit_text_view); private EditText toAddressEditText = findViewById(R.id.to_address); private EditText sendAmountEditText = findViewById(R.id.send_amount); Retrieve the gas price
      Gas price retrieval is an asynchronous task. Use the getFeeInfo API to retrieve the gas price. The getFeeInfo API returns three gas prices which depend on the speed of the transaction: fast, normal, and slow.
      To give full control over the gas price for advanced users, you can also enable numerical price input.
      In the sample application, when the user selects Gas Price, an asynchronous task retrieves the three gas prices, and assigns them to radio buttons. The user can select the transaction speed they want based on the gas price.
      public void OnClickGasPrice(View view) { ethereumService = (EthereumService) mCoinService; ethereumService.getFeeInfo().setCallback(new ListenableFutureTask.Callback<EthereumFeeInfo>() { @Override public void onSuccess(EthereumFeeInfo ethereumFeeInfo) { convertedAmount = EthereumUtils.convertWeiToGwei(ethereumFeeInfo.getNormal()); Log.i(LOG_TAG, "Fee info is fetched successfully."); mEthereumFeeInfo = ethereumFeeInfo; runOnUiThread(() -> { gasLimitButton.setEnabled(true); Toast.makeText(getApplicationContext(), "Fee info is fetched successfully.", Toast.LENGTH_SHORT).show(); } ); } @Override public void onFailure(@NotNull ExecutionException e) { Log.e(LOG_TAG, "Fetching Fee info is failed."); Log.e(LOG_TAG, "" + e.getMessage()); } @Override public void onCancelled(@NotNull InterruptedException e) { Log.e(LOG_TAG, "Fetching Fee info is canceled."); } }); } Fetching the gas limit
      Fetching the gas limit is also an asynchronous task. Use the estimateGasLimit API to calculate the gas limit. The input parameters are the account addresses of the sender and the receiver, the amount of Ether (in wei units), and the data to be sent.
      The sample application sends only Ether, so the data field is null. When the user selects Gas Limit, the gas limit is determined and shown on the screen.
      public void onClickGasLimit(View view) { String toAddress = toAddressEditText.getText().toString(); String amount = sendAmountEditText.getText().toString(); if (toAddress.isEmpty() || amount.isEmpty()) { Toast.makeText(getApplicationContext(), "Fill Send Address and Amount Field", Toast.LENGTH_SHORT).show(); } else if(!ethereumService.isValidAddress(toAddress)){ Toast.makeText(getApplicationContext(), "Invalid Address.", Toast.LENGTH_SHORT).show(); } else { BigDecimal sendAmount = new BigDecimal(amount); BigInteger convertedSendAmount = EthereumUtils.convertEthToWei(sendAmount); ethereumService.estimateGasLimit((EthereumAccount) mFirstAccount, toAddress, convertedSendAmount, null).setCallback(new ListenableFutureTask.Callback<BigInteger>() { @Override public void onSuccess(BigInteger bigInteger) { mGasLimit = bigInteger; Log.i(LOG_TAG, "Gas limit is fetched successfully."); Log.i(LOG_TAG, "Gas limit is:" + bigInteger.toString()); runOnUiThread(() -> { sendButton.setEnabled(true); gasLimitText.setText(bigInteger.toString()); }); } @Override public void onFailure(@NotNull ExecutionException e) { Log.e(LOG_TAG, "Fetching Gas limit is failed."); Log.e(LOG_TAG, "" + e.getMessage()); } @Override public void onCancelled(@NotNull InterruptedException e) { Log.e(LOG_TAG, "Fetching Gas limit is canceled."); } }); } }
      Send the Ether
      All the parameter values needed to send the Ether are now known. Use the sendTransaction API to initiate the transaction.
      In the sample application, the value of the nonce parameter has not been set manually. By leaving the value null, the platform handles the nonce value itself. If the transaction is successful, the onSuccess() event handler returns the transaction hash.
      A record of every Ethereum transaction is viewable in Etherscan, a blockchain explorer. It allows anyone to explore addresses, transactions, and tokens in the Ethereum blockchain.
      public void onClickSend(View view) { String toAddress = toAddressEditText.getText().toString(); BigDecimal sendAmount = new BigDecimal(sendAmountEditText.getText().toString()); BigInteger convertedSendAmount = EthereumUtils.convertEthToWei(sendAmount); //Getting Gas Price int transactionSpeedID = transactionSpeedGroup.getCheckedRadioButtonId(); if (transactionSpeedID == -1) { Toast.makeText(getApplicationContext(), "Select a Transaction Speed.", Toast.LENGTH_SHORT).show(); } else { switch (transactionSpeedID) { case R.id.transaction_speed_slow: mGasPrice = mEthereumFeeInfo.getSlow(); Log.d(LOG_TAG, "GasPrice: " + mGasPrice); break; case R.id.transaction_speed_normal: mGasPrice = mEthereumFeeInfo.getNormal(); Log.d(LOG_TAG, "GasPrice: " + mGasPrice); break; case R.id.transaction_speed_fast: mGasPrice = mEthereumFeeInfo.getFast(); Log.d(LOG_TAG, "GasPrice: " + mGasPrice); break; } } if(transactionSpeedID != -1) { try { ethereumService.sendTransaction(mHardwareWallet, (EthereumAccount) mFirstAccount, mGasPrice , mGasLimit, toAddress, convertedSendAmount, null).setCallback(new ListenableFutureTask.Callback<TransactionResult>() { @Override public void onSuccess(TransactionResult transactionResult) { Log.d(LOG_TAG, "Transaction Hash: " + transactionResult.getHash()); runOnUiThread(() -> Toast.makeText(getApplicationContext(), "Transaction Hash: " + transactionResult.getHash(), Toast.LENGTH_SHORT).show() ); } @Override public void onFailure(@NotNull ExecutionException e) { Log.e(LOG_TAG, "Transaction failed."); Log.e(LOG_TAG, "" + e.getMessage()); } @Override public void onCancelled(@NotNull InterruptedException e) { Log.e(LOG_TAG, "Transaction canceled."); } }); } catch (AvailabilityException e) { Log.e(LOG_TAG, "Error in sending: " + e); } } } Conclusion
      This blog has demonstrated how you can send Ether to another account, an example of a feature you can implement in a wallet application using the Samsung Blockchain Platform SDK.
      Check the Samsung Developers site periodically for updates as Samsung Blockchain Platform SDK keeps expanding support for new platforms.
      Additional Resources:
      Samsung Blockchain Platform SDK Transaction Sample Application Samsung Blockchain Platform SDK documentation View the full blog at its source
    • By STF News
      En este video del Programa para desarrolladores de Samsung, aprenda cómo integrar el SDK de compras en la aplicación (IAP) de Samsung en sus juegos de Unity.
      Puede obtener más información en https://developer.samsung.com/iap
      El proceso general para publicar su juego, cuando incluye pagos y microtransacciones por medio del Samsung IAP SDK es el siguiente:

      1- Registro en el Portal
      Para crear su cuenta y publicar en la Galaxy Store puede ir a http://seller.samsungapps.com
      Haga clic en la esquina superior para crear su cuenta. Si ya tiene una cuenta de Samsung, puede ingresar con ella.

      2- Solicitar el Status de Vendedor
      Una vez que haya creado su cuenta en el portal de desarrollo, puede solicitar su estatus de vendedor haciendo clic en el botón indicado en la imagen. Esto es necesario para poder vender diferentes artículos desde su aplicación.

      3- Registrar su Aplicación/Juego
      Para ver todo el detalle de cómo registrar su aplicación en el portal de ventas, puede ver el video que se encuentra en https://youtu.be/fil7DmD1v3g
      En general, se le va a solicitar que ingrese la información de su juego, como el nombre, descripción e imágenes promocionales.
      4- Registro de los Artículos en Venta
      Cuando su cuenta ha sido aprobada como una cuenta de vendedores, podrá tener acceso a la sección de “In App Purchase”.

      Aquí podrá registrar los diferentes artículos que va a vender, como vidas ilimitadas, poderes especiales, u opciones de personalización para los personajes de su juego.
      En el video podrá ver un poco más de detalle de cómo registrar cada uno de los artículos.
      Plugin para Unity
      Para poder usar el kit de desarrollo de la Samsung IAP, debe seguir los siguientes pasos:
      1- Descargar desde https://developer.samsung.com/iap/samsung-iap-unity-plugin.html
      2- Instalar el Plugin
      a. En Unity haga clic en Assets -> Import Package -> Custom Package
      3- Arrastrar el Script en un objeto del juego
      a. Este puede ser cualquier objeto de la UI, o como se ve en el video, un personaje de su juego. Una vez que haya incluido el Script, puede revisar la documentación (https://developer.samsung.com/iap/samsung-iap-unity-plugin.html) para ver en detalle cómo llamar la SDK desde el código de su juego, pero aquí tiene los conceptos básicos:
      Modo de operación
      Para que la Galaxy Store sepa si su juego está realizando pruebas, o si ya està en modo de producción, debe usar el método SetOperationMode.
      SamsungIAP.Instance.SetOperationMode(OperationMode.OPERATION_MODE_TEST); Los posibles valores para el parámetro son OperationMode.OPERATION_MODE_TEST, OperationMode.OPERATION_MODE_TEST_FAILURE, y OperationMode.OPERATION_MODE_PRODUCTION.
      Solicitar información de los artículos disponibles en venta
      Para saber qué artículos se pueden ofrecer desde el juego, debe invocar el método GetProductDetails.
      SamsungIAP.Instance.GetProductDetails("com.mygame.product1, com.mygame.product2,com.mygame.product3", OnGetProductsDetails); En este ejemplo se está solicitando la información de los productos 1, 2, y 3, ya que se está enviando los identificadores de esos productos, separados por comas.
      SamsungIAP.Instance.GetProductDetails("", OnGetProductsDetails); En este ejemplo se esta pidiendo la información de todos los productos disponibles, ya que no se está enviando ningún identificador de productos.
      Iniciar un pago
      Para poder empezar la compra de un producto se debe invocar el método StartPayment.
      SamsungIAP.Instance.StartPayment("com.mygame.product1", "pass_through_value", OnPayment); En este ejemplo se está iniciando la transacción para el “com.mygame.product1”.
      Usted puede especificar el valor del segundo parámetro y utilizarlo para verificar el éxito de la compra.
      Y por último se especifica el “callback”, que es el método que se va a invocar cuando se finalice la transacción, sin importar si esta fue exitosa o no.
      Artículos Consumibles
      Usted puede usar el método ConsumePurchasedItems para reaprovisionar productos consumibles. Así el jugador puede comprar energía en su juego cuantas veces quiera, por ejemplo.
      El primer parámetro es el identificador de la compra del artículo.
      SamsungIAP.Instance.ConsumePurchasedItems(purchase_id, OnConsume); Y el segundo parámetro es el método OnConsume que se activa cuando el proceso ha terminado, y este contiene información sobre el artículo consumido y el procesamiento de llamadas a la API.
      Consultar productos adquiridos anteriormente
      Para obtener la lista de todos los productos que un jugador ha comprado, puede usar el método GetOwnedList.
      SamsungIAP.Instance.GetOwnedList(ItemType.all, OnGetOwnedList); El primer parámetro puede ser ItemType.all, ItemType.item, o ItemType.subscription.
      Con ItemType.all el método devuelve todos los artículos no consumibles comprados, los artículos consumibles que no se han consumido y los artículos de suscripción con suscripciones activas.
      Con ItemType.item el método devuelve todos los artículos no consumibles comprados y los artículos consumibles que no se han consumido.
      Y por último, con ItemType.subscription el método devuelve todos los artículos de suscripción comprados con suscripciones activas.
      El segundo parámetro, es el método que se activará cuando el proceso ha finalizado.
      Para obtener más tutoriales, visite Samsung Developers. (http://developer.samsung.com/)
      View the full blog at its source
    • By STF News
      In this episode of POW, we interview Prasad Rayala, Product Manager for DeX, the Samsung technology that allows users to extend their Galaxy mobile device into a desktop computing experience. Not only do we talk about the advantages for developers optimizing their apps for DeX, but how easy it is to get started.
      Topics Covered:
      What is DeX Devices that run DeX Compatible operating systems Optimizing apps for DeX DeX resources DeX sample code Security DeX features Getting started with DeX  
        View the full blog at its source
    • By STF News
      All the goodies coming soon to a purple planet near you
      Today we are happy to announce our latest Samsung Internet Beta which includes new features, enhancement to existing features and UI refinements. We will go through the most notable changes available with this beta, that will be hitting 13.0 stable later this year. You can download the beta here.
      Permission Request UI
      Privacy and security are paramount for Samsung Internet. Nowadays websites ask for more and more permissions and in order to access content quickly, many users have gotten accustomed to just dismissing these prompts, which can lead to unwanted notifications. We are changing the permission request UI to display a warning message. This change makes it harder to trick or force users into allowing notifications, specially from those sites that like to mislead their users into accepting notifications. (side note, if you are a developer, do use notifications responsibly.)
      Double-tap to Play/Pause your videos
      One way or another, we eventually run into video content on the web. Sometimes we want to experience this content on Fullscreen, and sometimes, trying to reach those playback controls can be a bit harder than expected. Good news is that with version 13.0 beta, we are enabling the user to play or pause content while in video assistant fullscreen by double tapping the center area of the screen. No more hunting down for that little play/pause button, just smooth time saving clever UI for you.
      Easy editing of your quick bookmarks
      You’re on a page, you want to bookmark it, so you press the star icon in the toolbar. Snaps! It has a long generic title of the page, and that’s not very easy for you to look back through your bookmarks. Fear not, we’ve enabled in 13.0 beta a way to edit your bookmark right from the toast notification you get once you press that bookmark icon. Nice custom bookmark title. You’re welcome!
      Add-on extension API expansion
      Here’s an interesting one for all you extension developers out there: we’ve expanded the browser extension APIs available in Samsung Internet. These are the new API modules available: WebRequest, Proxy, Cookies, Types, History, Alarms, Privacy, Notifications, Permissions, Idle and Management. How cool is this you ask? It allows for the development of new experiences in the browser like the ones described below! If you are new to extension development and are keen on more information, do check this link.
      We are thrilled to present to you one first party extension and two third party ones that ride on these new features.
      On-device translation (1st party)
      As its name states, Samsung Internet 13.0 beta can now offer on-device translation via an extension. This works for English, Korean, German, Spanish, French, Italian and Portuguese. Browse foreign sites like a true native.
      Web Proxy (NordVPN extension — 3rd party)
      For those of us that use VPNs this is a welcome feature. For those of us that use NordVPN it’s an exciting time to be alive. NordVPN can now be integrated into the browser experience as an extension.

      Password Manager (Dashlane extension — 3rd party)
      Also, possible due to the new Add-on API expansion, we have a password manager extension that integrates Dashline into Samsung Internet 13.0 beta. And yes, if you’re not using a password manager it’s never too late to look into one.
      Better User privacy in Secret Mode

      There is now a better and more detailed explanation of what Secret Mode consists of. We have added this to the initial Secret Mode launch page. In this same vein, we have added an ‘About Secret Mode’ section in the settings to make it absolutely transparent how it helps you protect your privacy. The news feed in the Quick Access homepage is now gone as well.
      OneUI 3.0 enhancements
      OneUI was introduced several years ago and it is reaching it’s third iteration. Some changes are making their way into the browser and enhancing the overall one-handed experience. One of these changes is immersive scroll. This will make non scrollable elements like the status and navigation UI hide when you are scrolling, allowing you to focus on the content you are manipulating.
      OneUI 3 also brings an expandable app bar into bookmarks, saved pages, history, downloads, ad blocker, add-ins and settings. This expandable info provides useful information on the tap of a button.
      Additionally, we’re bringing the “more menu” button down to the lower bar to facilitate you reaching those actions present in sections like tab manager and downloads. Your fingers feel more rested already!
      Status bar visibility
      Screen real estate is a value asset for many of us, and our web experiences can now enjoy more of it! We are allowing users to hide or show the status bar while viewing websites. It is a small change that goes a long way for those that like to be immersed in their content with as little distractions as possible. Enabling this will make the status bar disappear when scrolling up and reappear when scrolling down. Web content never looked better on those infinity displays.
      (Even) More changes
      You can now use High Contrast mode when Dark mode is on.
      Samsung Internet now displays a Secret mode icon next to the address bar in order to make it easier to know when you are browsing in secret mode.
      There is a new sleek tab design that features a rounded tab shape (this browser keeps on getting prettier by the version).
      New rounded tab UI
      You can now see the icons of the search engines when choosing your default one. Makes it easier to modify your favorite engines!
      History for allowed apps: you can now see a detailed history for the apps than can call Samsung Internet. This includes which URL was requested and the timestamp.
      Last but certainly not least, there is an under the hood upgrade of the web engine: version 13.0 will be based on M83. As you can see, plenty of changes and enhancements that we can’t wait for you to try! Let us know what you think about these changes and what would you like to see in the future. You can download the beta here.

      View the full blog at its source
    • By Lokman Çam
      i own a samsung tv Q7FN. Samsung tizen tv automatic update took place in early August. After the update, no ip tv application can open channels.
      Lists load smoothly, but no streaming. Neither TV channel nor movies can be started. Apps I've tried SS İP TV - OTT PLAYER - DUPLEX İP TV ...
      How can this problem be solved? Please help

  • Create New...