Appstore Blogs

Appstore Blogs

Want the latest?

appstore topics

Recent Posts

Archive

Showing posts tagged with Android

January 09, 2014

Mike Hines

Today, we released the new developer portal that improves the look and feel of the site and helps you save time when planning, building, and submitting applications to the Amazon Appstore. 

The portal refresh is designed to make it easy for you to:

1. Get Started: If you have an Android app, you can simply drop your APK in our updated testing widget to get Appstore compatibility test results in just seconds. Once your app is ready, you can create a free developer account and submit it using the Developer Console.

2. Access the Latest Amazon APIs: Download the free Amazon Mobile App SDK for access to APIs and services that can enhance your apps and games, help you monetize them, and engage your audience across Android and iOS platforms.

3. Find the Content that Matters: The new site includes a wide variety of support resources to help you through the development process including documentation, development tools, marketing tips, promotional tools, videos, case studies, blog posts and one of my favorites, a schedule of upcoming training events.

 

 

Top Enhancements

There are many improvements in the new portal, and here are a few stand-outs:

    1. Streamlined App Submission

One thing that you’ll notice right away is how easy it is to check an existing Android .apk for compatibility with the Amazon Appstore. Just drag your .apk to the updated testing widget on the Home page and get results in seconds. If your app is ready to go (as most are), you can start the app submission process directly from the results page.

    2. Site-wide Search

The site-wide search tool in the top navigation bar can quickly get you to the page you are looking for. Just submit the term you are looking for and it will search the site for results.

    3. Complete list of APIs (with cross-platform compatibility notation)

There is now a page where you can find all of the Amazon Appstore APIs, and see their compatible platforms. In the case of the Analytics API for example, you can see that it is compatible with apps sold on iOS, the Google Play Store, and the Amazon App Store.

Also, behind each pretty icon is a page full of documentation, sample code and plug-in information for each service. (I spend a lot of time on these pages when I code.)

    4. Dedicated page for Game Developers

We introduced a page dedicated to the tools and services that Game developers will find most helpful, including game engine plug-ins and cross-platform APIs that can help you maximize revenue from In App Purchasing. (you can still use these even if you’re not a game dev.)

    5. Dedicated pages for HTML5 and iOS developers

Speaking of cross-platform, If you’re not an Android developer we made some changes to become more relevant to you, such as giving HTML5/web app developers their own resources page as well as building a page specifically for iOS developers who may want to take advantage of some of our Analytics tools, A|B Testing tools, or game services.  

    6. Resources for PC and Mac game developers

Even if you don’t program for mobile devices, we still have some great promotion programs.  These are detailed on the Mac and PC page to help you submit your game to Amazon and get noticed in our Digital Games and Software store, Indie Games store and Free-to-Play Store.

    7. Community resources and a calendar of events

We created a Community space, which provides you with access to our Developer Blog and Forums, and lists upcoming events and webinars, and lets you catch up on the latest tech news gathered from periodicals and blogs around the world. Check out the list of events and webinars here.

    8. A Resources section (including how-to videos)

This section contains links to development tools, marketing tips, and promotional programs. Also in this section are and learning resources, which include two of my favorite resources in the site: First is the one-stop-shop for all of the how-to videos, webinar videos, and case-study videos we’ve produced. The second is the Documentation page, which contains easy links to API documentation, Kindle Fire info, dev environment setup help, app submission tips, and even marketing tips.  

      

What hasn’t changed?

The Developer Console (the interface you use to work on app submission forms) has not changed its functionality; it has just been re-skinned. So you can add A|B Experiments, enter new IAP items and other dev console tasks just like you always have.

Take a look at our new developer portal as you build and distribute your apps with Amazon.

January 08, 2014

David Isbitski

HTML5 Web Apps: Tips on Acquiring Customers in the Amazon Appstore

We want to start the year off by focusing on getting your Web Apps noticed in the Amazon Appstore, so you have the best chance of acquiring new customers.  There are a few easy steps you can take to so that your apps, whether web or non-web apps, are more appealing to first time downloaders.  This includes ensuring you have quality screenshots and promotional images, detailed product descriptions, an easy way for customers to review or share your app, as well as a way for customers to discover your apps outside of the Amazon Appstore.  Amazon also offers unique ways to help your Web Apps get noticed including weekly promotions for the top Web Apps in the Appstore as well as access to Appstore Developer Select.   

Appstore Developer Select

All Web Apps submitted to the Amazon Appstore will be automatically entered into for Appstore Developer Select, if they meet the program requirements.  This program helps get your Web Apps discovered and gives you more opportunities to boost your sales and revenue.  As a developer with one or more qualifying apps, you will receive the following benefits:

  • Enhanced Merchandising to Improve Discovery: Your qualifying apps will receive 500,000 free mobile ad impressions across the Amazon Mobile Ad Network. We’ll provide enhanced merchandising for your apps in a dedicated section on the Amazon Appstore home page and consider your apps for advertising on Kindle Fire.
  • Amazon Coins Rewards to Customers to Improve Conversion: Consumers purchasing your app or in-app items in your app will receive up to 30% of the purchase price back in Amazon Coins. We’ll boost customer acquisition by rewarding first-time purchasers of Select paid apps and in-app items with an extra 250 bonus Coins.
  • 25% off AWS Services to Help You Scale: You will earn 25% credit back on qualifying purchases of Amazon Web Services (AWS) products, up to a maximum $500 credit per year.

You can check the status of your eligibility by going to the My Apps section of the Apps and Services Tab in the Developer Console.
 

 

You can click on View Report to see which items your App has passed on and which items you need to update in order to become eligible.


 

Once your app has been enrolled in Appstore Developer Select you will also have the option to view the Ad Campaign that has been set up on your behalf.
 

 

Optimizing App Details

The title and description of your app is like the front door of a building.  Customers will never know what’s inside until they knock and walk inside.  By writing an effective description you can change your app from the spooky abandoned house on the corner to an enticing new shopping mall just waiting to be explored.

 

