page.title=Creating Backward-Compatible UIs
page.tags="widgets","support"

trainingnavtop=true
startpage=true

@jd:body

<div id="tb-wrapper">
<div id="tb">

<h2>Dependencies and prerequisites</h2>

<ul>
  <li>API level 5</li>
  <li><a href="{@docRoot}tools/support-library/index.html">The Android Support Package</a></li>
</ul>

<h2>You should also read</h2>

<ul>
  <li><a href="{@docRoot}resources/samples/ActionBarCompat/index.html">ActionBarCompat</a></li>
  <li><a href="http://android-developers.blogspot.com/2010/07/how-to-have-your-cupcake-and-eat-it-too.html">How to have your (Cup)cake and eat it too</a></li>
</ul>

<h2>Try it out</h2>

<div class="download-box">
<a href="http://developer.android.com/shareables/training/TabCompat.zip"
  class="button">Download the sample app</a>
<p class="filename">TabCompat.zip</p>
</div>

</div>
</div>

<p>This class demonstrates how to use UI components and APIs available in newer versions of Android in a backward-compatible way, ensuring that your application still runs on previous versions of the platform.</p>

<p>Throughout this class, the new <a href="{@docRoot}guide/topics/ui/actionbar.html#Tabs">Action Bar Tabs</a> feature introduced in Android 3.0 (API level 11) serves as the guiding example, but you can apply these techniques to other UI components and API features.</p>

<h2 id="lessons">Lessons</h2>


<dl>
  <dt><strong><a href="abstracting.html">Abstracting the New APIs</a></strong></dt>
    <dd>Determine which features and APIs your application needs. Learn how to define application-specific, intermediary Java interfaces that abstract the implementation of the UI component to your application.</dd>

  <dt><strong><a href="new-implementation.html">Proxying to the New APIs</a></strong></dt>
    <dd>Learn how to create an implementation of your interface that uses newer APIs.</dd>

  <dt><strong><a href="older-implementation.html">Creating an Implementation with Older APIs</a></strong></dt>
    <dd>Learn how to create a custom implementation of your interface that uses older APIs.</dd>

  <dt><strong><a href="using-component.html">Using the Version-Aware Component</a></strong></dt>
    <dd>Learn how to choose an implementation to use at runtime, and begin using the interface in your application.</dd>
</dl>
