• Learn
    • Code Lab
    • Foldables and Large Screens
    • One UI Beta
  • Develop
    • Mobile/Wearable
    • Galaxy GameDev
    • Galaxy Themes
    • Galaxy Watch
    • Health
    • Samsung Blockchain
    • Samsung DeX
    • Samsung IAP
    • Samsung Internet
    • Samsung Pay
    • Samsung Wallet
    • View All
      • Galaxy AR Emoji
      • Galaxy Accessory
      • Galaxy Edge
      • Galaxy Z
      • Galaxy Performance
      • Galaxy FM Radio
      • Galaxy S Pen Remote
      • Galaxy Sensor Extension
      • PENUP
      • Samsung Automation
      • Samsung Neural
      • Samsung TEEGRIS
      • Samsung eSE SDK
      • Galaxy Watch for Tizen
      • Watch Face Studio
      • One UI Watch for Tizen
      • Galaxy Watch Studio Converter
      • Samsung IAP for Galaxy Watch (Tizen)
    • Visual Display
    • Smart TV
    • Smart Hospitality Display
    • Smart Signage
    • Digital Appliance
    • Family Hub
    • Platform
    • Bixby
    • Knox
    • SmartThings
    • Tizen.NET
  • Design
    • Design System
    • One UI
    • One UI Watch
    • Smart TV
  • Distribute
    • Galaxy Store
    • TV Seller Office
    • Galaxy Store Games
    • Instant Plays
  • Support
    • Developer Support
    • Remote Test Lab
    • Samsung Android USB Driver
    • Galaxy Emulator Skin
  • Connect
    • Blog
    • News
    • Forums
    • Events
    • Samsung Developer Conference
    • SDC23
    • SDC22
    • SDC21
    • SDC19 and Previous Events
  • Sign In
Top Global Search Form
Recommendation
  • Blog
  • Code Lab
  • Foldable and Large Screen Optimization
  • Forums
  • Galaxy Emulator Skin
  • Galaxy GameDev
  • Health
  • Remote Test Lab
  • SDC22
  • Watch Face Studio