The keywords section will be how customers find your app when searching the Amazon Appstore so make sure you chose relevant discoverability terms. 

In addition to the App details you can also select a Content Rating for your app letting customers know what to expect.

Be sure to read our previous blog post with tips on effective title and description for your apps here.

High Res Screenshots and Multimedia

Your Web App submission will need to provide screenshots of your app running as well as an optional video.  You should create and upload both a 114x114 icon and a 512x512 icon, which will be used for the app list and carousel respectively.

 

In order to take the screenshots of your app running you will need to use the Web App Tester program on a Kindle device (emulators are not currently supported) and use the Kindle built in screenshot button combination.  The button sequence for each Kindle device can be found here.

You will need to next copy the screenshots off of the Kindle device and uploaded to the developer portal.  

On windows simply plug in your Kindle device and open File Explorer to Internal Storage > Pictures > Screenshots.

 

For Mac OSX you will need to use the Android File Transfer Tool and navigate to Pictures > Screenshots.

 

While you are only required to submit three screenshots, having additional screenshots as well as a promotional image is recommended and will help to increase the chance for downloads.  You can also include an optional Video showcasing your Web App.

 

You can get additional information on taking screenshots of your Web Apps via the official developer documentation  here.

App Badges

Amazon also offers App Badges you can include on your Website and customer communications such as email blasts.

  

These Badges are available in a variety of languages and will further increase potential download traffic to your app by referring customers who are already interested in your products or have come across your website. 

For full details on using App Badges be sure to check out the documentation here.

Conclusion

Building an audience for your apps and connecting with new customers is an important concern for most developers.  By following the steps listed here you can ensure a higher chance of getting noticed.  The more customers who see your app the greater the chance of increased downloads, more reviews and eventual promotion inside the Amazon Appstore.

Got a great HTML5 Web App in the Amazon Appstore?  Looking to get promoted?  Why not tell us about it!  You can Contact Us directly and let us know. 

 

-Dave (@TheDaveDev)

 

December 24, 2013

Peter Heinrich

The Amazon Appstore for Android is spreading a little holiday cheer this week, offering a $5 credit to anyone who downloads the latest version of the Amazon Appstore and uses it to buy a mobile app or game from Christmas Eve through Saturday. The credit is good for the future purchase of any apps, games, or in-app items in the Amazon Appstore.

With millions opening brand new phones and tablets this season, there’s never been a better time to publish your mobile app or game on Amazon. The Amazon Appstore runs on all Android devices, and now customers will have an additional $5 to spend there on the great mobile content they love. Submit your app today to make sure it’s available for purchase when customers want to redeem their credit.

December 18, 2013

Peter Heinrich

The Amazon Appstore continues to see tremendous growth, and in fact selection has more than doubled in 2013 over 2012, offering more than 100,000 apps as a result of a growth of 95 percent in app submissions. This momentum would not be possible without the many developers who build apps and games for folks using Kindle Fire and other Android devices. Think of our ecosystem kind of like a pizza parlor.

In just two years since shipping its first Kindle Fire, the Amazon Appstore has established a platform that allows developers to reach millions of Amazon customers worldwide. Amazon also offers a unique discovery and marketing engine through Free App of the Day, Game Connect and other Amazon channels (like recommendations and emails).

 

December 12, 2013

Mike Hines

On 11/13/2013, Amazon launched a Limited Preview of Amazon AppStream, a service that lets developers run all or parts of their applications from the cloud. The allocated beta slots are filling quickly, and developers have been providing great feedback to the service.

One of the most interesting observations I’ve had so far is the diversity of use cases using Amazon AppStream. There are games using the service, but an equal number of utilities, productivity apps, and entertainment titles as well.  And while my focus is on mobile devices, I found that Amazon AppStream developers target Macs and PCs just as much as they do mobile devices.

Perhaps one of the biggest “ah-ha!” moments I’ve heard about is when participants realize that they can build a hybrid app; one that partly runs in native code on device, and partly runs in the cloud. I asked the AppStream team when this might be a good idea for developers. Here’s what they had to say:

“If you typically write native apps, you might think about using Amazon AppStream to beef up key graphics and scenes when the user is on a lower powered computer by using the richer graphics that a powerful server can generate. Another benefit of having a blended solution is that you can take advantage of any native features or APIs you might want to use.”

While writing blended apps sounds intriguing, one of the valuable aspects of Amazon AppStream is that it lets developers deliver rich experiences on more screens more quickly than re-writing applications in native code.

Certainly other streaming and virtualization technologies exist, but many have suffered from issues with high latency and low resolution. Amazon has managed to mitigate those issues by using the proprietary Amazon AppStream STX protocol, which streams H.264 encoded video and audio over the UDP transport layer, as well as capturing input from the user.  Using this technology, Amazon AppStream is able to produce 720p video at 30 frames per second under a variety of different network conditions (very cool!).

While it’s not as simple as pressing a button, optimizing for Amazon AppStream requires much less work than rebuilding you app for different platforms. To see design considerations for an Amazon AppStream app, see this page

 

November 21, 2013

Peter Heinrich

Just in time for the holidays, millions of customers can now purchase Android applications from the Australian Appstore and Brazilian Appstore using their own local currency. Available in nearly 200 countries since May, the Amazon Appstore now allows developers to price their apps in Australian dollars or Brazilian reais, in addition to the other currencies already supported. There’s even a new localization option for Brazilian Portuguese so you can make your app that much more relevant to customers in Brazil. And, the Australian Appstore is also accessible to Kiwis, so customers in New Zealand can download the best local and global apps, too.

Being able to offer your apps for sale in the local currency of Australia and Brazil means less friction for customers in two of the most important global app marketplaces. Brazil is the largest app marketplace in Latin America and is growing faster even than the US, according to a recent report by Distimo1, which also ranks the Australian app marketplace #6 in the world in terms of revenue. Despite Australia’s considerably smaller installed base, only the US, Japan, South Korea, the UK, and China surpass it for app purchases.

