Integrating Amazon’s In-App Purchasing and Amazon GameCircle APIs into mobile games is easy, but we’re always working to make it even quicker and easier. Today, we're pleased to announce the release of new plug-ins for the In-App Purchasing and GameCircle APIs for the Unity game engine.

If you build your games with Unity, you can now use these plug-ins to rapidly add both In-App Purchasing for virtual goods and GameCircle for leaderboards, achievements, and Whispersync for Games. 

Unity Technologies' game engine is one of the most popular tools for creating games. It enables you to easily create rich, interactive 3D experiences by providing ways to assemble your art and assets into scenes and environments, add physics, and simultaneously play-test and edit games. When you’re finished building and testing, the Unity engine creates a binary targeted for your chosen platform –like an Android APK which you can publish to Kindle Fire and the Amazon Appstore for Android.

The new plug-ins for Unity are available today for free as part of the AmazonMobile App SDK. You can download the latest version here. Just follow the simple instructions in the documents to get started. Of course, you’ll also need the Unity game engine in order to use the plug-ins. If you haven’t tried it yet, you can download a free version of Unity here. 

Sign in to your Amazon Mobile App Distribution Portal account now to get started.

CJ Frost, Technical Evangelist for Amazon Kindle, is our guest blogger for this post.

Kindle Fire tablets are designed to be rich content consumption devices. To make sure your app supports this goal and provides the best user experience, keep in mind that you are building for a tablet, not a smartphone. Many apps are derived from existing Android smartphone apps and do not scale well to the tablet form factor. Scaled apps generally do not look as good as dedicated tablet apps and are feature-limited when compared to a similar app designed specifically for a tablet environment. These scaled apps can also suffer from significant degradation in graphics quality as the UI and elements are dynamically scaled up, by the Android platform, to fit the screen.

Optimizing your app for tablets offers numerous benefits. It enables you to offer a rich,easy-to-navigate, and more detailed user experience, allows you to optimize user engagement, and can potentially improve your monetization opportunities.

To help you create the best user experience for both small and larger screened devices, we've put together a list of our top phone-to-tablet app development tips.

Exploit the real estate.

Apps that are scaled up from a smaller screen size generally do not look as good as dedicated tablet apps and are feature-limited when compared to a similar app designed specifically for a tablet environment.

For example, many mobile phone apps are designed as lists of items (e.g., postings, photos) that link to new pages. When viewed on a Kindle Fire tablet, these apps appear feature-limited compared to a similar app designed specifically for a tablet environment. The lists do not fill the screen, nor do they take advantage of the potential user experience features.Apps designed to be multi-pane leverage the screen real estate so users can directly open content they'd otherwise page to on a phone app.

For more information on how to design your app for larger screens, see the Android documentation on devicesand displays,planningfor multiple touchscreen sizes, and movingfrom multi-page to multi-pane designs.

Optimize for dynamic resizing.

Apps designed for phones tend to be created as portrait apps only. Apps designed for tablets are optimized to be viewed in portrait or landscape mode by providing orientation-specific layouts, as demonstrated in the Simple RSS Reader Sample,and re-size dynamically using the accelerometer to sense orientation.

Apps designed primarily for use on phones can also suffer from significant degradation in graphics quality as the UI and elements are dynamically scaled up, by the Android platform, to fit the screens of larger devices.

For more information on how to design your app for dynamic resizing, see the Android documentation on supportingdifferent screen sizes.

Design for interactivity.

Apps designed for phones are intended to be used with one hand and provide single-point touch elements with larger touch targets to accommodate thumb navigation. In contrast, apps designed for tablets are developed using multi-point touch elements that can accommodate tablet users'normal two-handed pinch-zoom and swipe actions, providing a richer and more dynamic user experience.

For more information on how to design your app for interactivity, see the Android documentation on making interactive views.

Increase your reach.

Apps designed for phones tend to provide a static representation of non-interactive content. Apps designed for tablets offer additional opportunities for interactivity and can help you extend the reach of your business by including partner content, such as ads or additional game offerings, as well as interactive applets, in a multi-pane design.

Starting today, the Kindle Fire HD 8.9” will begin shipping to customers. Kindle Fire HD 8.9” offers a 1920x2000 HD resolution display,with Dolby audio and dual stereo speakers. There’s also Kindle Fire HD 8.9” 4G,which offers ultra-fast 4G LTE wireless from AT&T. This rounds out our new selection of Kindle Fire tablets, including the all-new Kindle Fire and the Kindle Fire HD, which has already become the best-selling item on Amazon worldwide.

