page.title=Best Practices
excludeFromSuggestions=true
page.landing=true
page.landing.intro=Design and build apps the right way. Learn how to create apps that look great and perform well on as many devices as possible, from phones to tablets and more.  
page.landing.image=

@jd:body

<div class="landing-docs">

  <div class="col-12">
    <h3>Blog Articles</h3>
    
    <a href="http://android-developers.blogspot.com/2010/10/improving-app-quality.html">
      <h4>Improving App Quality</h4>
      <p>One way of improving your app’s visibility in the ecosystem is by deploying well-targeted
mobile advertising campaigns and cross-app promotions. However, there’s another time-tested method
of fueling the impression-install-ranking cycle: improve the product!</p>
    </a>
    
    <a href="http://android-developers.blogspot.com/2012/01/say-goodbye-to-menu-button.html">
      <h4>Say Goodbye to the Menu Button</h4>
      <p>As Ice Cream Sandwich rolls out to more devices, it's important that you begin to migrate
your designs to the action bar in order to promote a consistent Android user experience.</p>
    </a>
    
    <a href="http://android-developers.blogspot.com/2011/07/new-tools-for-managing-screen-sizes.html">
      <h4>New Tools For Managing Screen Sizes</h4>
      <p>Android 3.2 includes new tools for supporting devices with a wide range of screen sizes.
One important result is better support for a new size of screen; what is typically called a “7-inch”
tablet. This release also offers several new APIs to simplify developers’ work in adjusting to
different screen sizes.</p>
    </a>
    
    <a href="http://android-developers.blogspot.com/2011/03/identifying-app-installations.html">
      <h4>Identifying App Installations</h4>
      <p>It is very common, and perfectly reasonable, for a developer to want to track individual
installations of their apps. It sounds plausible just to call TelephonyManager.getDeviceId() and use
that value to identify the installation. There are problems with this</p>
    </a>
    
    <a
href="http://android-developers.blogspot.com/2011/11/making-android-games-that-play-nice.html">
      <h4>Making Android Games that Play Nice</h4>
      <p>Making a game on Android is easy. Making a <em>great</em> game for a mobile, multitasking,
often multi-core, multi-purpose system like Android is trickier. Even the best developers frequently
make mistakes in the way they interact with the Android system and with other applications</p>
    </a>
    
  </div>


</div>