In addition, you can publish any Android app on the Amazon Appstore, which includes those running on Kindle Fire OS. In fact, more than 75% of the Android tablet apps we’ve tested just work on Kindle Fire without additional development. Publish your Android app on Amazon and it automatically becomes eligible to be featured on our web storefront and to be included in search results and recommendations shown on product detail pages. Once your app or game is available in our store, you can also promote its availability by linking to it directly.

So, don’t miss this opportunity to monetize your apps and games in time for the holiday rush. In 2012, we saw a 50% increase in the number of app downloads during Thanksgiving week as compared to an average week. During ‘Digital Week’ in 2012 (the week after Christmas), customers purchased and downloaded 600% more apps than an average week during the yearSubmit your Android app to our store today and let us help you increase your international exposure in time for the holidays.

 

 



1Distimo MEF Mobile App Ecosystem Sept 2013.

 

 

November 19, 2013

David Isbitski

Over the last couple of years since our Amazon Appstore launch, we’ve talked with many unique and inspiring developers. Along the way we’ve learned quite a bit and wanted to pass some of those learnings back to our developer community. So to that end, we are excited to continue our Developer Spotlight series. This series will highlight developers’ experiences building apps, ranging from what inspires them and how they’re delivering innovation to consumers to the results they’re achieving.

For today’s spotlight, we’re excited to chat with one of the co-founders of ZeptoLab, a global gaming company whose game Cut the Rope has been an instant success since its debut in October of 2010. The game remains a top app throughout mobile markets, browsers and desktops, and has been downloaded more than 400 million times to date.

Below is our interview with Zeptolab co-founder and CTO, Efim Voinov.

Why did you start Zeptolab?

Creating games was a hobby for my brother and me since early childhood. We’ve started with the games for ZX Spectrum in the early 90s, switched to PalmOS in the 2000s, and jumped into iOS and Android development since the first days of those platforms. At that time we already had experience in several gaming companies, and thought it was the right time to start something on our own. The new platforms offered exciting opportunities for independent developers, and we believed they shouldn’t be missed.

When did you start Android development for Cut the Rope?

The original version of Cut the Rope was released for iOS only, since there were only two of us developing full-time, and we had to concentrate on a single platform. After the game was out, we started to receive feedback from the players that they would like it on other platforms, and Android was the most requested one. Once the company had grown enough, we started developing it and about eight months after the release of the original we had the Android version. The version for Amazon Appstore was released at the same time, and required very little adaptation.

What changes did you need to build into the game to make it available for the Amazon Appstore?

Since we released Cut the Rope, we’ve created other titles, like Cut the Rope: Time Travel, Cut The Rope: Experiments, and Pudding Monsters. All of our titles are available in the Amazon Appstore. The process of porting the app for Amazon is very easy; we simply swap out billing API’s for the Amazon API for billing, which is something we do for all platforms we sell our app on. In addition, we are using GameCircle to handle leaderboards and achievements for games in the Amazon Appstore, which we have built in.

What’s it like to work with Amazon?

We think the Amazon API’s are very well thought through, the implementation is efficient and it’s easy to find information on how to use them. Having this ease of use is very important to us because we have lots of different versions of the games and really value the quick turnaround time to support games. In cases where we need more information the documentation level for Amazon API’s is very good and compared to others it’s in many cases above the competition. We don’t have to communicate with the Amazon team a lot in terms of understanding how to implement.

We also really appreciate your developer relations team. Having these relationships with the team helps us plan for the future, so we can plan for our business and consider the best way to implement new API’s and improvements into our games. The level of technical features being brought to market is impressive.

What are you looking at doing next with the Amazon Appstore?

In our current titles we are actively using IAP and this is proving to be quite successful for us in the Amazon Appstore. They currently bring us more than 40% of our revenue, and this figure is growing. In general, our cumulative income in the Amazon Appstore is doubling every year, and we are looking forward to increasing this trend in the future. With the latest release of the Mobile Associates API, we are looking at various opportunities to sell physical goods for our games.

Do you have any tips and tricks for developers building mobile games and applications?

One of the things that we learned is that it’s really important to minimize the routine tasks during development, and optimize the process as much as possible. That’s why we have invested quite a lot of time into our own framework, which includes different tools that automate various tasks. For example, we have an animation system, which allows us to automatically export animations created in the Adobe Flash directly to the game.

We also try to keep things as abstract as possible while designing a native OpenGL application for the Android platform. We try not to rely too heavily on a list of pre-defined resolutions, even if the list is extensive, because hardware specs are always changing. Instead, we try to invent a system for adopting current graphics to any imaginary screen proportion and only switch version for graphic assets depending on a real resolution. The one constant that does not change is the size of a user’s finger. We try to estimate an optimal physical size for a gesture and calculate using real measures like dpi and screen size in inches on every device.

 

November 07, 2013

Mike Hines

Now is one of the best times of year to submit your apps to the Amazon Appstore and have them published for Android phones and tablets, including the new Kindle Fire line of tablets. In 2012, we saw a 50% increase in the number of app downloads during Thanksgiving week as compared to an average week. During ‘Digital Week’ in 2012, the week after Christmas, customers purchased and downloaded 600% more apps than an average week during the year.

As we’ve noted in earlier blog posts, it’s easy to get started as 75% of the Android tablet apps we’ve tested already work on Kindle Fire without any extra development. Amazon also has a tool that quickly ensures your apps have the best chance of passing both Amazon Appstore and Kindle Fire compatibility testing. Even if you’ve already got an app in the Amazon Appstore, you can use this service to check out any updates you plan on submitting.

The testing tool works fast and screens your apps for potential errors or incompatibilities. For example, you’ll learn:

  • If there are structural issues with implementation of Amazon APIs
  • If you are using any libraries that might impact compatibility
  • If your app has features that are not supported by some Kindle Fire devices

If an issue is found, you will also get some suggestions for fixing the problem. Note, the tool is not designed to replace debugging in your IDE, and it won’t find null pointer exceptions or similar coding errors.

To get started, you can find the tool in the SDK & Tools area of the Developer Portal where there is now a link for the App Testing Service.
 


 