Make sure your apps are ready. We’ve provided tools to optimize your app for Kindle Fire tablets, including the Kindle Fire HD 8.9”:

• Set up emulators for the Kindle Fire HD, Kindle Fire (2^nd generation) and Kindle FireHD 8.9”.

• Review our Kindle Fire development resources and documentation.

• Use Amazon Device Targeting to target specific app binaries to each Kindle Fire tablet.

For a full list of resources available, read our blog post from the Kindle Fire tablet announcement here.

Jonathan Wise, Technical Evangelist for Amazon Kindle, is our guest blogger for this post.

Many apps these days now use back-end services or some form of network connectivity to provide customers with up-to-date information. While tablet apps usually work over Wi-Fi, tablet devices that provide cellular data connectivity, such as the Kindle Fire HD 8.9" 4G LTE, delight customers by providing the always-on connectivity they've come to expect from their smartphones. Many cellular plans have data limits, and it’s important to respect the user's cellular data plan when designing your tablet apps.

To ensure your apps best utilize the customer's data plan, we recommend the following best practices:

• Detect the network connection.

Make sure your apps detect the type of network connection available and branches its behavior accordingly. For example, it is important to reduce the frequency or resolution of data downloaded in the background when the device is connected to a cellular network. To detect which type of network connection a customer is using, you can use the following code.

final ConnectivityManagerconnectManager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);                

NetworkInfo netInfo =connectManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

boolean isWANConnected =netInfo.isConnected();

NetworkInfo netInfo =connectManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

boolean isWIFIConnected = netInfo.isConnected();

• Block file transfers in excess of 50MB.

If a user tries to transfer a file in excess of 50MB while on cellular data, the app should provide an alert and abort the transfer. For consistency with first-party apps on the Kindle Fire HD 8.9" 4G LTE, we recommend using the following alert text:

"This item is over50MB and cannot be downloaded [or uploaded] over your Mobile Network connection. Please connect to a WiFi network to download [or upload] it."

You should also provide two buttons: one to Dismiss the warning,and the other to take the user to his or her Wireless & Networks network settings activity to enable connection to WiFi, if available. To open the Wireless& Network settings panel from your code, add the following:

startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS));

• Alert users of streaming audio or video.

When a user initiates streaming of audio or video over a cellular data connection, the app should alert him or her of the possible consequences before proceeding. For consistency with other Amazon apps on the Kindle Fire HD 8.9" 4G LTE, we recommend using the following alert text:

"It is recommended that you connect to a WiFi network when streaming media, to avoid excessive data use. Do you want to stream over your Mobile Network connection?"

You should also provide two buttons: one to Continue and another to Cancel. When the user clicks Cancel, do not stream the media.

• Gracefully handle the loss of connectivity.

When a customer consumes the monthly data plan on a Kindle Fire HD 8.9" 4G LTE, and has not purchased additional data, his or her cellular data connection will be disabled. The platform will manage alerts regarding data plan consumption, but your apps should gracefully handle the loss of connectivity -- both over Wi-Fi and over cellular data.

Following these best practices not only helps improve the user experience of your apps by protecting customers from inadvertent data consumption, it also helps ensure users feel safe using your apps on their Mobile Network-enabled device, no matter what network they're using. 

Jeremy Cath, Technical Evangelist for Amazon Kindle, is our guest blogger for this post.

How quickly your app starts is a significant factor in creating a good impression for your customers, especially if they use your app frequently. To help your app start quickly, consider the following best practices.

Minimize work on start-up

Show a minimal experience as fast as possible--some of the user perception of performance comes from how fast an app displays something after the user launches the app, so showing a minimal splash screen as soon as possible while the rest of the initial experience is loading makes startup appear more responsive.

The Android activity life cycle looks like this:

• onCreate() <-- activity is being CREATED
• onStart() <-- activity is becoming VISIBLE
  • onResume() <-- activity is coming to the FOREGROUND
  • onPause()
• onStop()
• onDestroy()

So one of the most effective ways to optimize startup time is to minimize tasks that take place in onCreate() and onStart().

Show a minimal splash screen at startup

If your full activity takes some time to display, starting with a minimum experience and transitioning to the main part of your application gives the user the impression of a responsive app.

One solution is described below. For a fuller version, download the Kindle Fire sample code and see the SampleSplashScreen sample.