All Search Form
Recommendation
    Suggestion
      All Search Form
      Filter
      Filter
      Filter
      • ALL (100)
      • DOCS
      • SDK
      • API REFERENCE
      • CODE LAB
      • BLOG
      • NEWS/EVENTS
      • OTHERS
        api reference code lab blog news/events
      1. tutorials | web, galaxy watch

      blog

      Tizen Tidbits: How to Deploy your Tizen App on a Device

      in the latest video in the tizen tidbits series, we will demonstrate how to take your tizen app and deploy it on a wearable device. running your app on an actual device is particularly helpful if you want to test the watch sensors or just figure out how your app acts in real-life conditions. check out other videos, blog posts, and tips to improve your tizen app development. check the tizen tidbits playlist on our youtube channel and learn more about the wide selection of samsung technologies on our developer portal.

      Diego Lizarazo Rivera

      https://developer.samsung.com/sdp/blog/en-us/2020/03/30/tizen-tidbits-how-to-deploy-your-tizen-app-on-a-device
      1. tutorials | galaxy watch, web

      blog

      Tizen Tidbits: Your First Tizen Web Application

      in the latest installment of the tizen tidbits series, we will be covering the code basics to create your first tizen web application. by the end of the video, you will understand the structure of projects in tizen studio, how to modify the core files of your web application, and how to use the emulator to test your app. check other videos, blog posts, and tips to improve your tizen app development. stay tuned for more web and .net app development for the galaxy watch, and don’t forget to visit our developer portal to learn more about samsung technologies.

      Diego Lizarazo Rivera

      https://developer.samsung.com/sdp/blog/en-us/2020/03/10/tizen-tidbits-your-first-tizen-web-application
      1. tutorials | mobile, game

      blog

      Integration of Samsung IAP Services in Android Apps

      selling digital content is a popular business all over the world. if you are interested in selling your digital items in the samsung ecosystem, then you need to learn about the samsung in-app purchase (iap) sdk. you can implement samsung iap in your android, unity, and unreal applications. since server to server communication is more secure and reliable, payment transaction should be verified from the iap server. this is the second of two blogs on this topic. in the first part, we discussed how to integrate samsung’s iap server api into your app’s server. in this blog, we will learn how to communicate with your server through an android app. please go through the documentation of samsung iap sdk to integrate samsung iap sdk in your app. then build your own app server for server verification which is covered in the first part of this blog. to know about server api, read samsung iap server api. get started let’s learn through a simple android game. this game has an item which can only be used for a certain period of time. so, it is a subscription type item. if a user buys this item, then the item will be available after purchase verification. when the app is launched, the app checks if this item is already subscribed or not. there can be one of two results: the item is not subscribed, then the app offers to subscribe this item. the item is subscribed then the app gets the current status of this subscription through getsubscriptionstatus server api. the subscription status can be active or cancel. subscription can be canceled for various reasons. if the iap server returns the subscription status as ‘cancel’ then the app notifies it to the user. implementation of these two cases are discussed in the next sections. implement android iap at first, integrate samsung iap sdk in your android app and register it in the seller office to test in-app items. when the app is launched, call getownedlist() api. it returns a list of in-app items that the app user currently has from previous purchases. if the item is not in this list, then the app offers to purchase the item. to purchase any item, call startpayment(). this api notifies the end user if the purchase succeeded or failed. if the purchase is successful, then do the server verification. if your app’s server validates the purchase, then make the item available to the user, otherwise request user to purchase it again. public void onpayment(errorvo _errorvo, purchasevo _purchasevo) { if (_errorvo != null) { if (_errorvo.geterrorcode() == iaphelper.iap_error_none) { if (_purchasevo != null) { if (mpassthroughparam != null && _purchasevo.getpassthroughparam() != null) { if (mpassthroughparam.equals(_purchasevo.getpassthroughparam())) { if (_purchasevo.getitemid().equals(item_id_subscription)) { mmainactivity.setbackgroundpurchaseid(_purchasevo.getpurchaseid()); new purchaseverification(mmainactivity).execute(_purchasevo.getpurchaseid()); } } } } } } } if the item is available in this list, then detailed information of this item such as purchase id will be available in the ownedproductvo type arraylist. to call getsubscriptionstatus server api, we need the purchase id of the item. so, send this id to your app’s server to get the status of the subscribed item. public void ongetownedproducts(errorvo _errorvo, arraylist<ownedproductvo> _ownedlist) { if (_errorvo != null) { if (_errorvo.geterrorcode() == iaphelper.iap_error_none) { if (_ownedlist != null) { for (ownedproductvo item : _ownedlist) { if (item.getitemid().compareto(itemname.item_id_subscription) == 0) { // check whether subscription is canceled or not. new subscriptiondetails(mmainactivity).execute(item.getpurchaseid()); } } } } else { log.e(tag, "ongetownedproducts errorcode [" + _errorvo.geterrorcode() +"]"); } } } connect your app with your app server create an asynchronous task for communicating with the server. this task has two parts. one is to send purchase id to your app server and the other is to receive the result from the app server. use doinbackground() method for these two tasks. return this result to your main ui through onpostexecute() method. create a class which extends asynctask<string,void,string> for server verification. then write the following code in doinbackground() method to send the purchase id: cookiehandler.setdefault( new cookiemanager( null, cookiepolicy.accept_all ) ); try{ url url = new url("http:// "); //url of your app’ server urlconnection connection = url.openconnection(); connection.setdooutput(true); connection.setdoinput(true); outputstreamwriter out = new outputstreamwriter(connection.getoutputstream(); string y = ""; for(int i = 0;i < x.length;i++) { y = y + x[i]; } out.write(y); out.close(); }catch(exception e){ } receive to the server verification result using the following code: string output = ""; bufferedreader in = new bufferedreader(new inputstreamreader(connection.getinputstream())); string s = ""; while((s = in.readline())!= null) { output = output + s; in.close(); } return output; now, create an interface called serverresponse and implement it in an activity where you want to show the result from your app’s server. public interface serverresponse { void processfinish(string output); } after receiving the result from the server, return the result to your main ui through onpostexecute() method. protected void onpostexecute(string result) { serverresponse.processfinish(result); } test your app let’s test the app. upload your web app onto a server. then use that url in your app to check server verification in doinbackground() method. keep in mind that samsung in-app purchase can’t be tested in an emulator of android studio. so use a samsung device to test your app. read the test guide before starting to test your app. a simple android game is attached at the end of this article where app to server communication is implemented. this game has a blue background image which can be subscribed. if this item is not in an active subscription period, then the app offers to subscribe the background. if the user purchases the item, then the game verifies the purchase through the server. if the purchase is verified, then it shows that the subscription status is activated and the app makes the item available. if the user unsubscribes the item from the galaxy store, subscription status becomes ‘cancel’. however, as the active subscription period has not ended yet, the item is still available in the app. wrapping up in these two blogs, we have covered the full communication between your app, server and iap server. now you will be able to implement purchase verification through your server. if your app is free but has some premium contents, then you can monetize your app. samsung in-app purchase provides many ways to earn money from your app. go to galaxy store games to find out more details about it. download the simple android game from galaxy store download the simple android game from here 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.

      Jakia Sultana

      https://developer.samsung.com/sdp/blog/en-us/2021/03/10/integration-of-samsung-iap-services-in-android-apps
      1. tutorials | game, mobile

      blog

      New Game Changing Vulkan Extensions for Mobile: Descriptor Indexing

      the samsung developers team works with many companies in the mobile and gaming ecosystems. we're excited to support our partner, arm, as they bring timely and relevant content to developers looking to build games and high-performance experiences. this vulkan extensions series will help developers get the most out of the new and game-changing vulkan extensions on samsung mobile devices. as i mentioned previously, android is enabling a host of useful new vulkan extensions for mobile. these new extensions are set to improve the state of graphics apis for modern applications, enabling new use cases and changing how developers can design graphics renderers going forward. these extensions will be available across various android smartphones, including the new samsung galaxy s21, which was recently launched on 14 january. existing samsung galaxy s models, such as the samsung galaxy s20, also allow upgrades to android r. i have already discussed two of these extensions in previous blogs - maintenance extensions and legacy support extensions. however, there are three further vulkan extensions for android that i believe are ‘game changers’. in the first of three blogs, i will explore these individual game changer extensions – what they do, why they can be useful and how to use them. the goal here is to not provide complete samples, but there should be enough to get you started. the first vulkan extension is ‘descriptor indexing.’ descriptor indexing can be available in handsets prior to android r release. to check what android devices are available with 'descriptor indexing' check here. you can also directly view the khronos group/ vulkan samples that are relevant to this blog here. vk_ext_descriptor_indexing introduction in recent years, we have seen graphics apis greatly evolve in their resource binding flexibility. all modern graphics apis now have some answer to how we can access a large swathes of resources in a shader. bindless a common buzzword that is thrown around in modern rendering tech is “bindless”. the core philosophy is that resources like textures and buffers are accessed through simple indices or pointers, and not singular “resource bindings”. to pass down resources to our shaders, we do not really bind them like in the graphics apis of old. simply write a descriptor to some memory and a shader can come in and read it later. this means the api machinery to drive this is kept to a minimum. this is a fundamental shift away from the older style where our rendering loop looked something like: render_scene() { foreach(drawable) { command_buffer->update_descriptors(drawable); command_buffer->draw(); } } now it looks more like: render_scene() { command_buffer->bind_large_descriptor_heap(); large_descriptor_heap->write_global_descriptors(scene, lighting, shadowmaps); foreach(drawable) { offset = large_descriptor_heap->allocate_and_write_descriptors(drawable); command_buffer->push_descriptor_heap_offsets(offset); command_buffer->draw(); } } since we have free-form access to resources now, it is much simpler to take advantage of features like multi-draw or other gpu driven approaches. we no longer require the cpu to rebind descriptor sets between draw calls like we used to. going forward when we look at ray-tracing, this style of design is going to be mandatory since shooting a ray means we can hit anything, so all descriptors are potentially used. it is useful to start thinking about designing for this pattern going forward. the other side of the coin with this feature is that it is easier to shoot yourself in the foot. it is easy to access the wrong resource, but as i will get to later, there are tools available to help you along the way. vk_ext_descriptor_indexing features this extension is a large one and landed in vulkan 1.2 as a core feature. to enable bindless algorithms, there are two major features exposed by this extension. non-uniform indexing of resources how resources are accessed has evolved quite a lot over the years. hardware capabilities used to be quite limited, with a tiny bank of descriptors being visible to shaders at any one time. in more modern hardware however, shaders can access descriptors freely from memory and the limits are somewhat theoretical. constant indexing arrays of resources have been with us for a long time, but mostly as syntactic sugar, where we can only index into arrays with a constant index. this is equivalent to not using arrays at all from a compiler point of view. layout(set = 0, binding = 0) uniform sampler2d textures[4]; const int constant_value = 2; color = texture(textures[constant_value], uv); hlsl in d3d11 has this restriction as well, but it has been more relaxed about it, since it only requires that the index is constant after optimization passes are run. dynamic indexing as an optional feature, dynamic indexing allows applications to perform dynamic indexing into arrays of resources. this allows for a very restricted form of bindless. outside compute shaders however, using this feature correctly is quite awkward, due to the requirement of the resource index being dynamically uniform. dynamically uniform is a somewhat intricate subject, and the details are left to the accompanying sample in khronosgroup/vulkan-samples. non-uniform indexing most hardware assumes that the resource index is dynamically uniform, as this has been the restriction in apis for a long time. if you are not accessing resources with a dynamically uniform index, you must notify the compiler of your intent. the rationale here is that hardware is optimized for dynamically uniform (or subgroup uniform) indices, so there is often an internal loop emitted by either compiler or hardware to handle every unique index that is used. this means performance tends to depend a bit on how divergent resource indices are. #extension gl_ext_nonuniform_qualifier : require layout(set = 0, binding = 0) uniform texture2d tex[]; layout(set = 1, binding = 0) uniform sampler sampler; color = texture(nonuniformext(sampler2d(tex[index], sampler)), uv); in hlsl, there is a similar mechanism where you use nonuniformresourceindex, for example. texture2d<float4> textures[] : register(t0, space0); samplerstate samp : register(s0, space0); float4 color = textures[nonuniformresourceindex(index)].sample(samp, uv); all descriptor types can make use of this feature, not just textures, which is quite handy! the nonuniformext qualifier removes the requirement to use dynamically uniform indices. see the code sample for more detail. update-after-bind a key component to make the bindless style work is that we do not have to … bind descriptor sets all the time. with the update-after-bind feature, we effectively block the driver from consuming descriptors at command recording time, which gives a lot of flexibility back to the application. the shader consumes descriptors as they are used and the application can freely update descriptors, even from multiple threads. to enable, update-after-bind we modify the vkdescriptorsetlayout by adding new binding flags. the way to do this is somewhat verbose, but at least update-after-bind is something that is generally used for just one or two descriptor set layouts throughout most applications: vkdescriptorsetlayoutcreateinfo info = { … }; info.flags = vk_descriptor_set_layout_create_update_after_bind_pool_bit_ext; const vkdescriptorbindingflagsext flags = vk_descriptor_binding_variable_descriptor_count_bit_ext | vk_descriptor_binding_partially_bound_bit_ext | vk_descriptor_binding_update_after_bind_bit_ext | vk_descriptor_binding_update_unused_while_pending_bit_ext; vkdescriptorsetlayoutbindingflagscreateinfoext binding_flags = { … }; binding_flags.bindingcount = info.bindingcount; binding_flags.pbindingflags = &flags; info.pnext = &binding_flags; for each pbinding entry, we have a corresponding flags field where we can specify various flags. the descriptor_indexing extension has very fine-grained support, but update_after_bind_bit and variable_descriptor_count_bit are the most interesting ones to discuss. variable_descriptor_count deserves special attention as it makes descriptor management far more flexible. having to use a fixed array size can be somewhat awkward, since in a common usage pattern with a large descriptor heap, there is no natural upper limit to how many descriptors we want to use. we could settle for some arbitrarily high limit like 500k, but that means all descriptor sets we allocate have to be of that size and all pipelines have to be tied to that specific number. this is not necessarily what we want, and variable_descriptor_count allows us to allocate just the number of descriptors we need per descriptor set. this makes it far more practical to use multiple bindless descriptor sets. when allocating a descriptor set, we pass down the actual number of descriptors to allocate: vkdescriptorsetvariabledescriptorcountallocateinfoext variable_info = { … }; variable_info.stype = vk_structure_type_descriptor_set_variable_descriptor_count_allocate_info_ext; variable_info.descriptorsetcount = 1; allocate_info.pnext = &variable_info; variable_info.pdescriptorcounts = &numdescriptorsstreaming; vk_check(vkallocatedescriptorsets(get_device().get_handle(), &allocate_info, &descriptors.descriptor_set_update_after_bind)); gpu-assisted validation and debugging when we enter the world of descriptor indexing, there is a flipside where debugging and validation is much more difficult. the major benefit of the older binding models is that it is fairly easy for validation layers and debuggers to know what is going on. this is because the number of available resources to a shader is small and focused. with update_after_bind in particular, we do not know anything at draw time, which makes this awkward. it is possible to enable gpu assisted validation in the khronos validation layers. this lets you catch issues like: "unassigned-descriptor uninitialized: validation error: [ unassigned-descriptor uninitialized ] object 0: handle = 0x55625acf5600, type = vk_object_type_queue; | messageid = 0x893513c7 | descriptor index 67 is uninitialized__. command buffer (0x55625b184d60). draw index 0x4. pipeline (0x520000000052). shader module (0x510000000051). shader instruction index = 59. stage = fragment. fragment coord (x,y) = (944.5, 0.5). unable to find spir-v opline for source information. build shader with debug info to get source information." or: "unassigned-descriptor uninitialized: validation error: [ unassigned-descriptor uninitialized ] object 0: handle = 0x55625acf5600, type = vk_object_type_queue; | messageid = 0x893513c7 | descriptor index 131 is uninitialized__. command buffer (0x55625b1893c0). draw index 0x4. pipeline (0x520000000052). shader module (0x510000000051). shader instruction index = 59. stage = fragment. fragment coord (x,y) = (944.5, 0.5). unable to find spir-v opline for source information. build shader with debug info to get source information." renderdoc supports debugging descriptor indexing through shader instrumentation, and this allows you to inspect which resources were accessed. when you have several thousand resources bound to a pipeline, this feature is critical to make any sense of the inputs. if we are using the update-after-bind style, we can inspect the exact resources we used. in a non-uniform indexing style, we can inspect all unique resources we used. conclusion descriptor indexing unlocks many design possibilities in your engine and is a real game changer for modern rendering techniques. use with care, and make sure to take advantage of all debugging tools available to you. you need them. this blog has explored the first vulkan extension game changer, with two more parts in this game changer blog series still to come. the next part will focus on ‘buffer device address’ and how developers can use this new feature to enhance their games. follow up thanks to hans-kristian arntzen and the team at arm for bringing this great content to the samsung developers community. we hope you find this information about vulkan extensions useful for developing your upcoming mobile games. the original version of this article can be viewed at arm community. the samsung developers site has many resources for developers looking to build for and integrate with samsung devices and services. stay in touch with the latest news by creating a free account or by subscribing to our monthly newsletter. visit the marketing resources page for information on promoting and distributing your apps and games. finally, our developer forum is an excellent way to stay up-to-date on all things related to the galaxy ecosystem.

      Arm Developers

      https://developer.samsung.com/galaxy-gamedev/blog/en-us/2021/06/28/new-game-changing-vulkan-extensions-for-mobile-descriptor-indexing
      1. tutorials | mobile, blockchain

      blog

      Optimize Address Fetching in the Samsung Blockchain Keystore SDK with Seed Hash

      last june, samsung introduced samsung blockchain keystore (sbk), a secure built-in cold wallet in galaxy devices. the cold wallet is isolated with samsung knox and encapsulated within a defense-grade trusted execution environment (tee). the samsung blockchain keystore sdk enables use of this wallet in android applications. in this article, we discuss how to optimize the address fetching process with seed hash. fetching addresses from the samsung blockchain keystore using the sdk is an expensive operation, so this blog teaches you how to store your seed hash values to avoid delays in fetching information whenever you launch your app. the samsung blockchain keystore (sbk) sdk enables users to get blockchain public addresses from the samsung blockchain keystore and sign a cryptocurrency transaction to authenticate. a public address is the hashed version of the public key and is used to recognize a blockchain cryptocurrency account. as the blockchain protocol goes, anyone can fetch the balance and transaction history of an account with its public address. developers can invoke the getaddresslist() api of the sbk sdk to fetch the address list. every time this api is called with the same request, you get the same address list. a change to the list occurs only when the wallet's root seed has been changed. the programming guide: api flow and use cases provides more detailed information. seed hash the sdk uses the term seed hash (see figure 1, inside the green rectangle). figure 1: sbk sdk api flow and use case the sdk glossary says: seed hash: a pseudo seed hash that is generated randomly when the hd wallet is created. if the master seed of a wallet is changed, the seed hash will be changed as well. the getseedhash() api gets the current seed hash from the samsung blockchain keystore. fetching the address list from the samsung blockchain keystore using the sbk sdk initiates an expensive operation that requires a considerable amount of time. to provide the user with a seamless experience, the sbk sdk programming guide recommends that developers store information from the getseedhash() api. developers then need to invoke the getaddresslist() api only when the stored seed hash is different from the seed hash fetched using the sbk sdk. prerequisites before you begin, be sure you've met these prerequisites: you have already imported the sdk in your android app you have completed samsung blockchain keystore wallet setup you meet supported device and regions restrictions if not, download the sbk sdk and check out the programming guide: getting started section to integrate the sbk sdk. i also recommend reading this blog on address fetching basics: "where's my crypto coin? featuring samsung blockchain keystore sdk” . enable developer mode in the samsung blockchain keystore to bypass api key verification. the sample application in this blog is not a partner app, so you must enable developer mode to run and test the app features. store the seed hash i recommend using android sharedpreferences to store the seed hash. remember, the seed hash value is not sensitive data; it's not the wallet's root seed itself. it's a hash value generated to keep track of change in the wallet. because high-level security is not a concern, and when you have a relatively small collection of key values that you'd like to save, sharedpreferences is an easily implemented solution. all you need to do is get the sharedpreferences file and then read and write key-value pairs on it. if you prefer another method of storing data, you can select any one of the methods described in the android: data and file storage overview. the following code snippet refers to sharedpreferences: private static final string seedhashkey = "seed_hash"; private static final string defaultseedhashvalue = ""; private static sharedpreferences msharedpreference; msharedpreference = getactivity().getpreferences(context.mode_private); public static string getseedhash() { return msharedpreferences.getstring( seedhashkey, defaultseedhashvalue); } public static void setseedhash(string seedhash) { sharedpreferences.editor editor = msharedpreferences.edit(); editor.putstring(seedhashkey, seedhash); editor.commit(); } } //fetch seedhash from sbk and store on shared preference string seedhashsdk = scwservice.getinstance().getseedhash(); setseedhash(seedhashsdk); get the address list from the samsung blockchain keystore the getaddresslist() api of the sbk sdk requires the hd path list and callback function parameters. hd path list parameter: an arraylist, a list of strings in which every string denotes an hd path. see understanding keystore > key management for more information. callback function parameter: a callback function of type scwservice.scwgetaddresslistcallback. the address fetching method is performed asynchronously; on completion onsuccess() or onfailure() method is invoked. onsuccess() holds the required address list as a list, whereas onfailure() holds the error code. the following code snippet retrieves four addresses at one time: private scwservice.scwgetaddresslistcallback mscwgetaddresslistcallback = new scwservice.scwgetaddresslistcallback() { @override public void onsuccess(list<string> addresslist) { log.i(util.log_tag, "accounts fetched from sdk successfully."); } @override public void onfailure(int errorcode) { // error codes doc: // https:developer.samsung.com/blockchain/keystore/ log.e(util.log_tag, "fetch accounts failure. error code: " + errorcode); } }; public void getpublicaddress(arraylist<string> hdpathlist) { mscwservice.getaddresslist( mscwgetaddresslistcallback, hdpathlist); } arraylist hdpathlist = new arraylist<>(); hdpathlist.add(scwservice.gethdpath(scwcointype.eth, 0)); //m/44'/60'/0'/0/0 hdpathlist.add(scwservice.gethdpath(scwcointype.eth, 1)); //m/44'/60'/0'/0/1 hdpathlist.add(scwservice.gethdpath(scwcointype.eth, 2)); //m/44'/60'/0'/0/2 hdpathlist.add(scwservice.gethdpath(scwcointype.eth, 3)); //m/44'/60'/0'/0/3 // btc -> "m/44'/0'/0'/0/0"; getpublicaddress(hdpathlist); representation for an accounts info demonstration, i've used android's recyclerview. for detailed information, see create a list with recyclerview and this android recyclerview example. figure 2: fetching an address list from the samsung blockchain keystore store address information on an application database once you have fetched the required addresses from the samsung blockchain keystore, design your mechanism to store this information. let’s look at requirements at this stage: storage for account information: accounts presented at app launch have to remain consistent on subsequent app launches, unless the wallet has been changed. provide users with a seamless experience: information should not be fetched from samsung blockchain keystore using sdk every time the app launches, because it causes delays. this leads us to android room. room provides an abstraction layer over sqlite to allow fluent database access while harnessing the full power of sqlite. the three major room components are: database: contains the database holder entity: represents a table within the database. dao interface: contains the methods used for accessing the database. for more information about android room, see the documentation, blogs, and samples. database database class extends the roomdatabase and builds the required database file. @database(entities = {accountmodel.class}, version = 1) public abstract class accountsdb extends roomdatabase { private static accountsdb accountsdb; public abstract iaccountsdao iaccountsdao(); public static accountsdb getinstance(context context) { if (accountsdb == null || !accountsdb.isopen()) { accountsdb = room.databasebuilder (context, accountsdb.class, util.db_name) .build(); } return accountsdb; } } entity here, we have declared our model class as a room entity using annotations. room converts “the members of the class” to “columns of the table,” reducing boilerplate code. @entity public class accountmodel { // accountid used as primary key & indexing, auto generated @primarykey(autogenerate = true) private int accountid; private string publicaddress; private string hdpath; // getter & setter methods .. .. } dao interface here, you have to declare methods and corresponding database sql queries to be run. this interface is implemented by the room persistence library; corresponding codes are generated automatically to perform required database operations. @dao public interface iaccountsdao { @query("select * from accountmodel") list<accountmodel> fetchaccounts(); @insert(onconflict = onconflictstrategy.replace) void insertaccounts(arraylist<accountmodel> accountmodels); @query("delete from accountmodel") void removeaccounts(); } on invoking the java method, corresponding queries are performed on the database. for example, invoking the removeaccounts() method executes the delete from accountmodel query. database operations room doesn’t allow you to issue database queries on the main thread, as it can cause delays. database crud operations must be performed on a separate thread. i’ve used asynctask on this example to perform database operations. asynctask allows you to perform background operations and publish results on the ui thread without manipulating threads and/or handlers yourself. asynctask gives a high-level wrapper over multithreading, so you don't need expertise in concurrent threads or handlers. doinbackground(params...): performs a computation on a background thread. onpostexecute (result): posts on the ui thread once doinbackground() operation is completed. the result parameter holds the execution result returned by doinbackground(). execute(params...): on invocation, executes the task specified with given parameters. see the api reference for details. the following example code snippet shows the database retrieve data task: private static class fetchasynctask extends asynctask<void,void,arraylist<accountmodel>> { @override protected arraylist<accountmodel> doinbackground(void...voids){ arraylist<accountmodel> accountmodels = new arraylist<accountmodel>(accountsdb.iaccountsdao().fetchaccounts()); return accountmodels; } @override protected void onpostexecute (arraylist<accountmodel> accountmodels) { log.i(util.log_tag, "db fetch successful"); accountrepository.setmaccountmodels(accountmodels); } } public static void fetchaccounts() { // db crud operations has to be performed in a separate thread new fetchasynctask().execute(); } figure 3: fetching an address list from database next steps it's a lot of technical info for one blog. however, it will be worth it to have your apps launch quickly and seamlessly once you've optimized address fetching in the samsung blockchain keystore sdk. for more detailed information, see the following references, and don't hesitate to reach out with any queries and feedback. source code for sample application "optimize address fetching with seed hash" "where's my crypto coin?” featuring samsung blockchain keystore sdk samsung blockchain keystore programming guide: api flow and use cases android data and file storage: sharedpreferences save data in a local database: android room

      Md. Armaan Ul Islam

      https://developer.samsung.com/sdp/blog/en-us/2020/02/04/optimize-address-fetching-in-the-samsung-blockchain-keystore-sdk-with-seed-hash

      web

      Sitemap | Samsung Developers

      sitemap learn code lab foldables and large screen one ui beta develop mobile/wearable galaxy gamedev galaxy themes galaxy watch health samsung blockchain samsung dex samsung iap samsung internet samsung pay samsung wallet visual display smart tv smart hospitality display smart signage digital appliance family hub platform bixby knox smartthings tizen.net design design system one ui one ui watch smart tv distribute galaxy store tv seller office galaxy store games instant plays support developer support remote test lab samsung android usb driver galaxy emulator skin connect blog news forum event samsung developer conferences

      https://developer.samsung.com/sitemap
      1. tutorials | mobile

      blog

      [Samsung DeX] Settings for Samsung DeX

      settings for samsung dex samsung dex is a fantastic feature .it can take you into the new world that you can take your apps to desktop mode or you can use multiple apps at once. when switch to dex mode, you can change the default settings that you prefer. this blog will introduce settings for samsung dex. these settings will not affect your settings in phone mode. getting started while in dex mode, find settings icon and click it. click the samsung dex item. screen timeout for samsung dex according to your habit, you can set it. wallpapers for samsung dex you can choose the image from gallery or use the default image that can set as wallpaper for home screen ,lock screen or home and lock screen. pointer speed

      Samsung Developer Program

      https://developer.samsung.com/sdp/blog/en-us/2017/06/08/samsung-dex-settings-for-samsung-dex
      1. tutorials | web, galaxy watch

      blog

      Tizen Tidbits: Reviewing More UI Samples

      this is part of a 2 hour tizen workshop that you can find here: https://youtu.be/5xp8jfpxom8 in this video, you will modify the heart rate monitor and tizen advanced ui samples. these will give you several ui components that you can re-use in your projects. you can also connect with me, diego, a sr. developer evangelist, on twitter: https://twitter.com/hielo777 have questions? post them in our forums: https://forum.developer.samsung.com/ check out other videos, blog posts, and tips to improve your tizen app development. check out the tizen tidbits playlist on our youtube channel, and learn more about the wide selection of samsung technologies on our developer portal.

      Diego Lizarazo Rivera

      https://developer.samsung.com/sdp/blog/en-us/2020/06/25/tizen-tidbits-reviewing-more-ui-samples
      1. tutorials | web, galaxy watch

      blog

      Tizen Tidbits: Intro to TAU (Tizen Advanced UI)

      this clip is part of a 2 hour tizen online workshop that you can find here: https://youtu.be/5xp8jfpxom8 this video focuses on creating a sample project using the tizen advanced ui (tau) library. stay tuned if you want to learn how to make your web apps more functional and elegant, taking advantage of the unique galaxy watch features. you can also connect with me, diego, a sr. developer evangelist, on twitter: https://twitter.com/hielo777 have questions? post them in our forums: https://forum.developer.samsung.com/ check out other videos, blog posts, and tips to improve your tizen app development. check the tizen tidbits playlist on our youtube channel, and learn more about the wide selection of samsung technologies on our developer portal.

      Diego Lizarazo Rivera

      https://developer.samsung.com/sdp/blog/en-us/2020/05/21/tizen-tidbits-intro-to-tau-tizen-advanced-ui
      1. tutorials

      blog

      Launch Your Tizen .NET Application on Samsung Smart TV

      this blog discusses how to run the tizen .net application with xamarin.forms on the samsung smart tv 2018 models. xamarin.forms developers, if you have a tizen project already added on your xamarin.forms application, you are ready to begin. you can also review this blog for more details about adding tizen projects (https://blog.xamarin.com/add-tizen-projects-xamarin-forms-apps/). note: the .net application is only supported on samsung smart tv 2018 or later models that use tizen 4.0 as a platform. for a list of supported models, go here. if you are new to developing tizen .net applications, we suggest that you browse quick guides and installing visual studio tools for tizen. development environment windows you must have visual studio tools for tizen installed. if you do not, install the extension tool first. tizen baseline sdk automatically installs after the extension tool is installed. mac no extension tool for visual studio for mac is provided. you can download and install the tizen baseline sdk or install the full tizen studio here. there are two more extensions in tizen package manager (tools > tizen > tizen package manager). samsung tv extension samsung certificate extension the extensions are located on the extension sdk tab. install them if they are not already installed. connect the sdk to the tv you can connect your sdk to a tv device as a remote device. before you connect to the tv, confirm that: your computer and tv are on the same network. you have prepared a certificate profile. enable developer mode on your tv device open the smart hub. select the apps panel. in the apps panel, enter 12345 using the remote control or the onscreen number keypad. the following popup appears. switch developer mode to on. enter the host pc ip you want to connect to the tv, and click ok. reboot the tv. after the tv reboots, open the apps panel. developer mode is indicated at the top of the screen. connect the tv to the sdk in visual studio, navigate to tools > tizen > tizen device manager to open device manager. note: for mac users, launch device manager on mac. click remote device manager and + to add a tv. in the add device popup, enter the information for the tv you want to connect to and click add. back to the device manager window, select the tv from the list, and switch the connection to on. when the tv is successfully connected, you can see the tv is connected as a device on the visual studio toolbar. now you are ready to launch your applications on the tv. launch an application on the tv visual studio for windows on windows, you can launch your application directly through visual studio using the ctrl + f5 shortcut. visual studio for mac after building the tizen project, go to terminal, move to the output folder and execute the following commands: acbook:~ jay$ sdb install org.tizen.example.hello.tizen-1.0.0.tpk acbook:~ jay$ sdb shell 0 execute <app_id> the sdb tool is located where the tizen studio is installed; for example ~/tizen-studio/tools/. you can check the <app_id> in the tizen-manifest.xml file. the application you installed on the tizen 4.0 tv is automatically removed when the tv is turned off and on with cold boot. if you have any questions about launching your tizen .net application on samsung smart tv, contact us at issues.

      Jay Cho

      https://developer.samsung.com/tizen/blog/en-us/2019/02/19/launch-your-tizen-net-application-on-samsung-smart-tv
      No Search Results
      No Search results. Try using another keyword.
      • <<
      • <
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • >
      • >>
      Samsung Developers
      Samsung Developers
      Quick Link
      • Android USB Driver
      • Code Lab
      • Galaxy Emulator Skin
      • Foldables and Large Screens
      • One UI Beta
      • Remote Test Lab
      • Developer Support
      Family Site
      • Bixby
      • Knox
      • Samsung Pay
      • SmartThings
      • Tizen
      • Samsung Research
      • SamsungOpen Source
      • Samsung Dev Spain
      • Samsung Dev Brazil
      Legal
      • Terms
      • Privacy
      • Open Source License
      • Cookie Policy
      Social Communications
      • Facebook
      • Instagram
      • Twitter
      • YouTube
      • Buzzsprout
      • Rss
      • Linkedin
      • System Status
      • Site Map
      • System Status
      • Site Map
      • facebook
      • instagram
      • twitter
      • youtube
      • buzzsprout
      • rss
      • linkedin

      Copyright © 2023 SAMSUNG. All rights reserved.