The App Testing Service detail page includes a brief description of the tool and a button that initiates the App Testing Service. Clicking that button brings you to the app testing page (below) which contains a control into which you can drag your .apk.
 


To give you a sense on the experience you can expect, I’ll walk you through the short process. I started with a small quotation app that I created and dragged it into the tool. The testing was complete in under a minute and my app passed. The tool then displayed a ‘Submit to Amazon Appstore’ button that I could use to start the app submission process.

Next, I tested the same app that used Google In-App Billing instead of Amazon In-App Purchasing. The tool caught that error and correctly identified the issue and offered suggestions for fixing my app. Here is that test result:
 


Here is another test result that identifies an error in In-App Purchasing implementation:
 


Once the test is complete, you can find the results of this and all your tests in a table at the bottom of the app testing page. This lets you go back and re-visit previous issues and recommendations across all the apps you have tested.

So don’t miss out on getting in front of all those customers during the holiday season. Save time and go to https://developer.amazon.com/tya/welcome.html and make sure your apps are ready to submit to the Amazon Appstore. 

 

July 23, 2013

Peter Heinrich

Save game data in the cloud to protect your customers’ progress and support play from multiple devices

In just a few short years, the explosion in popularity of smart phones and tablets has transformed gaming, as touch controls, geolocation, and micropayments enter the mainstream. Online storage is also becoming more common, as developers adjust to a major challenge of mobile devices: physical durability. Keeping your data in the cloud starts to look mighty attractive compared to keeping it on a device that’s easily misplaced, damaged, or stolen.

Blob storage is a common way to save data online (game data is simply written to the cloud as one big chunk). If two devices update the same data, though, one of the updates must be ignored or overwrite the other. You have to decide which update to keep (based on a timestamp or version number, perhaps), or maybe prompt the user to choose between them. Either way, data is lost.

Because of the overhead involved, many developers don’t even bother with this naïve approach. This is a huge disservice to the player, whose game progress is completely lost if anything happens to his or her mobile device. Whispersync for Games saves game data for you, and works across all Android devices (including Kindle Fire).

Mergeable and Non-mergeable Data

Whispersync was designed to prevent data loss, make developer or player intervention unnecessary when resolving conflicts, and be dead-simple to integrate and use. It doesn’t distinguish between online and local storage, so the programmer doesn’t have to handle separate cases for saving to disk and cloud. It does this by manipulating only mergeable data.

Game data is mergeable if a simple rule can be defined to resolve conflicting values. For example, the rule associated with the best completion time might be, “Take whichever value is smallest.” To keep track of a player’s best score, we might use, “Take whichever value is highest.” In some cases, the most recent value may be the most important, so the appropriate rule would be, “Take whichever value is newest.” These rules apply at a granular level; Whispersync doesn’t treat game data as one big chunk.

Not all game data can be resolved using simple rules, though, in which case we call it non-mergeable. The current state of a chess board, for example, requires a complex tree structure to describe it. Reconciling two versions of the board is more complicated than just choosing the “lowest” or “highest” one.

Describing Game Data Using Syncable Types

Fortunately, a lot of game data is naturally mergeable or can be adjusted to be so. Whispersync offers many different syncable types with several built-in rules to resolve conflicts. They can be used to model simple and complex game data.

  • SyncableNumber – A number that is the lowest, highest, or most recent.
  • SyncableString – A string that is the most recent.
  • SyncableAccumulatingNumber – A number that can be incremented and decremented.
  • SyncableNumberList – A list of numbers in ascending, descending, or latest order.
  • SyncableStringList – A list of strings ordered by most recent.
  • SyncableStringSet – A set of strings.
  • GameDataMap – A nested map, allowing hierarchical data.

A global GameDataMap object represents the root storage for your game, storing named values of the types above. Setting a value that doesn’t exist will create it on the fly. The accessor used to retrieve a value determines the conflict resolution strategy that will be associated with it.

  public static final String SKILLS = "skills";
  public static final String TOTAL_TIME = "totalTime";

  public static final String LEVEL_MAP = "levelMap";

  public static final int NUM_LEVELS = 5;
  public static final int MAX_ITEMS = 3;

  public static final String SCORE = "score";
  public static final String STARS = "stars";
  public static final String BEST_SCORES = "bestScores";
  public static final String BEST_TIMES = "bestTimes";

  GameDataMap gameDataMap;

  public void initGameData() {
    gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();

    // These will be independent of level.
    gameDataMap.getStringSet(SKILLS);
    gameDataMap.getAccumulatingNumber(TOTAL_TIME);

    // Use nested maps to establish some per-level values.
    for (int i=0; i < NUM_LEVELS; i++) {
      GameDataMap levelMap = gameDataMap.getMap(LEVEL_MAP + i);

      // Each level will have its own copy of these values.
      levelMap.getLatestNumber(SCORE);
      levelMap.getHighestNumber(STARS);
      levelMap.getHighNumberList(BEST_SCORES).setMaxSize(MAX_ITEMS);
      levelMap.getLowNumberList(BEST_TIMES).setMaxSize(MAX_ITEMS);
    }
  }

In the example above, we use initGameData() to establish the structure of the data we’ll synchronize, even though we don’t actually set any values. (It can be helpful to define the data layout in one place like this, even if it’s not strictly required.) The code effectively says,

  • There will be a global set of strings called SKILLS. It will track every string added to it (strings may not be removed).
  • There will be a global running total of time in the game called TOTAL_TIME. It will accumulate deltas submitted from all devices used by a single player.
  • There will be NUM_LEVELS nested maps, each of which will have its own set of values:
    • SCORE will always reflect the last score submitted for that level.
    • STARS will always reflect the maximum stars attained for that level.
    • BEST_SCORES will always list the MAX_ITEMS highest scores for that level.
    • BEST_TIMES will always list the MAX_ITEMS fastest times for that level.

Updating and Retrieving Game Data