<activity

   android:name=".Min"

   android:label="@string/title_activity_min"

   android:theme="@style/Theme.MinBackground" >

    <intent-filter>

        <action android:name="android.intent.action.MAIN" />

        <category android:name="android.intent.category.LAUNCHER" />

    </intent-filter>

</activity>

<activity

   android:name=".Full"

   android:label="@string/title_activity_full" >

</activity>

Notethe use of the theme: "MinBackground." This should be defined intheme.xml.

<style name="Theme.MinBackground" parent="android:Theme">

    <item name="android:windowBackground">@color/gray</item>

    <item name="android:windowNoTitle">true</item>

</style>

Andthe color "gray" can be defined in color.xml.

<color name="gray">#444444</color>

"Min" should be as simple as possible, for example (min_layout.xml):

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

   xmlns:tools="http://schemas.android.com/tools"

   android:layout_width="match_parent"

   android:layout_height="match_parent">

</RelativeLayout>

You could add a logo or text to this screen, but the overall goal is to make it lightweight and fast.

The launcher will invoke Min when starting the app. Inside Min you can then invoke Full(in a thread), which will display once loaded by doing this:

public class Min extendsActivity {

public class Min extendsActivity {

   @Override

    publicvoid onCreate(BundlesavedInstanceState) {

        super.onCreate(savedInstanceState);

// Hide the soft keys and status bar          I        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

       WindowManager.LayoutParams.FLAG_FULLSCREEN);

        // Display this activity.

       setContentView(R.layout.min_layout);

        // Create a thread to do the heavy lifting and then

        // start the Full Activity

        finalThread workerThread =new Thread(){

           @Override

           public void run() {

                // Call a method to perform thework.

                Min.this.loadResources();

               // Start the full Activity.

               Min.this.startActivity(newIntent(Min.this, Full.class));

               // Avoid the flash back to home screen.

               Min.this.overridePendingTransition(0, 0);

               // Never come back to this Activity.

               Min.this.finish();

           }

        };

        workerThread.start();

    }

}

Tuning startup under the covers

To tune startup "under the covers," consider the following tips:

• Use a Thread (or AsyncTask) for longer running tasks to avoid blocking the display and allow the user to start interacting with the app faster. However, be aware that thread synchronization can also take time, so assess the trade-offs and use threads wisely.
• Minimize allocations: The more you allocate at startup, the higher the risk that Garbage Collection will be triggered, which can result in unnecessary delays. If you are seeing references to garbage collection in the system log, you should review both your onCreate and onResume methods to look for ways to reduce allocations.
• Defer loading dependencies: If you have services that are not required for the initial user interaction (e.g., sync services or download managers), wait until you have a natural pause to load them, or load them when first requested by the user.
  • Lazily inflate views, if you can.
  • Lazily initialize objects, and avoid static initializers for referencing expensive things (they will get fired the moment the class is referenced, odds of that being on the main thread are high), for example:

// BAD!

  staticCacheManager sCacheManager = newCacheManager();

  // better

  staticCacheManager sCacheManager = null;

  publicstatic CacheManager getCacheManager() { if(sCacheManager== null) {sCacheManager = new CacheManager(); } returnsCacheManager; }

• Group and load assets based on when they are needed: Rather than load all assets at the outset, only load assets when they are required, or pre-load when the user is not going to notice the activity.

Cache network resources

If your app relies on network-loaded resources, use a persistent cache to avoid a network call during startup. This also applies within the app in general—avoid relying on a network connection if the assets can be retained locally; this will improve performance while reducing the user's bandwidth consumption.

Use static methods

On the Android platform, static methods have been demonstrated to perform up to 20% faster than virtual methods (see here for more information).

Avoid disk/network IO on the main UI thread

• Turn on StrictMode to check for this.
• Be mean: make StrictMode violations fatal: StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().penaltyDeath().build());
• However, when using Traceview, turn off StrictMode checking (strict checking is expensive!): StrictMode.setThreadPolicy(newStrictMode.ThreadPolicy.Builder().permitAll().build());

StrictMode and TraceView

To help you identify areas that need work in your app, there are a couple of handy tools that you should become familiar with:

StrictMode will help you identify bad practices in the UI thread, such as accessing the networkor disk. For information on how to use StrictMode, see the StrictModedocumentation.

Traceview can be used to profile what is happening in your app. For information on how to use Traceview,see the Traceview documentation.

As an example of how to use Traceview to measure startup time programmatically, you can follow these steps:

1. In onCreate() before calling super.onCreate(): Debug.startMethodTracing("somefilename");
2. Somewhere later (when you want profiling to stop, e.g.,at the end of onResume()): Debug.stopMethodTracing();
3. From your PC: adb pull /sdcard/somefilename.trace
4. From your PC: traceview some filename.trace
5. Look for methods that are consuming a lot of time. Drill down into each one until you find out what’s causing the slow down.

Traceview introduces overhead on its own, and as such is not terribly useful for making absolute statements about time (e.g., that XYZ takes 10ms). It is useful for finding hotspots, and (mostly) comparing relative runtimes of sections of code. Also, it’s worth noting that overhead is only introduced on the java side. Native methods run as quickly as they normally do—so native calls end up appearing to take a smaller percentage of runtime than they actually take.

With the all-new Kindle Fire and the Kindle Fire HD, there are several changes to the way media is handled in the browser. The biggest change is that Flash is no longer supported in the browser, due to significant changes to the version of Android used on the devices. Instead, our HTML5 support is improved, with support for both the HTML5 <video> and <audio> tags.

Video

On the new tablets, as with the Kindle Fire (1^st Generation), we open an Android player activity to handle playback, rather than playing video embedded in the browser. This approach means the referring web page will not be visible during video playback. We’ve also chosen to disable auto-play to prevent a jarring customer experience where page load would be immediately followed by a jump into full screen video, with no initiating action by the customer. Instead, the auto-play attribute is ignored, and JavaScript calls to play video are disabled until after the customer has interacted with the page at least once. Note: As long as a document remains loaded the 'has interacted' state is preserved, it is only reset when a new page is loaded or the existing page is reloaded.

Because video is handled by the Android player, HTML5 features such as custom controls or drawing over the video are not going to work as expected. We do bridge some video status events from the external player into the browser's JavaScript environment, but we recommend you not try to control playback using the JavaScript API as the customer experience is likely to be confusing.

The browser gets updates from the Android player activity and will emit JavaScript events to simulate how an embedded video would work. Supported events are: loadstart,loadedmetadata, loadeddata, durationchange, canplay, canplaythrough, play, waiting, playing, progress, timeupdate, pause, ended, abort, emptied. Other events such as those for seeking, rate changes, volume changes, etc. should not be counted on. Since customers can't see the browser pane while video is playing, we discourage any reliance on these events. The most useful event in our current implementation is the ended event, emitted when the video window is closed either due to hitting the back button or reaching the end of the video. In either case, the video will appear to have played to completion.  Duration events provide accurate duration times, but we don't generate regular progress events, only the ended event.For the moment there's no way to start a video playback anywhere other than at the beginning, seeking is not supported. Pause works, though using it will probably not provide the best customer experience as any web UI that would normally accompany this event would not be visible. Of course, customers will be able to skip forward and backward, pause, and so forth using the native controls of the Android player.

We currently support MP4 and WEBM video formats. If your<video> tag contains multiple formats we'll prefer MP4. The audio encoding in video streams must be at most stereo, the Kindle Fire family of devices doesn't support 5.1 audio. RTSP and HLS are supported by the Android player activity, for details on formats see http://developer.android.com/guide/appendix/media-formats.html.

We know that publishers want support from the browser for embedded video and that is something that we’re investigating.

Images

Image support has also been improved. In addition to all the expected browser image formats, we now support SVG via both the HTML5<svg> tag and .svg resources in <img> tags.

Audio

We fully support the HTML5 <audio> tag and playback happens in the browser. The default controls are improved from earlier devices, and custom controls are supported. Playback of multiple streams works as expected. MP3, OGG, and WAV audio are all supported, and JavaScript support is good, enabling algorithmic PCM Audio using data URIs, for example.

There is no current support for any kind of background audio, meaning that audio playback is paused when a tab loses focus.

Click "Continue Reading" for a complete list of supported formats.

Amazon customers are familiar with our personalized product recommendations—they’re front and center for customers on Amazon.com, as well as the Amazon Appstore for Android’s web store. Amazon’s recommendation engine ensures that each customer is receiving suggestions of other products based on their past purchases, making shopping convenient and allowing them to discover new products that they may be interested in. The same recommendation technology is now included on the Kindle Fire HD and all-new Kindle Fire.

Customers will see recommendations of other apps that they may enjoy right on the carousel of the Kindle Fire HD and all-new Kindle Fire. In the example below, you can see that customers who are downloading USA TODAYalso are commonly downloading TuneIn Radio Pro, Scrabble and CalenGoo.