Whispersync abstracts all game data persistence, so we can update or retrieve values using simple getters and setters. We don’t have to worry about managing a network connection, saving to disk or the cloud, or reconciling local and online versions of variables we have in memory. When we add to the running total of time played, for example, Whispersync automatically saves the delta to disk and updates the cloud if connected. If the player’s device is currently offline, the update will be queued and delivered later.

  public void updateTotalTime(int timePlayed) {
    SyncableAccumulatingNumber totalTime = gameDataMap.getAccumulatingNumber(TOTAL_TIME);

    // Add the time played to the running total.
    totalTime.increment(timePlayed);

    // Output the new total to the console.
    System.out.println("Total Time Played = " + totalTime.asInt());
  }

Likewise, we can record skills as the player masters them and easily iterate over the set to display the ones learned so far:

  public void learnSkill(String skill) {
    SyncableStringSet skillSet = gameDataMap.getStringSet(SKILLS);

    // Add the new skill to the player's repertoire. Note that this list

    // can only expand; strings cannot be removed.
    skillSet.add(skill);

    // Output all skills to the console.
    for (SyncableStringElement s : skillSet.getValues()) {
      System.out.println("Skill = " + s.getValue());
    }
  }

Updating numbers and number lists is just as straightforward, so persisting all of the player’s progress at the completion of a level can be done in just a few lines:

  public void finishLevel(int level, int score, int stars, int time) {
    GameDataMap levelMap = gameDataMap.getMap(LEVEL_MAP + level);

    // Save the score for this level. Newer values will always overwrite
    // previous scores.

    levelMap.getLatestNumber(SCORE).set(score);

    // Try to set the new maximum stars attained on this level. If the
    // value is less than the current maximum, this call does nothing.

    levelMap.getHighestNumber(STARS).set(stars);

    // Try to add this score to the list of all-time bests. If it's not
    // high enough, this update will be ignored.

    levelMap.getHighNumberList(BEST_SCORES).add(score);

    // Try to add this completion time to the list of all-time bests. If
    // it's not low enough, this update will be ignored.

    levelMap.getLowNumberList(BEST_TIMES).add(time);
    updateTotalTime(time);
  }

The accessors on GameDataMap and Whispersync’s syncable types make it easy to manipulate game data and define how conflicts should be resolved.

Think Mergeable!

Whispersync for Games automatically resolves conflicts for data it can merge, which makes it worthwhile to describe game data using syncable types when possible. Since Whispersync supports high, low, and most recent numbers and number lists; running totals; latest strings and string lists; sets of strings; and nested maps supporting hierarchical structures, a wide range of game data can be modeled.

Thinking about your game data in mergeable terms lets you push a lot of overhead out of your code. Let Whispersync handle the heavy lifting. For more information on integrating Whispersync into your game, see the online documentation

 

June 30, 2013

Peter Heinrich

We just released a major update to Amazon GameCircle, our free game service providing achievements, leaderboards, and Whispersync for Games. Games on all Android devices (including Kindle Fire, of course) can now integrate GameCircle, which is easy because we support Java, JNI, and Unity3D. Whether you submit your game to Amazon or Google, customers will benefit from the GameCircle experience. In addition, Whispersync has been dramatically improved, becoming the first and only cloud-save service to:

1) Automatically resolve data conflicts between mobile devices and the cloud,

2) Queue updates to support offline operation, and

3) Offer a simple interface that can be integrated in minutes.

The result: Your customers’ game data will automatically sync across devices—even if they play your game while temporarily offline—and you can concentrate on using the data instead of persisting it. You’re not locked in, though; you retain ownership and can always get a copy of the data you store.

We also give you flexibility when it comes to GameCircle display options, with no intrusive splash screen and configurable notification toasts. You’re in control and choose where they appear.

I’ll provide more technical details about these enhancements in future posts, but for now, let’s take a closer look Whispersync and explore its powerful new features and simplified interface.

Whispersync for Games

Whispersync does the heavy lifting when it comes to synchronizing local data to and from the cloud. It handles the tricky scenarios that you would normally have to deal with yourself, like conflicting updates from multiple devices or sync requests from a device that’s temporarily offline. You can also stop worrying about scalability; behind the curtain, Whispersync (and all of GameCircle) is powered by Amazon Web Services like S3 and DynamoDB.

Using Whispersync is easy through an API that has been completely redesigned, providing an interface similar to SharedPreferences. Saving game data to the cloud and synchronizing it between devices is as easy as retrieving a variable from a map and using (or changing) its value:

    // Get the global game data map for the current player.
    GameDataMap gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();

    // Look up the object representing the player’s skill rating.
    // If none exists, one will be created.

    SyncableNumber skillRating = gameDataMap.getHighestNumber("skillRating");
    System.out.println("skillRating = " + skillRating.asLong());

    . . .

    // Update the value. As long as this device is online (or as soon as
    // it is), local and cloud storage will be synced.

    skillRating.set(MAX_SKILLRATING);

Whispersync maintains a singleton instance of GameDataMap that acts as the root of your game data. It can track numbers, strings, simple lists, and other maps, and gives you complete freedom in how you represent your game data using these basic syncable types. You add new variables simply by retrieving them by name; if they don’t exist, they’ll be created on the fly and synchronized from that point on.

How Whispersync applies updates and resolves conflicts depends on the way you access each syncable variable. For example, suppose you want to retrieve the current user’s best (highest) level across all devices:

    GameDataMap gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();
    SyncableNumber bestLevel = gameDataMap.getHighestNumber( "bestLevel" );
    System.out.println( "bestLevel = "  + bestLevel.asLong());

In this case, because “bestLevel” is retrieved as a highest number, it will always reflect the maximum value ever assigned to it, from anywhere, on any device.

String values can also be synced. You could easily set the name of the latest power-up collected:

    gameDataMap.getLatestString( "lastPowerUp" ).set("Super Boingo"); 

The syncable string associated with “lastPowerUp” will always reflect the value most recently assigned to it.

The online documentation and Javadoc included with the SDK have more information on the syncable types Whispersync supports, as well as the ways in which each may be accessed.

Practical Applications

Let me provide a few more examples to illustrate just how straightforward synchronization can be.