From within the “Apps” category, customers are presented with another way to discover new apps. There’s the “Recommended for You” section, featuring apps personalized to the customer’s past downloads, and “New for You”, specifically featuring only new apps that they may be interested in.

Recommended apps are also featured on every app’s product page on the web, Kindle Fire tablets and in our smartphone app. Apps are featured in the “Customers Who Bought This App Also Bought” section based on similarities between customers downloading your apps and other apps on Amazon. For example, customers who downloaded Scope also are consistently downloading Minecraft – Pocket Edition, Temple Run: Brave and textPlus GOLD. This extends outside of just the Amazon Appstore too – if customers are buying any product on Amazon and also buying your app, the recommendation will show there, and vice versa. This means you may see toys or books within this area on your app, or your app may be featured similarly on a product in the Home or Video Games stores.

Improving app discovery is just another way that Amazon helps you grow your business. As a developer, all you need to do is submit your apps in the Mobile App Distribution Portal. We will take care of making sure your apps are presented in front of the right customers.

You might have already heard about the 6^th AWS Global Start-Up Challenge, which is now accepting entries for this year’s contest. This contest, launched in 2007, is away for promising start-ups to get noticed and compete for an opportunity to win some great rewards.

This year, Amazon Web Services will select four grand prize winners – one from each of the following categories:

• Gaming
• BigData & High Performance Computing
• Consumer Applications
• Business Applications

Each grand prize winner will be awarded $50,000 in cash, $50,000 in AWS credits, as well as AWS Business Support services for one year and technical mentorship from AWS.

The final judging event for the Challenge will take place on January 23-24, 2013 at the W hotel in San Francisco, California. 12 finalists will be flown from their place of residence to participate in the final judging round, where they will present to the Amazon Web Services Executive Team, as well as representatives from VC firms such as Sequoia, First Round Capital and Madrona. After the final judging round, we will be hosting a finale event at Dog Patch Wine Works in San Francisco, CA where we will announce the 4 Grand Prize Winners. Here, the 12 finalists will get to present to a large audience of start-ups, entrepreneurs and like-minded business professionals. This event is open to everyone to attend and registration will be announced shortly.

Don’t miss your change to win big. Learn more about this year’s Challenge and enter by visitinghttp://aws.amazon.com/startupchallenge . The deadline to enter is 11:59:59P.M. (PT) on Wednesday December 5, 2012. If you have more questions about the contest or your entry application, please refer to the Official Rules, Frequently Asked Questions page, or email awsstartups@amazon.com.

Interested? Get started here.

In addition to sessions on developing for Kindle Fire tablets, there are also great sessions at AWS re: Invent specifically for start-ups. Whether your start-up is running on AWS today or if you’re prototyping your mobile app, AWS re:Invent is the place to learn how to build and scale your business on the AWS Cloud. 

Mudeem Siddiqui, Solutions Architect, a2z Development Center Inc., an Amazon.com company, is our guest blogger for this post. 

initiatePurchaseUpdatesRequestis an important API call that enables developers to restore in-app purchases. A common use case for this method is when a customer buys in-app items on one device and then downloads the same app on another device, or when a customer re-installs the app after removing it from their device. In both scenarios, through the initiatePurchaseUpdatesRequest() call, make past in-app purchases and restore those purchases to the correct state.

Consider a scenario where a freemium app uses the In-App Purchasing API to grant an entitlement to the full version of the app. A customer downloads the free version and unlocks the full version through an in-app purchase. Then, they remove the app from their device. The customer then re-installs the app from the cloud. If the initiatePurchaseUpdatesRequestcall is used correctly, the customer will have a seamless experience and have access to full version of the app without taking any action. This is a great customer experience.

On the contrary, if the call is not used or used incorrectly, the customer will not have access to content they’ve already purchased. Instead, the customer will be presented with the free version and the option to purchase the full version. This is a bad customer experience and could lead to negative reviews.

PurchaseUpdates MethodCall

Make the PurchaseUpdates call whenever the onResume() activity lifecycle method is invoked and determine if the customer has already purchased any entitlements and subscriptions. Based on the result, lock/unlock content in the app as appropriate.

Here are the technical details of how to use PurchaseUpdatesAPI calls:

1. Override and implement onPurchaseUpdateResponse callback: In the Observer class that extends BasePurchasingObserver, override and implement callback onPurchaseUpdatesResponse. This callback will be called on initiation of purchase updated request.

private class MyObserver extends BasePurchasingObserver{

  ...

  //

 // Is invoked once the call from initiatePurchaseUpdatesRequest is completed.

 // On a successful response, a response object is passed which contains the request id, request

 // status, a set of previously purchased receipts, a set of revoked skus,and the next offset if

 // applicable. If a user downloads your application to another device,this call is used to sync

 // up this device with all the user's purchases.

  //

  // @param purchaseUpdatesResponse

 //   Response object containing the user's recent purchases.

  //

 @Override

  public void onPurchaseUpdatesResponse (PurchaseUpdatesResponsepurchaseUpdatesResponse){

    for (final String sku : purchaseUpdatesResponse.getRevokedSkus()){

      // Revoke Items here

   }

    switch(purchaseUpdatesResponse.getPurchaseUpdatesRequestStatus()) {

    case SUCCESSFUL:

        for (final Receipt receipt: purchaseUpdatesResponse.getReceipts()) {

          switch (receipt.getItemType()) {

          case ENTITLED:

            // If the receipt is for an entitlement,the customer is re-entitled.

            // Add re-entitlement code here

            break;

          case SUBSCRIPTION:

            // Purchase Updates forsubscriptions can be done here in one of two ways:

            // 1. Use the receipts to determineif the user currently has an active subscription

            // 2. Use the receipts to create asubscription history for your customer.

            break;

          }

        }

      case FAILED:

        // Failure Case

    }

  }

  ...

}

NOTE: Please be aware that this method is invoked on the UI thread. Any long-running tasks should run on another thread. It is best practice to use AyncTask to implement onPurchaseUpdatesResponse functionality. Please see ButtonClicker example for details.

2. Initiate the purchase update request: initiatePurchaseUpdatesRequest initiates a request to retrieve updates about items that customer has purchased. A good place to call this function is from onGetUserIdResponse()callback where initiateUserIdResponse() should be called from OnResume() in the MainActivity to check which customer has signed in. Chaining these calls ensures that you can correlate the user to the purchased content.

private class MyObserver extends BasePurchasingObserver{

  ...

  ...

 // When the application resumes the application checks which customer is signed in.

 @Override

  protected void onResume() {

    super.onResume();

   PurchasingManager.initiateGetUserIdRequest();

  };

  ...

  ...

}

private class MyObserver extends BasePurchasingObserver{

  ...

  ...

 @Override

  publicvoid onGetUserIdResponse(final GetUserIdResponsegetUserIdResponse) {

    ...

    ...

   PurchasingManager.initiatePurchaseUpdatesRequest(...)

    ...

    ...

  }

}

The argument to initiate PurchaseUpdateRequest is an offset. The offset represents a position in a set of paginated results. Operations that make use of an offset as input will provide an offset as an output. You can use the offset to get the next set of results. To reset an offset, you can pass in Offset.BEGINNING. It is a best practice to continue the current offset of the call within your app and use that offset for subsequent calls. It is best practice to associate an offset with a UserID in the event multiple customers share the same physical device. Offset values are base64 encoded values and not human readable.

NOTE: It's a best practice to have the onGetUserIdResponse implementation in an AsycTask. In that case, initiatePurchaseUpdatesRequest() should be called from onPostExecute() function of the AsycTask.

For a comprehensive example see ButtonClicker sample part of In-App Purchasing API.

Kate Shoaf, Marketing and Public Relations leader at PlayTales, is our guest blogger for this post.

PlayTales is a world leader in children’s bookstore apps, that has expanded internationally, with offices in the USA, UK, Spain, Romania, and China. Founded in 2010, PlayTales develops and distributes interactive playable storybooks for children within the world’s leading children’s bookstore app for smartphones and tablets.

International distribution has become a prominent part of PlayTales’ business plan as we’ve realized the international market can open the door to millions of downloads for our apps. Although we developed the app with the intention of mainly distributing in the USA, China and the UK have become some of our top downloaders. We´ve developed and localized our app to cater to the needs of our various international customers.

Based on our experiences, there are several things developers should consider as they prepare and launch their applications:

Language options

A unique feature of our app is the several language options users can choose. The selected language of the application is based on the settings of the user’s device, but within the application itself, you can choose to view the stories in a different language. For example, all of your menus and links are in English, but you can easily view all stories in their Spanish version, French version, Italian version, and so on. We know our target users are interested in exposing their children to various languages so we’ve developed our app to make this possibility easily attainable.