Recording Star Count for Several Levels

A common pattern in many games is to show stars and unlock status for each level on a level selection screen. Here’s an example of using Whispersync to track individual star values for multiple levels:

  SyncableNumber[] getLevelStars() {
     GameDataMap gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();
     SyncableNumber[] stars = new SyncableNumber[NUM_LEVELS];

     // Get the star counts for all levels.
    
for (int i = 0; i < stars.length; i++) {
        stars[i] = gameDataMap.getHighestNumber("levelStars" + i);
     }

     return stars;
  }

The first time the score values are accessed (from anywhere), Whispersync will create entries for them in the cloud, so there’s no need to declare them ahead of time.

Accumulating a Running Total

Some progress, like coins collected or time played, represents a running total that is always updated using a delta amount. Instead of setting the value directly, you just submit the amount by which it should change. Whispersync automatically adds or subtracts this value to update the current total. For example:

 void addTimePlayedToTotal(long timePlayed) {
    GameDataMap gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();
    SyncableAccumulatingNumber totalTime =        gameDataMap.getAccumulatingNumber("totalTime");

    // This object may be incremented/decremented with long, double, and
    // BigDecimal values.

    totalTime.increment(timePlayed);
    System.out.println("Total time played: " + totalTime.asLong());
 }

Keeping a Map of Maps

By embedding a map within a map, you can create a hierarchical data structure. If your game has multiple worlds, for example, you might keep a separate GameDataMap for each one. Each of these might contain additional maps—say, one for each level.

 GameDataMap getWorldData(String name) {
    GameDataMap gameDataMap = AmazonGamesClient.getWhispersyncClient().getGameData();

    // Get all the string keys associated with top-level GameDataMap objects.
    Set<String> worldNames = gameDataMap.getMapKeys();

    // Look for a match among the maps.
    for (String currentName : worldNames) {
       if (currentName.equals(name)) {
          // A map exists for the name specified.
          return gameDataMap.getMap(currentName);
       }
    }

    // No match found. Don't create one.
    return null;
 }

Maintaining a List of Numbers

A racing game might save a player’s top three best times using a syncable number list. In this case, you could create a list for low numbers—they decrease as times improve—but you could easily choose to retain a collection of the highest or most recent values in other situations.

 // We'll initialize this once the application has launched.
 AmazonGames agsGameClient;
 GameDataMap agsGameData;
 SyncableNumberList agsBestTimes;

 // Create a callback to handle initialization result codes.
 AmazonGamesCallback agsGameCallback = new AmazonGamesCallback() {
    @Override
    public void onServiceReady(AmazonGamesClient client) {
       agsGameClient = client;
       agsGameData = AmazonGamesClient.getWhispersyncClient().getGameData();

       // Establish how many slots will be allocated and preserved.
       agsBestTimes = agsGameData.getLowNumberList("bestTimes");
       agsBestTimes.setMaxSize(3);
    }

    . . .
 };

  void finishLap(double time) {
   // Every time a lap is completed, try to add the lap time
   // to our list of best times. Only the lowest three will
   // ever be preserved.

   agsBestTimes.add(time);
 }

Every time the player finishes a lap, finishLap() would be called to update the number list. The value specified will be discarded unless it is lower than one of the current entries.

More to Come

The GameCircle improvements released in the latest update deserve more attention than the brief overview I’ve given here, so I’ll add details in the coming weeks. Look for articles dedicated to JNI; advanced API features; and using GameCircle with frameworks such as Unity3D, Cocos2d-x, and Marmalade. I’ll also dive deeper into Whispersync, discussing the difference between mergeable and non-mergeable data (and why it’s important), considerations when synchronizing currency across offline devices, and migration from the previous version. Stay tuned!

In the meantime, check out the new GameCircle release and give it a whirl. You’ll benefit whether you use the simplified Whispersync API and its expanded functionality, create a universal build to run on Kindle Fire and Android, or take advantage of the other features included with this update.

June 27, 2013

Peter Heinrich

Our A/B Testing service just added support for A/B/n tests, allowing more than two variations in a single experiment. This feature makes it even easier to quickly optimize your app in the field—without having to republish your APK. A/B/n testing saves you time since one experiment can now test up to five variations at once.

For example, suppose you have four ideas for how to label a Buy button – Buy, Purchase, Add to Cart, and Get it Now! – and want to know which label leads to the most purchases. You start by setting up an A/B test as you normally would (if you’re new to A/B testing on mobile, learn more about getting started) and click Add Variation for each new variation:

New A/B/n Test

A/B/n testing saves time, since standard A/B testing of four variations would require completing multiple A/B tests one after the other. The experiment above, for example, would require three separate tests, with the winning test becoming the new control each time.

A/B Test

A/B/n testing lets you compare all four variations at once, so only one test is necessary:

When planning an A/B test it is important to consider the size of the daily active user base you want to affect and how long you can wait for the test to complete. If a variation’s slice of the data is small, the A/B test may take a long time to achieve statistical significance. Apps with a large audience can likely distribute most customers to Variation A (Control) without sacrificing test time or significance. Apps with a smaller audience will want to distribute tests evenly across all variations as shown below:

A/B/n Testing Test Type

After you identify the winning variation, the A/B Testing service allows you to launch it to customers with a simple button click on the Mobile App Distribution Portal. There’s no need to republish your app. You can simply indicate which variation the service should distribute to customers from now on.

If you’re an Android developer, explore this update to the free Amazon A/B Testing service. We’re interested in hearing your feedback on A/B Testing. Please take this short survey to help us improve the service.

June 03, 2013

Mike Hines

Starting today, customers can now buy apps and games directly from PCs and Macs for their Android phones, tablets, and Kindle Fire. You can now reach the millions of customers visiting Amazon.co.jp, either by automatically being included in recommendations on product detail pages or product search results, or featured on the Amazon Appstore for Android web storefront. Plus, you can now directly link to your app or game to promote its availability on Amazon.co.jp—learn more about linking to your apps and games on Amazon here.