If you look at this screen shot, you’ll notice that all menu items are in English, while the books are available in Spanish; a unique feature that caters to our target user.

There is no substitute for a native speaker

Anyone can learn a new language, but when it comes to common phrases and appropriate expressions we’ve found that working with native speakers is the best method for localization. At PlayTales we translate our stories into eight different languages and there is no substitute for working with a native speaker. When translators become a part of your localization team, they understand the message and product quality you are trying to develop within your app.

Keep an eye on currency

With the current economic crises going on it seems that currencies all over the world are constantly on a roller coaster of changing value. Because our books are available in so many different countries, monitoring exchange rates has become an important pastime within the office. We deal with Dollars, Euros, Yuan, and Pounds and the constantly changing exchange rates have kept us on our toes. It is important to monitor the currencies you deal with because you can lose business if your prices are too high, and also miss opportunities to generate more revenue if your prices are too low. Monitor your money and don’t lose out on business because of this common mistake.

Direct contact with multilingual tech support

It’s almost impossible to release an app that is absolutely perfect. Listening to the comments of users can really help work out the kinks and improve your app. Within all PlayTales accounts, users have the option to directly contact our tech/localization team in whatever language they want. Because our translators work in-office, we are able to efficiently respond to everyone that contacts us in their native language. If you are going to have a multiple language app, make sure that your users can communicate with your tech team in their preferred language.

Adapt your app

Adapt your app so that it can be accessed by potentially everyone. PlayTales started out as an app only accessible through iOS devices. But as tablets like the Kindle Fire were released, it became obvious that adapting our apps to function on these devices was necessary. After teaming up with Amazon, we’ve seen a great increase in our number of downloads. Amazon’s submission module makes submitting localized features such as texts, graphics, and user interfaces a simple and quick process. Using Amazon as a distribution platform has made our app easily attainable for tablet users and has given us a chance to enter a market we hadn’t considered before. Remember that iTunes is not your only resource; you can develop and adapt your apps to function on almost any device and consequently tap into new markets.

Distributing internationally is becoming a necessity for many developers who want to stay on top of the market. Know your target users and develop your app accordingly, remember to use native speakers to help with localization, monitor exchange rates, offer tech support in various languages, and adapt your app to a changing market. Following this advice may help you find the international success we’ve experienced. New technologies are spreading to every part of the world, and along with it the newest applications. Take advantage of this opportunity and go global. 

Amazon’s mobile app distribution platform continues to expand internationally, giving developers a chance to grow their businesses. We are pleased to let you know that the Kindle Fire and Kindle Fire HD will be coming soon to Japan. Check out the press release here.

Additionally, we started shipping Kindle Fire and Kindle Fire HD tablets to the U.K., France, Germany, Italy and Spain this week.

Visit Kindle Fire Developer Resources to build for the Kindle Fire and Kindle Fire HD. And you can learn more about taking your app international with Android localization tips and resources and steps for localizing your app in the Distribution Portal right here on the blog.

Sign in to your Amazon Mobile App Distribution Portal account now to get started.

We’ve released a beta of the Kindle Fire HD 8.9" emulator to enable you to test and debug your apps in anticipation of the device launch next month. While we recommend developers test their apps on a physical device whenever possible, you can test many aspects of your apps without running your code on a device. This allows you to be confident that the user interface, navigation and flow through the application are as you designed it.

The emulator for the Kindle Fire HD 8.9" is currently available as a beta. Be aware that the user interface and functionality of the beta emulator may not match the experience available in the Kindle Fire HD 8.9"when it is released later this year.

With high resolution device emulators such as the Kindle Fire HD 8.9”, we recommend enabling GPU emulation. This will deliver a smoother graphical experience and faster start-up experience. While this will help performance throughout the emulator for host computers that support these capabilities, it will have the most impact in graphics-intensive OpenGL- based applications such as games. Learn more by following the instructions at this link. 

We’ve also updated the emulators for the all-new Kindle Fire and the Kindle Fire HD7” to reflect the software in the latest over-the-air software update.

Ready to get started? Review the documentation, install the emulators, and give them a whirl. We’d love to hear your feedback in the forums.

Kindle FreeTime is available in the latest over-the-air software update that was released today for the Kindle Fire HD and all-new Kindle Fire. This new feature provides a dedicated space for kids to interact with books, movies, TV shows, apps, and games.  

With Kindle FreeTime, parents never have to worry about the content their kids will access–parents select the content their kids will see , and kids can’t exit FreeTime without a password. Kindle FreeTime also offers parents enhanced tools to manage their child’s content and interaction, including multiple profile support and daily time limits. Parents can create a profile for each of their children and choose which books, movie, TV shows, apps, and games they want to give each child access to.

As a developer, you don’t need to do anything to participate in Kindle FreeTime other than build great products. Simply by including them in the Amazon Mobile App Distribution Program, your apps will be available for parents to include in their children’s personalized experience.

Join the Amazon team, along with mobile app and game developers like you, at AWS re: Invent for two days of sessions covering everything you need to know to grow your business and monetize on Kindle Fire. Amazon’s first developer conference is the perfect opportunity for you to learn strategies and tips to help you thrive, from creating engaging user experiences on Kindle Fire to building mobile apps that scale for rapid user adoption. You'll also be able to learn more about Amazon GameCircle, which makes it easy for you to create more engaging gaming experiences via achievements, leaderboards and sync APIs. 

Stop by our booth and play with Kindle Fire—we’ll have the Kindle Fire HD available for you to play with loaded with mobile apps and games that have already been optimized for the tablets. Plus, Amazon Mobile App Distribution marketing and technical representatives will be there, ready to answer your questions on optimizing for and being marketed on Kindle Fire.

Here are just some of the sessions offered for mobile app and game developers:

Distributing Apps Through Kindle Fire and the Amazon Appstore for Android

Aaron Rubenson, director of the Amazon Appstore, will provide an overview of the Amazon Mobile App Distribution Program, the Amazon Mobile App SDK, and resources available to developers for Kindle Fire tablet optimization. Learn how to grow your business by engaging new customers and monetizing your apps.

Creating the Killer App for Kindle Fire

Mike Nash, vice president of Kindle Developer Programs, will be providing tips and optimizations you can easily implement to make the killer app on Kindle Fire and stand out from the crowd.

Monetizing Your App on Kindle Fire: In-App Purchasing Made Easy

Mekka Okereke, developer services lead for the Amazon Appstore, will discuss how in-app purchasing can help you monetize your app and grow your business, as well as how to integrate the Amazon In-App Purchasing API into your mobile apps.

Level Up Your Kindle Games with Amazon GameCircle

Jason Chein, director of Game Services, will be presenting the brand new games library experience, fully integrated with Amazon GameCircle, and offering tips on how to increase customer engagement of your content. This session is open for all but specifically tailored for game designers,producers, and publishers.

In addition to the sessions and the expo, we will also be hosting other events:

• Ready to test your skills, building apps in the AWS cloud or optimizing for Kindle Fire? Complete in our Code Challenge, where you can win prizes such as Kindle Fire tablets, AWS credits, or Amazon.com gift cards.

• If you have questions about marketing your apps or optimizing your apps on Kindle Fire, come and meet with our technical and marketing teams—either in our expo booth or one-on-one during our office hours.

• Learn from accelerators, venture capitalists, and start-up founders on paths to launching your start-up. Hand-selected start-ups will publicly launch at AWS re: Invent. Are you ready to launch? Tell us about your start-up and be considered for one of the launch spots.

AWS re: Invent will be held Tuesday-Thursday, Nov. 27-29,2012, at the Venetian in Las Vegas. For more information about AWS re: Invent and to read about the 150+ sessions and other conference activities, go to the AWSre: Invent website.

We hope to see you there.

Amazon recently expanded electronic payments to include additional countries. Now more developers in the E.U. can select an electronic payment method as a more convenient way to receive payment.

Using electronic payment gives you the benefit of having your mobile app distribution payment sent directly to your bank, reducing the time it takes you to get paid. Plus electronic deposits paid in your home currency may help you avoid conversion fees that could be imposed by your bank.

Sign in to your Amazon Mobile App Distribution Portal account now to make sure your next payment is electronic. Simply select your bank’s location from the “Where is your bank/financial institution?” drop-down menu. If available, you will have the option to choose an electronic payment (this could be “wire transfer” or “electronic funds transfer”, depending on your location). Once selected you will need to enter your bank information.

The following thresholds must be met before Amazon issues a payment:

• USD Electronic Funds Transfer: $10
• EUR Electronic Funds Transfer: €10
• GBP Electronic Funds Transfer: £10
• Swiss Francs Electronic Funds Transfer: $10, €10 or £10
• EUR Wire Transfer: €100
• Check: $100, €100 or £100

See our previous post for some additional information here.