This comes on the heels of our recent announcements of the opening of our store in nearly 200 countries worldwide, and Kindle Fire HD becoming available for pre-order in those countries as well. The shop is open today, and available at www.amazon.co.jp/apps.

 

May 30, 2013

Peter Heinrich

It’s no secret that customer satisfaction is key to Amazon’s success. It’s something we obsess about, and we constantly tweak everything from product selection to payment options to website design. We experiment, we measure, and we decide whether or not a change improves the user experience. One of the most powerful tools at our disposal is something we call a Web Lab, which allows us to test two (or more) different versions of a webpage, or roll out a new feature to a limited audience.

Perhaps this concept is less familiar to mobile application and game developers than to those who write web code, but it shouldn’t be. In fact, it’s so useful and important that Amazon’s A/B Testing service was one of the first we made available to mobile developers (If you haven’t tried the service yet, check out Getting Started with A/B Testing for a quick introduction).

Now a significant enhancement has just been released: Segmentation offers greater flexibility and control over who sees your experiments, allowing you to limit your tests to a set of users based on any dimensions you care to associate with them.

User dimensions

A “dimension” in this sense is simply a named characteristic whose value is a number or a bit of text. The UserProfile singleton object manages the dimensions you define, keeping track of their values for the current user. It’s these values that determine whether the current user is a member of a particular segment, and it’s entirely up to you how they are chosen, named, and initialized.

For example, say I want to test a new wine feature in my restaurant review app. I don’t want everyone to see it—just my beta testers—so I define a dimension called “isBetaTester” and initialize it based on some information I know about the current user:

        // Determine if the current user is actually participating in the beta,

        // based on my own definition of “participating.”

        boolean isBetaTester = validateUserAsBetaTester();

 

        // Set the dimension for the current user.

        UserProfile.addDimensionAsString("isBetaTester", String.valueOf(isBetaTester));

 

        // Initialize the Insights SDK to enable A/B Testing.

        AmazonInsights.withApplicationKey(MY_APPLICATION_KEY)

                      .withPrivateKey(MY_PRIVATE_KEY)

                      .withContext(getApplicationContext())

                      .initialize();

                 . . .

In this case, validateUserAsBetaTester() is a helper method I define to assist me in deciding whether the current user is a beta tester or not. This could be a preferences setting, or perhaps a check against an email whitelist.  Regardless, I’m responsible for setting the value, which I do before initializing the A/B Testing system.

Create a segment

Now that I’ve established a dimension to differentiate users, I need to define a segment that actually refers to it. The segment may be associated with any A/B test, limiting access to users who match (or don’t match) along the relevant dimension. From the Amazon Mobile App Distribution Portal, I navigate to the A/B Testing tab of my app, then click Add a New Segment.

Next, I fill in the segment information, paying special attention to the dimension information, since that must correspond to the name (“isBetaTester”) and type (String) I use in my application. In this case, I define a segment called “Beta Testers” that will include anyone whose isBetaTester dimension is a string equal to “true”:

Limit a test

With a segment defined, I can now use it to limit the scope of an A/B test. Let’s say I want to experiment with the length of user-submitted wine reviews. (I’d like to give people more space, but have to balance the storage required against the benefit of more detailed content.) When I create the test, the last setting allows me to specify the user segment I want to target. In this case, I choose my beta testers, whom I just identified:

When the test is started, beta users will begin to see variations of wineReviewLen, subject to the distribution I specify.  In my app, I can initialize a variable with the maximum allowable review length for the current user:

        ABTest.getVariationsByProjectNames("Wine Reviews")

            .withVariationListener("Wine Reviews", new VariationListener() {

                public void onVariationAvailable(Variation variation) {

                    maxReviewLen = variation.getVariableAsInt("wineReviewLen", 256);

                }

            });

For users outside the Beta Testers segment, the control variation will always be allocated. However, these users will never be included when the results of the experiment are calculated.

Complex segment criteria

In this simple example, a single boolean value was enough to distinguish segment members, but segmentation supports much more complicated criteria. You can easily attach more than one variable or change how variables are evaluated. String equality works as demonstrated (numeric equality is identical), but it’s also possible to create a segment based on a numeric range or set membership.

For example, perhaps I want to further segment my beta testers by those who have made a past purchase. I can create a numeric value called purchasesToDate and define the valid range as any non-zero value—note that I just have to start at 0 (exclusive) and omit the upper bound:

If I wanted to create a segment of customers in the Pacific Northwest, but only those who have used the app in 2012 or 2013, I could combine two tests for set membership:

Important note: users retain the variation they are initially allocated, even if their dimensions change later on.  This means that once a user has been identified as a member of one segment, they never move to another for the duration of the test, even if their dimensions change. This ensures a consistent experience; significant changes to features or interface could be jarring. (If a new test is started, the dimensions will be re-evaluated.)

That’s it!

Setting up segments is simple and adds a lot of flexibility to your experiments.  Give it a try the next time you’re considering A/B testing.  For information, be sure to check out the Insights documentation.

May 29, 2013

Peter Heinrich

Login with Amazon is now available to developers to integrate in their mobile apps and websites. The new service lets you take advantage of the same user authentication system used by Amazon.com.  Login with Amazon allows you to securely recognize millions of Amazon customers and provide them with a personalized user experience.  For example, you can greet visitors by their name or display customized offers based on their zip code.

Login with Amazon uses the OAuth 2.0 protocol making it easy for you to integrate it in your app or website. Developers who have previously worked with the OAuth 2.0 protocol will find the terms and concepts straightforward and consistent with other implementations. 

How does Login with Amazon work?

  1. The user visits your website or app and clicks the Login with Amazon button.
  2. The user is presented with a login screen hosted on Amazon.com.
  3. The user enters their Amazon credentials.  First-time users will see a consent screen hosted on Amazon.com to grant your site permission to specific pieces of information.
  4. After the user consents, your app will be able to securely access customer profile data (name, email, zip code) to create a new user account and provide a personalized user experience for them.

Login with Amazon SDKs are available in public beta for Android, Kindle Fire, and iOS. To integrate the service in your app or website, go to login.amazon.com to register a developer account, download the SDKs, and view the Getting Started Guides.

Login with Amazon adds yet another capability for mobile app developers.  Now, developers can use Amazon Web Services (AWS) for its infrastructure (e.g., compute, storage, and database). For those interested in building cloud-backed apps, you can read more about it here.

 

May 28, 2013

Mike Hines

The Amazon A/B Testing service is an effective tool to increase user engagement and monetization. It allows you to set-up two in-app experiences (each of which is presented to a different group of users) and evaluate the success of each, based on criteria you establish. Another, less obvious, use of the A/B testing service is feature timing. It’s easy to turn on a new feature at a specific time, or release a series of features on a schedule. You can do it in four simple steps, which I walk through here:

  1. Creating a new A/B project and launch used for releasing a feature
  2. Integrating the SDK and API into your Android app
  3. Adding the Java code necessary to enable your feature based on the A/B launch
  4. Releasing your feature via Amazon’s A/B Testing portal

Step 1: Creating a new A/B project and launch used for releasing a feature

Using the Amazon A/B Testing service requires an Amazon developer account and an Android app associated with the account. If you don’t already have a developer account you can sign up here. The first step for using Amazon’s A/B Testing to release a feature is to create an A/B launch used to determine whether the feature in your app is hidden from users or accessible by them. Once signed into your developer account the following steps can be used to accomplish this:

  1. Navigate into your app. Click “My Apps” on the navigation bar of the Mobile App Distribution Portal to access your list of apps.
  2. On the detail page of your app, click the “A/B Testing” link as shown below.

    App Detail Page


  3. A screen displaying your list of A/B projects is displayed. Click “Add a New Project”.

    Amazon A/B Testing Page


  4. Enter a title and description that indicates this test is used for the launch of a specific feature and click “Save Project”.

    Add A/B Testing Create Project Page


  5. Click “Add a New Launch” on the detail page of the project you just created.

    A/B Testing Project Detail Page


  6. We are now looking at the page for creating an A/B launch. Enter a name and description that indicates this is used for a feature release. For the variable, we create a boolean that tracks whether the feature is enabled. The old variation is set to false and the new version is set to true. Make sure to keep the old variation set to 100% of the distribution. This means all users of your app will not have the feature enabled when you check this A/B launch’s variable. Click “Save” to add your A/B launch.

A/B Launch Creation Page

  1. Click the “Start” button on the newly created A/B launch to make it available for use.

List of A/B Items under the Project

Step 2: Integrating the SDK and API into your Android app

We now have an A/B launch containing a corresponding variable for determining whether our feature is made available. The next step is to integrate the A/B Testing SDK into our app using the following steps so we can write code to obtain whether the feature is made available.

  1. Download the Amazon A/B Testing SDK from here.
  2. Set the required permissions INTERNET and ACCESS_NETWORK_STATE in your AndroidManifest.xml file.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

  1. Add the Amazon Insights Processing Service to your AndroidManifest.xml.

<application>
    ...
    <service android:name="com.amazon.insights.InsightsProcessingService" />
</application>

  1. Add the AmazonInsights Android SDK jar and all 3 AWS Android jars to your Android project.  These jars can be found in the libs folder of the SDK download.
     

Step 3: Adding the Java code necessary to enable your feature based on the A/B launch

With the SDK setup its time to add code to either make our feature hidden or available based on the variable we configured for our A/B launch. The steps below detail the code needed for accomplishing this.

  1. Import Amazon Insights in to your code.

    import com.amazon.insights.*;

  2. Initialize the Amazon Insights SDK in the onCreate method of your Activity. Note: Your application key and private key can be found on the Amazon A/B Testing page for your application where we created the A/B project in step 1.

AmazonInsights

    .withApplicationKey(YOUR_APPLICATION_KEY)
    .withPrivateKey(YOUR_PRIVATE_KEY)
    .withContext(getApplicationContext())
    .initialize();

  1. Add code to enable the feature based on the A/B launch variable.  We obtain our A/B launch variable and check whether we should enable access to the feature.

//Get our “Feature Launch - FeatureName” experiment and retrieve the variable
//for whether the feature is made available.
ABTest
   .getVariationsByProjectNames("Feature Launch - FeatureName")
   .withVariationListener("Feature Launch - FeatureName", new VariationListener() {
      public void onVariationAvailable(Variation variation) {
         boolean featureNameEnabled = variation. getVariableAsBoolean(
            "FeatureName_IsLive", false);
         if (featureNameEnabled) {
            enableFeatureName();
         }
    }
});

 Step 4: Releasing your feature via Amazon’s A/B Testing portal

With your app now supporting the release of the feature, the final step is to make your feature available at the appropriate time. This can be done completely via the Amazon A/B Testing portal and doesn’t require an APK update with the feature enabled. To launch the feature use the following steps:

  1. Navigate back to the A/B launch experiment you created for your app’s feature release. This is accessible by clicking the “A/B Testing” link on your app’s detail page. Next click on the current experiment for our feature launch A/B project as displayed by Image 8 below.

    App Detail Page

A/B Project List

  1. Click the “Edit” tab to change the distrubtion of the variable we use to determine if the feature should be made available.

    A/B Launch Detail Page

When the Launch was created the distribution was set to 100% to the “Old Version”. Change the distribution of the new variation to 100%. All users of your app are going to receive true for the variable used to enable your feature. Click “Save Launch” and your feature will now be live for all users. 

In some scenarios you might want to incrementally release a new feature over time. This can beneficial when releasing features for which scaling might be a concern. For example,  you can use Launch to safely increase the percentage of customers receiving the feature while you monitor the scalability of your service.   If a problem is detected you can stop incrementing the release or in an extreme case pull it back.

A/B Launch Edit Page

That is all it takes to support releasing a feature via Amazon A/B Testing in your Amazon app. You can find more information the Amazon A/B Testing service here.

 

Want the latest?

appstore topics

Recent Posts

Archive