Massive clobber of all HTML files in developer docs for new site design
Change-Id: Idc55a0b368c1d2c1e7d4999601b739dd57f08eb3
diff --git a/docs/html/tools/aidl.jd b/docs/html/tools/aidl.jd
new file mode 100644
index 0000000..805b7ec
--- /dev/null
+++ b/docs/html/tools/aidl.jd
@@ -0,0 +1,465 @@
+page.title=Android Interface Definition Language (AIDL)
+@jd:body
+
+
+<div id="qv-wrapper">
+<div id="qv">
+<h2>In this document</h2>
+<ol>
+ <li><a href="#Defining">Defining an AIDL Interface</a>
+ <ol>
+ <li><a href="#Create">Create the .aidl file</a></li>
+ <li><a href="#Implement">Implement the interface</a></li>
+ <li><a href="#Expose">Expose the interface to clients</a></li>
+ </ol>
+ </li>
+ <li><a href="#PassingObjects">Passing Objects over IPC</a></li>
+ <li><a href="#Calling">Calling an IPC Method</a></li>
+</ol>
+
+<h2>See also</h2>
+<ol>
+ <li><a href="{@docRoot}guide/components/bound-services.html">Bound Services</a></li>
+</ol>
+
+</div>
+</div>
+
+
+<p>AIDL (Android Interface Definition Language) is similar to other IDLs you might have
+worked with. It allows you to define the programming interface that both
+the client and service agree upon in order to communicate with each other using
+interprocess communication (IPC). On Android, one process cannot normally access the
+memory of another process. So to talk, they need to decompose their objects into primitives that the
+operating system can understand, and marshall the objects across that boundary for you. The code to
+do that marshalling is tedious to write, so Android handles it for you with AIDL.</p>
+
+<p class="note"><strong>Note:</strong> Using AIDL is necessary only if you allow clients from
+different applications to access your service for IPC and want to handle multithreading in your
+service. If you do not need to perform concurrent IPC across
+different applications, you should create your interface by <a
+href="{@docRoot}guide/components/bound-services.html#Binder">implementing a
+Binder</a> or, if you want to perform IPC, but do <em>not</em> need to handle multithreading,
+implement your interface <a
+href="{@docRoot}guide/components/bound-services.html#Messenger">using a Messenger</a>.
+Regardless, be sure that you understand <a
+href="{@docRoot}guide/components/bound-services.html">Bound Services</a> before
+implementing an AIDL.</p>
+
+<p>Before you begin designing your AIDL interface, be aware that calls to an AIDL interface are
+direct function calls. You should not make assumptions about the thread in which the call
+occurs. What happens is different depending on whether the call is from a thread in the
+local process or a remote process. Specifically:</p>
+
+<ul>
+<li>Calls made from the local process are executed in the same thread that is making the call. If
+this is your main UI thread, that thread continues to execute in the AIDL interface. If it is
+another thread, that is the one that executes your code in the service. Thus, if only local
+threads are accessing the service, you can completely control which threads are executing in it (but
+if that is the case, then you shouldn't be using AIDL at all, but should instead create the
+interface by <a href="{@docRoot}guide/components/bound-services.html#Binder">implementing a
+Binder</a>).</li>
+
+<li>Calls from a remote process are dispatched from a thread pool the platform maintains inside of
+your own process. You must be prepared for incoming calls from unknown threads, with multiple calls
+happening at the same time. In other words, an implementation of an AIDL interface must be
+completely thread-safe.</li>
+
+<li>The {@code oneway} keyword modifies the behavior of remote calls. When used, a remote call does
+not block; it simply sends the transaction data and immediately returns.
+The implementation of the interface eventually receives this as a regular call from the {@link
+android.os.Binder} thread pool as a normal remote call. If {@code oneway} is used with a local call,
+there is no impact and the call is still synchronous.</li>
+</ul>
+
+
+<h2 id="Defining">Defining an AIDL Interface</h2>
+
+<p>You must define your AIDL interface in an {@code .aidl} file using the Java
+programming language syntax, then save it in the source code (in the {@code src/} directory) of both
+the application hosting the service and any other application that binds to the service.</p>
+
+<p>When you build each application that contains the {@code .aidl} file, the Android SDK tools
+generate an {@link android.os.IBinder} interface based on the {@code .aidl} file and save it in
+the project's {@code gen/} directory. The service must implement the {@link android.os.IBinder}
+interface as appropriate. The client applications can then bind to the service and call methods from
+the {@link android.os.IBinder} to perform IPC.</p>
+
+<p>To create a bounded service using AIDL, follow these steps:</p>
+<ol>
+ <li><a href="#CreateAidl">Create the .aidl file</a>
+ <p>This file defines the programming interface with method signatures.</p>
+ </li>
+ <li><a href="#ImplementTheInterface">Implement the interface</a>
+ <p>The Android SDK tools generate an interface in the Java programming language, based on your
+{@code .aidl} file. This interface has an inner abstract class named {@code Stub} that extends
+{@link android.os.Binder} and implements methods from your AIDL interface. You must extend the
+{@code Stub} class and implement the methods.</p>
+ </li>
+ <li><a href="#ExposeTheInterface">Expose the interface to clients</a>
+ <p>Implement a {@link android.app.Service Service} and override {@link
+android.app.Service#onBind onBind()} to return your implementation of the {@code Stub}
+class.</p>
+ </li>
+</ol>
+
+<p class="caution"><strong>Caution:</strong> Any changes that you make to your AIDL interface after
+your first release must remain backward compatible in order to avoid breaking other applications
+that use your service. That is, because your {@code .aidl} file must be copied to other applications
+in order for them to access your service's interface, you must maintain support for the original
+interface.</p>
+
+
+<h3 id="Create">1. Create the .aidl file</h3>
+
+<p>AIDL uses a simple syntax that lets you declare an interface with one or more methods that can
+take parameters and return values. The parameters and return values can be of any type, even other
+AIDL-generated interfaces.</p>
+
+<p>You must construct the {@code .aidl} file using the Java programming language. Each {@code .aidl}
+file must define a single interface and requires only the interface declaration and method
+signatures.</p>
+
+<p>By default, AIDL supports the following data types:</p>
+
+<ul>
+ <li>All primitive types in the Java programming language (such as {@code int}, {@code long},
+{@code char}, {@code boolean}, and so on)</li>
+ <li>{@link java.lang.String}</li>
+ <li>{@link java.lang.CharSequence}</li>
+ <li>{@link java.util.List}
+ <p>All elements in the {@link java.util.List} must be one of the supported data types in this
+list or one of the other AIDL-generated interfaces or parcelables you've declared. A {@link
+java.util.List} may optionally be used as a "generic" class (for example,
+<code>List<String></code>).
+The actual concrete class that the other side receives is always an {@link
+java.util.ArrayList}, although the method is generated to use the {@link
+java.util.List} interface.</p>
+ </li>
+ <li>{@link java.util.Map}
+ <p>All elements in the {@link java.util.Map} must be one of the supported data types in this
+list or one of the other AIDL-generated interfaces or parcelables you've declared. Generic maps,
+(such as those of the form
+{@code Map<String,Integer>} are not supported. The actual concrete class that the other side
+receives is always a {@link java.util.HashMap}, although the method is generated to
+use the {@link java.util.Map} interface.</p>
+ </li>
+</ul>
+
+<p>You must include an {@code import} statement for each additional type not listed above, even if
+they are defined in the same package as your interface.</p>
+
+<p>When defining your service interface, be aware that:</p>
+<ul>
+ <li>Methods can take zero or more parameters, and return a value or void.</li>
+ <li>All non-primitive parameters require a directional tag indicating which way the data goes.
+Either <code>in</code>, <code>out</code>, or <code>inout</code> (see the example below).
+ <p>Primitives are <code>in</code> by default, and cannot be otherwise.</p>
+ <p class="caution"><strong>Caution:</strong> You should limit the direction to what is truly
+needed, because marshalling parameters is expensive.</p></li>
+ <li>All code comments included in the {@code .aidl} file are included in the generated {@link
+android.os.IBinder} interface (except for comments before the import and package
+statements).</li>
+ <li>Only methods are supported; you cannot expose static fields in AIDL.</li>
+</ul>
+
+<p>Here is an example {@code .aidl} file:</p>
+
+<pre>
+// IRemoteService.aidl
+package com.example.android;
+
+// Declare any non-default types here with import statements
+
+/** Example service interface */
+interface IRemoteService {
+ /** Request the process ID of this service, to do evil things with it. */
+ int getPid();
+
+ /** Demonstrates some basic types that you can use as parameters
+ * and return values in AIDL.
+ */
+ void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
+ double aDouble, String aString);
+}
+</pre>
+
+<p>Simply save your {@code .aidl} file in your project's {@code src/} directory and when you
+build your application, the SDK tools generate the {@link android.os.IBinder} interface file in your
+project's {@code gen/} directory. The generated file name matches the {@code .aidl} file name, but
+with a {@code .java} extension (for example, {@code IRemoteService.aidl} results in {@code
+IRemoteService.java}).</p>
+
+<p>If you use Eclipse, the incremental build generates the binder class almost immediately. If you
+do not use Eclipse, then the Ant tool generates the binder class next time you build your
+application—you should build your project with <code>ant debug</code> (or <code>ant
+release</code>) as soon as you're finished writing the {@code .aidl} file, so that your code can
+link against the generated class.</p>
+
+
+<h3 id="Implement">2. Implement the interface</h3>
+
+<p>When you build your application, the Android SDK tools generate a {@code .java} interface file
+named after your {@code .aidl} file. The generated interface includes a subclass named {@code Stub}
+that is an abstract implementation of its parent interface (for example, {@code
+YourInterface.Stub}) and declares all the methods from the {@code .aidl} file.</p>
+
+<p class="note"><strong>Note:</strong> {@code Stub} also
+defines a few helper methods, most notably {@code asInterface()}, which takes an {@link
+android.os.IBinder} (usually the one passed to a client's {@link
+android.content.ServiceConnection#onServiceConnected onServiceConnected()} callback method) and
+returns an instance of the stub interface. See the section <a href="#calling">Calling an IPC
+Method</a> for more details on how to make this cast.</p>
+
+<p>To implement the interface generated from the {@code .aidl}, extend the generated {@link
+android.os.Binder} interface (for example, {@code YourInterface.Stub}) and implement the methods
+inherited from the {@code .aidl} file.</p>
+
+<p>Here is an example implementation of an interface called {@code IRemoteService} (defined by the
+{@code IRemoteService.aidl} example, above) using an anonymous instance:</p>
+
+<pre>
+private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
+ public int getPid(){
+ return Process.myPid();
+ }
+ public void basicTypes(int anInt, long aLong, boolean aBoolean,
+ float aFloat, double aDouble, String aString) {
+ // Does nothing
+ }
+};
+</pre>
+
+<p>Now the {@code mBinder} is an instance of the {@code Stub} class (a {@link android.os.Binder}),
+which defines the RPC interface for the service. In the next step, this instance is exposed to
+clients so they can interact with the service.</p>
+
+<p>There are a few rules you should be aware of when implementing your AIDL interface: </p>
+<ul>
+ <li>Incoming calls are not guaranteed to be executed on the main thread, so you need to think
+about multithreading from the start and properly build your service to be thread-safe.</li>
+ <li>By default, RPC calls are synchronous. If you know that the service takes more than a few
+milliseconds to complete a request, you should not call it from the activity's main thread, because
+it might hang the application (Android might display an "Application is Not Responding"
+dialog)—you should usually call them from a separate thread in the client. </li>
+ <li>No exceptions that you throw are sent back to the caller.</li>
+</ul>
+
+
+<h3 id="Expose">3. Expose the interface to clients</h3>
+
+<p>Once you've implemented the interface for your service, you need to expose it to
+clients so they can bind to it. To expose the interface
+for your service, extend {@link android.app.Service Service} and implement {@link
+android.app.Service#onBind onBind()} to return an instance of your class that implements
+the generated {@code Stub} (as discussed in the previous section). Here's an example
+service that exposes the {@code IRemoteService} example interface to clients. </p>
+
+<pre>
+public class RemoteService extends Service {
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ }
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ // Return the interface
+ return mBinder;
+ }
+
+ private final IRemoteService.Stub mBinder = new IRemoteService.Stub() {
+ public int getPid(){
+ return Process.myPid();
+ }
+ public void basicTypes(int anInt, long aLong, boolean aBoolean,
+ float aFloat, double aDouble, String aString) {
+ // Does nothing
+ }
+ };
+}
+</pre>
+
+<p>Now, when a client (such as an activity) calls {@link android.content.Context#bindService
+bindService()} to connect to this service, the client's {@link
+android.content.ServiceConnection#onServiceConnected onServiceConnected()} callback receives the
+{@code mBinder} instance returned by the service's {@link android.app.Service#onBind onBind()}
+method.</p>
+
+<p>The client must also have access to the interface class, so if the client and service are in
+separate applications, then the client's application must have a copy of the {@code .aidl} file
+in its {@code src/} directory (which generates the {@code android.os.Binder}
+interface—providing the client access to the AIDL methods).</p>
+
+<p>When the client receives the {@link android.os.IBinder} in the {@link
+android.content.ServiceConnection#onServiceConnected onServiceConnected()} callback, it must call
+<code><em>YourServiceInterface</em>.Stub.asInterface(service)</code> to cast the returned
+parameter to <code><em>YourServiceInterface</em></code> type. For example:</p>
+
+<pre>
+IRemoteService mIRemoteService;
+private ServiceConnection mConnection = new ServiceConnection() {
+ // Called when the connection with the service is established
+ public void onServiceConnected(ComponentName className, IBinder service) {
+ // Following the example above for an AIDL interface,
+ // this gets an instance of the IRemoteInterface, which we can use to call on the service
+ mIRemoteService = IRemoteService.Stub.asInterface(service);
+ }
+
+ // Called when the connection with the service disconnects unexpectedly
+ public void onServiceDisconnected(ComponentName className) {
+ Log.e(TAG, "Service has unexpectedly disconnected");
+ mIRemoteService = null;
+ }
+};
+</pre>
+
+<p>For more sample code, see the <a
+href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/app/RemoteService.html">{@code
+RemoteService.java}</a> class in <a
+href="{@docRoot}resources/samples/ApiDemos/index.html">ApiDemos</a>.</p>
+
+
+
+
+
+
+
+
+<h2 id="PassingObjects">Passing Objects over IPC</h2>
+
+<p>If you have a class that you would like to send from one process to another through
+an IPC interface, you can do that. However, you must ensure that the code for your class is
+available to the other side of the IPC channel and your class must support the {@link
+android.os.Parcelable} interface. Supporting the {@link android.os.Parcelable} interface is
+important because it allows the Android system to decompose objects into primitives that can be
+marshalled across processes.</p>
+
+<p>To create a class that supports the {@link android.os.Parcelable} protocol, you must do the
+following:</b>
+<ol>
+<li>Make your class implement the {@link android.os.Parcelable} interface.</li>
+<li>Implement {@link android.os.Parcelable#writeToParcel writeToParcel}, which takes the
+current state of the object and writes it to a {@link android.os.Parcel}.</li>
+<li>Add a static field called <code>CREATOR</code> to your class which is an object implementing
+the {@link android.os.Parcelable.Creator Parcelable.Creator} interface.</li>
+<li>Finally, create an {@code .aidl} file that declares your parcelable class (as shown for the
+{@code Rect.aidl} file, below).
+ <p>If you are using a custom build process, do <em>not</em> add the {@code .aidl} file to your
+build. Similar to a header file in the C language, this {@code .aidl} file isn't compiled.</p></li>
+</ol>
+
+<p>AIDL uses these methods and fields in the code it generates to marshall and unmarshall
+your objects.</p>
+
+<p>For example, here is a {@code Rect.aidl} file to create a {@code Rect} class that's
+parcelable:</p>
+
+<pre>
+package android.graphics;
+
+// Declare Rect so AIDL can find it and knows that it implements
+// the parcelable protocol.
+parcelable Rect;
+</pre>
+
+<p>And here is an example of how the {@link android.graphics.Rect} class implements the
+{@link android.os.Parcelable} protocol.</p>
+
+<pre>
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public final class Rect implements Parcelable {
+ public int left;
+ public int top;
+ public int right;
+ public int bottom;
+
+ public static final Parcelable.Creator<Rect> CREATOR = new
+Parcelable.Creator<Rect>() {
+ public Rect createFromParcel(Parcel in) {
+ return new Rect(in);
+ }
+
+ public Rect[] newArray(int size) {
+ return new Rect[size];
+ }
+ };
+
+ public Rect() {
+ }
+
+ private Rect(Parcel in) {
+ readFromParcel(in);
+ }
+
+ public void writeToParcel(Parcel out) {
+ out.writeInt(left);
+ out.writeInt(top);
+ out.writeInt(right);
+ out.writeInt(bottom);
+ }
+
+ public void readFromParcel(Parcel in) {
+ left = in.readInt();
+ top = in.readInt();
+ right = in.readInt();
+ bottom = in.readInt();
+ }
+}
+</pre>
+
+<p>The marshalling in the {@code Rect} class is pretty simple. Take a look at the other
+methods on {@link android.os.Parcel} to see the other kinds of values you can write
+to a Parcel.</p>
+
+<p class="warning"><strong>Warning:</strong> Don't forget the security implications of receiving
+data from other processes. In this case, the {@code Rect} reads four numbers from the {@link
+android.os.Parcel}, but it is up to you to ensure that these are within the acceptable range of
+values for whatever the caller is trying to do. See <a
+href="{@docRoot}guide/topics/security/security.html">Security and Permissions</a> for more
+information about how to keep your application secure from malware.</p>
+
+
+
+<h2 id="Calling">Calling an IPC Method</h2>
+
+<p>Here are the steps a calling class must take to call a remote interface defined with AIDL: </p>
+<ol>
+ <li>Include the {@code .aidl} file in the project {@code src/} directory.</li>
+ <li>Declare an instance of the {@link android.os.IBinder} interface (generated based on the
+AIDL). </li>
+ <li>Implement {@link android.content.ServiceConnection ServiceConnection}. </li>
+ <li>Call {@link
+android.content.Context#bindService(android.content.Intent,android.content.ServiceConnection,int)
+ Context.bindService()}, passing in your {@link
+android.content.ServiceConnection} implementation. </li>
+ <li>In your implementation of {@link
+android.content.ServiceConnection#onServiceConnected onServiceConnected()},
+you will receive an {@link android.os.IBinder} instance (called <code>service</code>). Call
+<code><em>YourInterfaceName</em>.Stub.asInterface((IBinder)<em>service</em>)</code> to
+ cast the returned parameter to <em>YourInterface</em> type.</li>
+ <li>Call the methods that you defined on your interface. You should always trap
+ {@link android.os.DeadObjectException} exceptions, which are thrown when
+ the connection has broken; this will be the only exception thrown by remote
+ methods.</li>
+ <li>To disconnect, call {@link
+android.content.Context#unbindService(android.content.ServiceConnection)
+ Context.unbindService()} with the instance of your interface. </li>
+</ol>
+<p>A few comments on calling an IPC service:</p>
+<ul>
+ <li>Objects are reference counted across processes. </li>
+ <li>You can send anonymous objects
+ as method arguments. </li>
+</ul>
+
+<p>For more information about binding to a service, read the <a
+href="{@docRoot}guide/components/bound-services.html#Binding">Bound Services</a>
+document.</p>
+
+<p>Here is some sample code demonstrating calling an AIDL-created service, taken
+ from the Remote Service sample in the ApiDemos project.</p>
+<p>{@sample development/samples/ApiDemos/src/com/example/android/apis/app/RemoteService.java
+ calling_a_service}</p>
diff --git a/docs/html/tools/avd.html b/docs/html/tools/avd.html
new file mode 100644
index 0000000..1d314a1
--- /dev/null
+++ b/docs/html/tools/avd.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/devices/index.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/devices/index.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/building/building-cmdline.jd b/docs/html/tools/building/building-cmdline.jd
new file mode 100644
index 0000000..6154d96
--- /dev/null
+++ b/docs/html/tools/building/building-cmdline.jd
@@ -0,0 +1,371 @@
+page.title=Building and Running from the Command Line
+parent.title=Building and Running
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#DebugMode">Building in Debug Mode</a></li>
+ <li><a href="#ReleaseMode">Building in Release Mode</a>
+ <ol>
+ <li><a href="#ManualReleaseMode">Build unsigned</a></li>
+ <li><a href="#AutoReleaseMode">Build signed and aligned</a></li>
+ <li><a href="#OnceBuilt">Once built and signed in release mode</a></li>
+ </ol>
+ </li>
+ <li><a href="#RunningOnEmulator">Running on the Emulator</a></li>
+ <li><a href="#RunningOnDevice">Running on a Device</a></li>
+ <li><a href="#Signing">Application Signing</a></li>
+ <li><a href="#AntReference">Ant Command Reference</a></li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/devices/managing-avds-cmdline.html">Managing AVDs from
+the Command Line</a></li>
+ <li><a href="{@docRoot}tools/devices/emulator.html">Using the Android
+Emulator</a></li>
+ <li><a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>There are two ways to build your application using the Ant build script: one for
+ testing/debugging your application — <em>debug mode</em> — and one for building your
+ final package for release — <em>release mode</em>. Regardless of which way you build your application,
+ it must be signed before it can install on an emulator or device—with a debug key when building
+ in debug mode and with your own private key when building in release mode.</p>
+
+ <p>Whether you're building in debug mode or release mode, you need to use the Ant tool to compile
+ and build your project. This will create the .apk file that you can install on an emulator or device.
+ When you build in debug mode, the .apk file is automatically signed by the SDK tools with
+ a debug key, so it's instantly ready for installation onto an emulator or attached
+ development device. You cannot distribute an application that is signed with a debug key.
+ When you build in release mode, the .apk file is <em>unsigned</em>, so you
+ must manually sign it with your own private key, using Keytool and Jarsigner.</p>
+
+ <p>It's important that you read and understand <a href=
+ "{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a>, particularly once
+ you're ready to release your application and share it with end-users. That document describes the
+ procedure for generating a private key and then using it to sign your .apk file. If you're just
+ getting started, however, you can quickly run your applications on an emulator or your own
+ development device by building in debug mode.</p>
+
+ <p>If you don't have Ant, you can obtain it from the <a href="http://ant.apache.org/">Apache Ant
+ home page</a>. Install it and make sure it is in your executable PATH. Before calling Ant, you
+ need to declare the JAVA_HOME environment variable to specify the path to where the JDK is
+ installed.</p>
+
+ <p class="note"><strong>Note:</strong> When installing JDK on Windows, the default is to install
+ in the "Program Files" directory. This location will cause <code>ant</code> to fail, because of
+ the space. To fix the problem, you can specify the JAVA_HOME variable like this:
+ <pre>set JAVA_HOME=c:\Progra~1\Java\<jdkdir></pre>
+
+ <p>The easiest solution, however, is to install JDK in a non-space directory, for example:</p>
+
+ <pre>c:\java\jdk1.6.0_02</pre>
+
+ <h2 id="DebugMode">Building in Debug Mode</h2>
+
+ <p>For immediate application testing and debugging, you can build your application in debug mode
+ and immediately install it on an emulator. In debug mode, the build tools automatically sign your
+ application with a debug key and optimize the package with {@code zipalign}.</p>
+
+ <p>To build in debug mode:</p>
+
+ <ol>
+ <li>Open a command-line and navigate to the root of your project directory.</li>
+ <li>Use Ant to compile your project in debug mode:
+ <pre>
+ant debug
+</pre>
+
+ <p>This creates your debug <code>.apk</code> file inside the project <code>bin/</code> directory, named
+ <code><your_project_name>-debug.apk</code>. The file is already signed with
+ the debug key and has been aligned with
+ <a href="{@docRoot}tools/help/zipalign.html"><code>zipalign</code></a>.
+ </p>
+ </li>
+ </ol>
+
+ <p>Each time you change a source file or resource, you must run Ant again in order to package up
+ the latest version of the application.</p>
+
+ <p>To install and run your application on an emulator, see the following section about <a href=
+ "#RunningOnEmulator">Running on the Emulator</a>.</p>
+
+ <h2 id="ReleaseMode">Building in Release Mode</h2>
+
+ <p>When you're ready to release and distribute your application to end-users, you must build your
+ application in release mode. Once you have built in release mode, it's a good idea to perform
+ additional testing and debugging with the final .apk.</p>
+
+ <p>Before you start building your application in release mode, be aware that you must sign the
+ resulting application package with your private key, and should then align it using the {@code
+ zipalign} tool. There are two approaches to building in release mode: build an unsigned package
+ in release mode and then manually sign and align the package, or allow the build script to sign
+ and align the package for you.</p>
+
+ <h3 id="ManualReleaseMode">Build unsigned</h3>
+
+ <p>If you build your application <em>unsigned</em>, then you will need to manually sign and align
+ the package.</p>
+
+ <p>To build an <em>unsigned</em> .apk in release mode:</p>
+
+ <ol>
+ <li>Open a command-line and navigate to the root of your project directory.</li>
+
+ <li>Use Ant to compile your project in release mode:
+ <pre>
+ant release
+</pre>
+ </li>
+ </ol>
+
+ <p>This creates your Android application .apk file inside the project <code>bin/</code>
+ directory, named <code><em><your_project_name></em>-unsigned.apk</code>.</p>
+
+ <p class="note"><strong>Note:</strong> The .apk file is <em>unsigned</em> at this point and can't
+ be installed until signed with your private key.</p>
+
+ <p>Once you have created the unsigned .apk, your next step is to sign the .apk with your private
+ key and then align it with {@code zipalign}. To complete this procedure, read <a href=
+ "{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a>.</p>
+
+ <p>When your <code>.apk</code> has been signed and aligned, it's ready to be distributed to end-users.
+ You should test the final build on different devices or AVDs to ensure that it
+ runs properly on different platforms.</p>
+
+ <h3 id="AutoReleaseMode">Build signed and aligned</h3>
+
+ <p>If you would like, you can configure the Android build script to automatically sign and align
+ your application package. To do so, you must provide the path to your keystore and the name of
+ your key alias in your project's {@code ant.properties} file. With this information provided,
+ the build script will prompt you for your keystore and alias password when you build in release
+ mode and produce your final application package, which will be ready for distribution.</p>
+
+ <p class="caution"><strong>Caution:</strong> Due to the way Ant handles input, the password that
+ you enter during the build process <strong>will be visible</strong>. If you are concerned about
+ your keystore and alias password being visible on screen, then you may prefer to perform the
+ application signing manually, via Jarsigner (or a similar tool). To instead perform the signing
+ procedure manually, <a href="#ManualReleaseMode">build unsigned</a> and then continue with
+ <a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a>.</p>
+
+ <p>To specify your keystore and alias, open the project {@code ant.properties} file (found in
+ the root of the project directory) and add entries for {@code key.store} and {@code key.alias}.
+ For example:</p>
+ <pre>
+key.store=path/to/my.keystore
+key.alias=mykeystore
+</pre>
+
+ <p>Save your changes. Now you can build a <em>signed</em> .apk in release mode:</p>
+
+ <ol>
+ <li>Open a command-line and navigate to the root of your project directory.</li>
+
+ <li>Use Ant to compile your project in release mode:
+ <pre>
+ant release
+</pre>
+ </li>
+
+ <li>When prompted, enter you keystore and alias passwords.
+
+ <p class="caution"><strong>Caution:</strong> As described above, your password will be
+ visible on the screen.</p>
+ </li>
+ </ol>
+
+ <p>This creates your Android application .apk file inside the project <code>bin/</code>
+ directory, named <code><em><your_project_name></em>-release.apk</code>. This .apk file has
+ been signed with the private key specified in {@code ant.properties} and aligned with {@code
+ zipalign}. It's ready for installation and distribution.</p>
+
+ <h3 id="OnceBuilt">Once built and signed in release mode</h3>
+
+ <p>Once you have signed your application with a private key, you can install and run it on an
+ <a href="#RunningOnEmulator">emulator</a> or <a href="#RunningOnDevice">device</a>. You can
+ also try installing it onto a device from a web server. Simply upload the signed .apk to a web
+ site, then load the .apk URL in your Android web browser to download the application and begin
+ installation. (On your device, be sure you have enabled
+ <em>Settings > Applications > Unknown sources</em>.)</p>
+
+ <h2 id="RunningOnEmulator">Running on the Emulator</h2>
+
+ <p>Before you can run your application on the Android Emulator, you must <a href=
+ "{@docRoot}tools/devices/managing-avds.html">create an AVD</a>.</p>
+
+ <p>To run your application:</p>
+
+ <ol>
+ <li>
+ <strong>Open the AVD Manager and launch a virtual device</strong>
+
+ <p>From your SDK's <code>platform-tools/</code> directory, execute the {@code android} tool
+with the <code>avd</code> options:</p>
+ <pre>
+android avd
+</pre>
+
+ <p>In the <em>Virtual Devices</em> view, select an AVD and click <strong>Start</strong>.</p>
+ </li>
+
+ <li>
+ <strong>Install your application</strong>
+
+ <p>From your SDK's <code>tools/</code> directory, install the {@code .apk} on the
+ emulator:</p>
+ <pre>
+adb install <em><path_to_your_bin></em>.apk
+</pre>
+
+ <p>Your .apk file (signed with either a release or debug key) is in your project {@code bin/}
+ directory after you build your application.</p>
+
+ <p>If there is more than one emulator running, you must specify the emulator upon which to
+ install the application, by its serial number, with the <code>-s</code> option. For
+ example:</p>
+ <pre>
+adb -s emulator-5554 install <em>path/to/your/app</em>.apk
+</pre>
+
+ <p>To see a list of available device serial numbers, execute {@code adb devices}.</p>
+ </li>
+ </ol>
+
+ <p>If you don't see your application on the emulator, try closing the emulator and launching the
+ virtual device again from the AVD Manager. Sometimes when you install an application for the
+ first time, it won't show up in the application launcher or be accessible by other applications.
+ This is because the package manager usually examines manifests completely only on emulator
+ startup.</p>
+
+ <p>Be certain to create multiple AVDs upon which to test your application. You should have one
+ AVD for each platform and screen type with which your application is compatible. For instance, if
+ your application compiles against the Android 1.5 (API Level 3) platform, you should create an
+ AVD for each platform equal to and greater than 1.5 and an AVD for each <a href=
+ "{@docRoot}guide/practices/screens_support.html">screen type</a> you support, then test your
+ application on each one.</p>
+
+ <p class="note"><strong>Tip:</strong> If you have <em>only one</em> emulator running, you can
+ build your application and install it on the emulator in one simple step. Navigate to the root of
+ your project directory and use Ant to compile the project with <em>install mode</em>: <code>ant
+ install</code>. This will build your application, sign it with the debug key, and install it on
+ the currently running emulator.</p>
+
+ <h2 id="RunningOnDevice">Running on a Device</h2>
+
+ <p>Before you can run your application on a device, you must perform some basic setup for your
+ device:</p>
+
+ <ul>
+ <li>Enable USB Debugging on your device. You can find the setting on most Android devices by
+ going to <strong>Settings > Applications > Development > USB debugging</strong>.</li>
+
+ <li>Ensure that your development computer can detect your device when connected via USB</li>
+ </ul>
+
+ <p>Read <a href="{@docRoot}tools/device.html#setting-up">Setting up a Device for
+ Development</a> for more information.</p>
+
+ <p>Once your device is set up and connected via USB, navigate to your SDK's <code>platform-tools/</code>
+ directory and install the <code>.apk</code> on the device:</p>
+ <pre>
+adb -d install <em>path/to/your/app</em>.apk
+</pre>
+
+ <p>The {@code -d} flag specifies that you want to use the attached device (in case you also have
+ an emulator running).</p>
+
+ <p>For more information on the tools used above, please see the following documents:</p>
+
+ <ul>
+ <li><a href="{@docRoot}tools/help/android.html">android Tool</a></li>
+
+ <li><a href="{@docRoot}tools/devices/emulator.html">Android Emulator</a></li>
+
+ <li><a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a> (ADB)</li>
+ </ul>
+
+ <h2 id="Signing">Application Signing</h2>
+
+ <p>As you begin developing Android applications, understand that all Android applications must be
+ digitally signed before the system will install them on an emulator or device. There are two ways
+ to do this: with a <em>debug key</em> (for immediate testing on an emulator or development
+ device) or with a <em>private key</em> (for application distribution).</p>
+
+ <p>The Android build tools help you get started by automatically signing your .apk files with a
+ debug key at build time. This means that you can compile your application and install it on the
+ emulator without having to generate your own private key. However, please note that if you intend
+ to publish your application, you <strong>must</strong> sign the application with your own private
+ key, rather than the debug key generated by the SDK tools.</p>
+
+ <p>The ADT plugin helps you get started quickly by signing your .apk files with a debug key,
+ prior to installing them on an emulator or development device. This means that you can quickly
+ run your application from Eclipse without having to generate your own private key. No specific
+ action on your part is needed, provided ADT has access to Keytool. However, please note that if
+ you intend to publish your application, you <strong>must</strong> sign the application with your
+ own private key, rather than the debug key generated by the SDK tools.</p>
+
+ <p>Please read <a href="{@docRoot}tools/publishing/app-signing.html">Signing Your
+ Applications</a>, which provides a thorough guide to application signing on Android and what it
+ means to you as an Android application developer. The document also includes a guide to exporting
+ and signing your application with the ADT's Export Wizard.</p>
+
+ <h2 id="AntReference">Ant Command Reference</h2>
+ <dt><code>ant clean</code></dt>
+ <dd>Cleans the project. If you include the <code>all</code> target before <code>clean</code>
+(<code>ant all clean</code>), other projects are also cleaned. For instance if you clean a
+test project, the tested project is also cleaned.</dd>
+
+ <dt><code>ant debug</code></dt>
+ <dd>Builds a debug package. Works on application, library, and test projects and compiles
+ dependencies as needed.</dd>
+
+ <dt id="emma"><code>ant emma debug</code></dt>
+ <dd>Builds a test project while building the tested project with instrumentation turned on.
+ This is used to run tests with code coverage enabled.</dd>
+
+ <dt><code>ant release</code></dt>
+ <dd>Builds a release package.</dd>
+
+ <dt><code>ant instrument</code>
+ </dt>
+ <dd>Builds an instrumented debug package. This is generally called automatically when building a
+ test project with code coverage enabled (with the <code>emma</code>
+ target)</dd>
+
+ <dt><code>ant <build_target> install</code></dt>
+ <dd>Builds and installs a package. Using <code>install</code> by itself fails.</dd>
+
+ <dt><code>ant installd</code></dt>
+ <dd>Installs an already compiled debug package. This fails if the <code>.apk</code> is not
+ already built.</dd>
+
+ <dt><code>ant installr</code></dt>
+ <dd>Installs an already compiled release package. This fails if the <code>.apk</code> is not
+ already built.</dd>
+
+ <dt><code>ant installt</code></dt>
+ <dd>Installs an already compiled test package. Also installs the <code>.apk</code> of the
+ tested application. This fails if the <code>.apk</code> is not already built.</dd>
+
+ <dt><code>ant installi</code></dt>
+ <dd>Installs an already compiled instrumented package. This is generally not used manually as
+ it's called when installing a test package. This fails if the <code>.apk</code> is not already
+ built.</dd>
+
+ <dt><code>ant test</code></dt>
+ <dd>Runs the tests (for test projects). The tested and test <code>.apk</code> files must be
+ previously installed.</dd>
+
+ <dt><code>ant debug installt test</code></dt>
+ <dd>Builds a test project and the tested project, installs both <code>.apk</code> files, and
+ runs the tests.</dd>
+
+ <dt><code>ant emma debug install test</code></dt>
+ <dd>Builds a test project and the tested project, installs both <code>.apk</code> files, and
+ runs the tests with code coverage enabled.</dd>
+
diff --git a/docs/html/tools/building/building-eclipse.jd b/docs/html/tools/building/building-eclipse.jd
new file mode 100644
index 0000000..c73fe97
--- /dev/null
+++ b/docs/html/tools/building/building-eclipse.jd
@@ -0,0 +1,165 @@
+page.title=Building and Running from Eclipse with ADT
+parent.title=Building and Running
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#RunningOnEmulatorEclipse">Running on an Emulator</a></li>
+
+ <li><a href="#RunningOnDeviceEclipse">Running on a Device</a></li>
+
+ <li><a href="#RunConfig">Creating a Run Configuration</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>Eclipse and ADT provide an environment where most of the details of the build process are
+ hidden from you. By default, the build process constantly runs in the background as you make
+ changes to your project.</p>
+
+ <p>When Eclipse automatically builds your application, it enables debugging and signs the
+ <code>.apk</code> with a debug key, by default. When you run the application,
+ Eclipse invokes ADB and installs your application to a device or emulator, so you do not have to
+ manually perform these tasks. Since most of the build process is taken care of by Eclipse, the
+ following topics show you how to run an application, which will automatically build your
+ application as well.</p>
+
+ <p>To distribute your application, however, you must build your application in release mode and sign the
+ <code>.apk</code> file with your own private key.</p>
+
+ <p>This document shows you how to run your application on an emulator or a real device
+ from Eclipse—all of which is done using the debug version of your application.
+ For more information about how to sign your application with a private key for release, see <a href=
+ "{@docRoot}tools/publishing/app-signing.html#ExportWizard">Signing Your Applications</a></p>
+
+ <h2 id="RunningOnEmulatorEclipse">Running on the emulator</h2>
+
+ <p>Before you can run your application on the Android Emulator, you must <a href=
+ "{@docRoot}tools/devices/managing-avds.html">create an AVD</a>.</p>
+
+ <p>To run (or debug) your application, select <strong>Run</strong> > <strong>Run</strong> (or
+ <strong>Run</strong> > <strong>Debug</strong>) from the Eclipse menu bar. The ADT plugin will
+ automatically create a default run configuration for the project. Eclipse will then perform the
+ following:</p>
+
+ <ol>
+ <li>Compile the project (if there have been changes since the last build).</li>
+
+ <li>Create a default run configuration (if one does not already exist for the project).</li>
+
+ <li>Install and start the application on an emulator (or device), based on the Deployment
+ Target defined by the run configuration.
+
+ <p>By default, Android run configurations use an "automatic target" mode for selecting a
+ device target. For information on how automatic target mode selects a deployment target, see
+ <a href="#AutoAndManualTargetModes">Automatic and manual target modes</a> below.</p>
+ </li>
+ </ol>
+
+ <p>If you run the application with the Debug option, the application will start in the "Waiting For Debugger" mode. Once the debugger
+ is attached, Eclipse opens the Debug perspective and starts the application's main activity. Otherwise, if you run the
+ application with the normal Run option, Eclipse installs the application on the device and launches the main activity.</p>
+
+ <p>To set or change the run configuration used for your project, use the run configuration
+ manager. See the section below about <a href="#RunConfig">Creating a Run Configuration</a> for more information.</p>
+
+ <p>Be certain to create multiple AVDs upon which to test your application. You should have one
+ AVD for each platform and screen type with which your application is compatible. For instance, if
+ your application compiles against the Android 1.5 (API Level 3) platform, you should create an
+ AVD for each platform equal to and greater than 1.5 and an AVD for each <a href=
+ "{@docRoot}guide/practices/screens_support.html">screen type</a> you support, then test your
+ application on each one.</p>
+
+ <h2 id="RunningOnDeviceEclipse">Running on a device</h2>
+
+ <p>Before you can run your application on a device, you must perform some basic setup for your
+ device:</p>
+
+ <ul>
+ <li>Ensure that your application is debuggable by setting the
+ <code>android:debuggable</code> attribute of the <code><application></code>
+ element to <code>true</code>. As of ADT 8.0, this is done by default when you build in debug mode.</li>
+
+ <li>Enable USB Debugging on your device. You can find the setting on most Android devices by
+ going to <strong>Settings > Applications > Development > USB debugging</strong>.</li>
+
+ <li>Ensure that your development computer can detect your device when connected via USB</li>
+ </ul>
+
+ <p>Read <a href="{@docRoot}tools/device.html">Using Hardware Devices</a>
+ for more information.</p>
+
+ <p>Once set up and your device is connected via USB, install your application on the device by
+ selecting <strong>Run</strong> > <strong>Run</strong> (or <strong>Run</strong> >
+ <strong>Debug</strong>) from the Eclipse menu bar.</p>
+
+ <h2 id="RunConfig">Creating a Run Configuration</h2>
+
+ <p>The run configuration specifies the project to run, the Activity to start, the emulator or
+ connected device to use, and so on. When you first run a project as an <em>Android
+ Application</em>, ADT will automatically create a run configuration. The default run
+ configuration will launch the default project Activity and use automatic target mode for device
+ selection (with no preferred AVD). If the default settings don't suit your project, you can
+ customize the run configuration or even create a new one.</p>
+
+ <p>To create or modify a run configuration, refer to the Eclipse documentation on how to create Run configurations.
+ The following steps highlight the important things you need to do for an Android project:</p>
+
+ <ol>
+ <li>Open the run configuration manager from the Run Menu.</li>
+
+ <li>Expand the <strong>Android Application</strong> item and create a new configuration or open
+ an existing one.
+ </li>
+
+ <li>With the Run Configuration selected, adjust your desired run configuration settings:
+ <ul>
+ <li>In the Android tab, specify the Project and Activity to launch.
+ </li>
+ <li><p>In the Target tab, consider whether you'd like to use Manual or Automatic mode when
+ selecting an AVD to run your application. See the following section on <a href=
+ "#AutoAndManualTargetModes">Automatic and manual target modes</a>).</p>
+
+ <p>You can specify any emulator options to the Additional Emulator Command Line Options
+ field. For example, you could add <code>-scale 96dpi</code> to scale the AVD's screen to an
+ accurate size, based on the dpi of your computer monitor. For a full list of emulator
+ options, see the <a href="{@docRoot}tools/help/emulator.html">Android
+ Emulator</a> document.</p>
+ </li>
+ </ul>
+ </li>
+ </ol>
+
+ <h4 id="AutoAndManualTargetModes">Automatic and manual target modes</h4>
+
+ <p>By default, a run configuration uses the <strong>automatic</strong> target mode in order to
+ select an AVD. In this mode, ADT will select an AVD for the application in the following
+ manner:</p>
+
+ <ol>
+ <li>If there's a device or emulator already running and its AVD configuration meets the
+ requirements of the application's build target, the application is installed and run upon
+ it.</li>
+
+ <li>If there's more than one device or emulator running, each of which meets the requirements
+ of the build target, a "device chooser" is shown to let you select which device to use.</li>
+
+ <li>If there are no devices or emulators running that meet the requirements of the build
+ target, ADT looks at the available AVDs. If there is an AVD that matches the build target of the project,
+ ADT chooses that AVD. If the AVD versions are newer than the build target of the project, ADT chooses
+ the oldest possible version of an AVD that meets the project's build target requirement.</li>
+
+ <li>If there are no suitable AVDs, the application is not installed a console error warning tells
+ you that there is no existing AVD that meets the build target requirements.</li>
+ </ol>
+
+ <p>However, if a "preferred AVD" is selected in the run configuration, then the application will
+ <em>always</em> be deployed to that AVD. If it's not already running, then a new emulator will be
+ launched.</p>
+
+ <p>If your run configuration uses <strong>manual</strong> mode, then the "device chooser" is
+ presented every time that your application is run, so that you can select which AVD to use.</p>
\ No newline at end of file
diff --git a/docs/html/tools/building/index.jd b/docs/html/tools/building/index.jd
new file mode 100644
index 0000000..c64942f
--- /dev/null
+++ b/docs/html/tools/building/index.jd
@@ -0,0 +1,81 @@
+page.title=Building and Running
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#detailed-build">A Detailed Look at the Build Process</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>During the build process, your Android projects are compiled and packaged into an .apk file,
+ the container for your application binary. It contains all of the information necessary to run
+ your application on a device or emulator, such as compiled <code>.dex</code> files (<code>.class</code> files
+ converted to Dalvik byte code), a binary version of the <code>AndroidManifest.xml</code> file, compiled
+ resources (<code>resources.arsc</code>) and uncompiled resource files for your application.</p>
+
+ <p>If you are developing in Eclipse, the ADT plugin incrementally builds your project as you
+ make changes to the source code. Eclipse outputs an <code>.apk</code> file automatically to the bin folder of
+ the project, so you do not have to do anything extra to generate the <code>.apk</code>.</p>
+
+ <p>If you are developing in a non-Eclipse environment, you can build your project with the
+ generated <code>build.xml</code> Ant file that is in the project directory. The Ant file calls targets that
+ automatically call the build tools for you.</p>
+
+ <p>To run an application on an emulator or device, the application must be signed using debug or
+ release mode. You typically want to sign your application in debug mode when you develop and test
+ your application, because the build tools use a debug key with a known password so you do not have
+ to enter it every time you build. When you are ready to release the application to Google
+ Play, you must sign the application in release mode, using your own private key.</p>
+
+ <p>Fortunately, Eclipse or your Ant build script signs the application for you in debug mode
+ when you build your application. You can also easily setup Eclipse or your Ant build to sign your
+ application in release mode as well. For more information on signing applications, see <a href=
+ "{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a>.</p>
+
+ <p>The following diagram depicts the components involved in building and running an application:</p>
+
+ <img src="{@docRoot}images/build-simplified.png" />
+
+ <h2 id="detailed-build">A Detailed Look at the Build Process</h2>
+
+ <p>The build process involves many tools and processes that generate intermediate files on the
+ way to producing an <code>.apk</code>. If you are developing in Eclipse, the complete build process is
+ automatically done periodically as you develop and save your code changes. If you are using other
+ IDEs, this build process is done every time you run the generated Ant build script for your
+ project. It is useful, however, to understand what is happening under the hood since much of the
+ tools and processes are masked from you. The following diagram depicts the different tools and
+ processes that are involved in a build:</p>
+
+ <img src="{@docRoot}images/build.png" />
+
+ <p>The general process for a typical build is outlined below:</p>
+
+ <ul>
+
+ <li>The Android Asset Packaging Tool (aapt) takes your application resource files, such as the
+ <code>AndroidManifest.xml</code> file and the XML files for your Activities, and compiles them. An <code>R.java</code> is
+ also produced so you can reference your resources from your Java code.</li>
+
+ <li>The aidl tool converts any <code>.aidl</code> interfaces that you have into Java interfaces.</li>
+
+ <li>All of your Java code, including the <code>R.java</code> and <code>.aidl</code> files, are compiled by the Java
+ compiler and .class files are output.</li>
+
+ <li>The dex tool converts the .class files to Dalvik byte code. Any 3rd party libraries and
+ .class files that you have included in your project are also converted into <code>.dex</code> files so that
+ they can be packaged into the final <code>.apk</code> file.</li>
+
+ <li>All non-compiled resources (such as images), compiled resources, and the .dex files are
+ sent to the apkbuilder tool to be packaged into an <code>.apk</code> file.</li>
+
+ <li>Once the <code>.apk</code> is built, it must be signed with either a debug or release key before it can
+ be installed to a device.</li>
+
+ <li>Finally, if the application is being signed in release mode, you must align the <code>.apk</code> with
+ the zipalign tool. Aligning the final <code>.apk</code> decreases memory usage when the application is
+ running on a device.</li>
+ </ul>
+
diff --git a/docs/html/tools/debug-tasks.html b/docs/html/tools/debug-tasks.html
new file mode 100644
index 0000000..2a5bc51
--- /dev/null
+++ b/docs/html/tools/debug-tasks.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/debugging/index.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/debugging/index.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/debugging/ddms.jd b/docs/html/tools/debugging/ddms.jd
new file mode 100644
index 0000000..3d6324b
--- /dev/null
+++ b/docs/html/tools/debugging/ddms.jd
@@ -0,0 +1,357 @@
+page.title=Using DDMS
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#running">Running DDMS</a></li>
+ <li><a href="#how-ddms-works">How DDMS Interacts with a Debugger</a></li>
+
+ <li><a href="#using-ddms">Using DDMS</a>
+ <ol>
+ <li><a href="#heap">Viewing heap usage for a process</a></li>
+ <li><a href="#alloc">Tracking memory allocation of objects</a></li>
+ <li><a href="#emulator">Working with an emulator or device's file system</a></li>
+ <li><a href="#thread">Examining thread information</a></li>
+ <li><a href="#profiling">Starting method profiling</a></li>
+ <li><a href="#network">Using the Network Traffic tool</a></li>
+ <li><a href="#logcat">Using LogCat</a></li>
+ <li><a href="#ops-location">Emulating phone operations and location</a></li>
+ </ol>
+
+ </li>
+ </ol>
+ </div>
+ </div>
+
+ <p>Android ships with a debugging tool called the Dalvik Debug Monitor Server (DDMS), which
+ provides port-forwarding services, screen capture on the device, thread and heap information on
+ the device, logcat, process, and radio state information, incoming call and SMS spoofing,
+ location data spoofing, and more. This page provides a modest discussion of DDMS features; it is
+ not an exhaustive exploration of all the features and capabilities.</p>
+
+ <h2 id="running">Running DDMS</h2>
+ <p>DDMS is integrated into Eclipse and is also shipped in the <code>tools/</code> directory of the
+ SDK. DDMS works with both the emulator and a connected device. If both are connected and running simultaneously,
+ DDMS defaults to the emulator.</p>
+
+ <ul>
+ <li>From Eclipse: Click <strong>Window > Open Perspective > Other... > DDMS</strong>.</li>
+ <li>From the command line: Type <code>ddms</code> (or <code>./ddms</code> on Mac/Linux) from the <code>tools/</code>
+ directory. </li>
+ </ul>
+
+
+ <h2 id="how-ddms-works">How DDMS Interacts with a Debugger</h2>
+
+ <p>On Android, every application runs in its own process, each of which runs in its own virtual machine
+ (VM). Each VM exposes a unique port that a debugger can attach to.</p>
+
+ <p>When DDMS starts, it connects to <a href="{@docRoot}tools/help/adb.html">adb</a>.
+ When a device is connected, a VM monitoring service is created between
+ <code>adb</code> and DDMS, which notifies DDMS when a VM on the device is started or terminated. Once a VM
+ is running, DDMS retrieves the the VM's process ID (pid), via <code>adb</code>, and opens a connection to the
+ VM's debugger, through the adb daemon (adbd) on the device. DDMS can now talk to the VM using a
+ custom wire protocol.</p>
+
+ <p>DDMS assigns a debugging port to each VM on the device. Typically,
+ DDMS assigns port 8600 for the first debuggable VM, the next on 8601, and so on. When a debugger
+ connects to one of these ports, all traffic is forwarded to the debugger from the associated
+ VM. You can only attach a single debugger to a single port, but DDMS can handle multiple, attached
+ debuggers.</p>
+
+ <p>By default, DDMS also listens on another debugging port, the DDMS "base port" (8700, by default).
+ The base port is a port forwarder, which can accept VM traffic from any debugging port and forward
+ it to the debugger on port 8700. This allows you to attach one debugger to port 8700, and debug
+ all the VMs on a device. The traffic that is forwarded is determined by the currently selected process
+ in the DDMS Devices view.</p>
+
+ <p>The following screenshot shows a typical DDMS screen in Eclipse. If you are starting DDMS from
+ the command line, the screen is slightly different, but much of the functionality is identical.
+ Notice that the highlighted process, <code>com.android.email</code>, that is running in the emulator
+ has the debugging port 8700 assigned to it as well as 8606. This signifies that DDMS is currently
+ forwarding port 8606 to the static debugging port of 8700.</p>
+
+ <img src="{@docRoot}images/debug-ddms.png"
+ width="1024" />
+ <p class="img-caption"><strong>Figure 1.</strong>
+ Screenshot of DDMS</p>
+
+ <p>If you are not using Eclipse and ADT, read <a href=
+ "{@docRoot}tools/debugging/debugging-projects-cmdline.html#debuggingPort">Configuring
+ your IDE to attach to the debugging port</a>, for more information on attaching your
+ debugger.</p>
+
+ <p class="note"><strong>Tip:</strong> You can set a number of DDMS preferences in
+ <strong>File</strong> > <strong>Preferences</strong>. Preferences are saved to
+ <code>$HOME/.android/ddms.cfg</code>.</p>
+
+ <p class="warning"><strong>Known debugging issues with Dalvik</strong><br />
+ Debugging an application in the Dalvik VM should work the same as it does in other VMs. However,
+ when single-stepping out of synchronized code, the "current line" cursor may jump to the last
+ line in the method for one step.</p>
+
+ <h2 id="using-ddms">Using DDMS</h2>
+ The following sections describe how to use DDMS and the various tabs and panes that are part of the
+ DDMS GUI. The Eclipse version and the command line version have minor UI differences, but the
+ same functionality. For information on running DDMS, see the previous section in this document,
+ <a href="#running">Running DDMS</a>.
+
+
+ <h3 id="heap">Viewing heap usage for a process</h3>
+
+ <p>DDMS allows you to view how much heap memory a process is using. This information is useful in
+ tracking heap usage at a certain point of time during the execution of your application.</p>
+ <p>To view heap usage for a process:</p>
+ <ol>
+ <li>In the Devices tab, select the process that you want to see the heap information for.</li>
+
+ <li>Click the <strong>Update Heap</strong> button to enable heap information for the
+ process.</li>
+
+ <li>In the Heap tab, click <strong>Cause GC</strong> to invoke garbage collection, which
+ enables the collection of heap data. When the operation completes, you will see a group of
+ object types and the memory that has been allocated for each type. You can click <strong>Cause
+ GC</strong> again to refresh the data.</li>
+
+ <li>Click on an object type in the list to see a bar graph that shows the number of objects
+ allocated for a particular memory size in bytes.</li>
+ </ol>
+
+ <h3 id="alloc">Tracking memory allocation of objects</h3>
+
+ <p>DDMS provides a feature to track objects that are being allocated to memory and to see which
+ classes and threads are allocating the objects. This allows you to track, in real time, where
+ objects are being allocated when you perform certain actions in your application. This
+ information is valuable for assessing memory usage that can affect application performance.
+ </p>
+
+ <p>To track memory allocation of objects:</p>
+ <ol>
+ <li>In the Devices tab, select the process that you want to enable allocation tracking
+ for.</li>
+
+ <li>In the Allocation Tracker tab, click the <strong>Start Tracking</strong> button to begin
+ allocation tracking. At this point, anything you do in your application will be tracked.</li>
+
+ <li>Click <strong>Get Allocations</strong> to see a list of objects that have been allocated
+ since you clicked on the <strong>Start Tracking</strong> button. You can click on <strong>Get
+ Allocations</strong> again to append to the list new objects that that have been
+ allocated.</li>
+
+ <li>To stop tracking or to clear the data and start over, click the <strong>Stop Tracking
+ button</strong>.</li>
+
+ <li>Click on a specific row in the list to see more detailed information such as the method and
+ line number of the code that allocated the object.</li>
+ </ol>
+
+ <h3 id="emulator">Working with an emulator or device's file system</h3>
+
+ <p>DDMS provides a File Explorer tab that allows you to view, copy, and delete files on the
+ device. This feature is useful in examining files that are created by your application or if you
+ want to transfer files to and from the device.</p>
+
+ <p>To work with an emulator or device's file system:</p>
+ <ol>
+ <li>In the Devices tab, select the emulator that you want to view the file system for.</li>
+
+ <li>To copy a file from the device, locate the file in the File Explorer and click the
+ <strong>Pull file</strong> button.</li>
+
+ <li>To copy a file to the device, click the <strong>Push file</strong> button on the File
+ Explorer tab.</li>
+ </ol>
+
+ <!-- Need to elaborate more on where things are stored in the file system,
+ databases, apks, user info, files that are important to look at -->
+
+ <h3 id="thread">Examining thread information</h3>
+
+ <p>The Threads tab in DDMS shows you the currently running threads for a selected process.</p>
+
+ <ol>
+ <li>In the Devices tab, select the process that you want to examine the threads for.</li>
+
+ <li>Click the <strong>Update Threads</strong> button.</li>
+
+ <li>In the Threads tab, you can view the thread information for the selected process.</li>
+ </ol>
+
+ <h3 id="profiling">Starting method profiling</h3>
+
+ <p>Method profiling is a means to track certain metrics about a method, such as number of calls,
+ execution time, and time spent executing the method. If you want more granular control over
+ where profiling data is collected, use the {@link android.os.Debug#startMethodTracing()} and
+ {@link android.os.Debug#stopMethodTracing()} methods. For more information about generating trace logs, see
+ <a href="debugging-tracing.html">Profiling and Debugging UIs</a>.</p>
+
+ <p>Before you start method profiling in DDMS, be aware of the following restrictions:</p>
+ <ul>
+ <li>Android 1.5 devices are not supported.</li>
+ <li>Android 2.1 and earlier devices must
+ have an SD card present and your application must have permission to write to the SD card.
+ <li>Android 2.2 and later devices do not need an SD card. The trace log files are
+ streamed directly to your development machine.</li>
+ </ul>
+
+ <p>To start method profiling:</p>
+ <ol>
+ <li>On the Devices tab, select the process that you want to enable method profiling for.</li>
+
+ <li>Click the <strong>Start Method Profiling</strong> button.</li>
+
+ <li>Interact with your application to start the methods that you want to profile.</li>
+
+ <li>Click the <strong>Stop Method Profiling</strong> button. DDMS stops profiling your
+ application and opens <a href="{@docRoot}tools/debugging/debugging-ui.html">Traceview</a>
+ with the method profiling information that was collected
+ between the time you clicked on <strong>Start Method Profiling</strong> and <strong>Stop Method
+ Profiling</strong>.</li>
+ </ol>
+
+ <h3 id="network">Using the Network Traffic tool</h3>
+
+ <p>In Android 4.0, the DDMS (Dalvik Debug Monitor Server) includes a Detailed
+Network Usage tab that makes it possible to track when your application is
+making network requests. Using this tool, you can monitor how and when your app
+transfers data and optimize the underlying code appropriately. You can also
+distinguish between different traffic types by applying a “tag” to network
+sockets before use.</p>
+
+<p>These tags are shown in a stack area chart in DDMS, as shown in figure 2:</p>
+
+<img src="{@docRoot}images/developing/ddms-network.png" />
+<p class="img-caption"><strong>Figure 2.</strong> Network Usage tab.</p>
+
+<p>By monitoring the frequency of your data transfers, and the amount of data
+transferred during each connection, you can identify areas of your application
+that can be made more battery-efficient. Generally, you should look for
+short spikes that can be delayed, or that should cause a later transfer to be
+pre-empted. </p>
+
+<p>To better identify the cause of transfer spikes, the
+{@link android.net.TrafficStats} API allows you
+to tag the data transfers occurring within a thread using {@link
+android.net.TrafficStats#setThreadStatsTag setThreadStatsTag()}, followed
+by manually tagging (and untagging) individual sockets using {@link
+android.net.TrafficStats#tagSocket tagSocket()} and {@link
+android.net.TrafficStats#untagSocket untagSocket()}. For example:</p>
+
+<pre>TrafficStats.setThreadStatsTag(0xF00D);
+TrafficStats.tagSocket(outputSocket);
+// Transfer data using socket
+TrafficStats.untagSocket(outputSocket);</pre>
+
+<p>Alternatively, the Apache {@link org.apache.http.client.HttpClient} and
+{@link java.net.URLConnection} APIs included in the platform
+automatically tag sockets internally based on the active tag (as
+identified by
+{@link android.net.TrafficStats#getThreadStatsTag getThreadStatsTag()}).
+These APIs correctly tag/untag sockets when recycled through
+keep-alive pools. In the following example,
+{@link android.net.TrafficStats#setThreadStatsTag setThreadStatsTag()}
+sets the active tag to be {@code 0xF00D}.
+There can only be one active tag per thread.
+That is the value that will
+be returned by {@link android.net.TrafficStats#getThreadStatsTag getThreadStatsTag()}
+and thus used by {@link org.apache.http.client.HttpClient}
+ to tag sockets. The {@code finally} statement
+invokes
+{@link android.net.TrafficStats#clearThreadStatsTag clearThreadStatsTag()}
+to clear the tag.</p>
+
+<pre>TrafficStats.setThreadStatsTag(0xF00D);
+ try {
+ // Make network request using HttpClient.execute()
+ } finally {
+ TrafficStats.clearThreadStatsTag();
+}</pre>
+
+<p>Socket tagging is supported in Android 4.0, but real-time stats will only be
+displayed on devices running Android 4.0.3 or higher.</p>
+
+ <h3 id="logcat">Using LogCat</h3>
+
+ <p>LogCat is integrated into DDMS, and outputs the messages that you print out using the {@link android.util.Log}
+ class along with other system messages such as stack traces when exceptions are thrown. View the
+ <a href="{@docRoot}tools/debugging/debugging-log.html">Reading and
+ Writing Log Messages.</a> topic for more information on how to log messages to the LogCat.</p>
+
+ <p>When you have set up your logging, you can use the LogCat feature of DDMS to filter certain
+ messages with the following buttons:</p>
+
+ <ul>
+ <li>Verbose</li>
+
+ <li>Debug</li>
+
+ <li>Info</li>
+
+ <li>Warn</li>
+
+ <li>Error</li>
+ </ul>
+
+ <p>You can also setup your own custom filter to specify more details such as filtering messages
+ with the log tags or with the process id that generated the log message. The add filter,
+ edit filter, and delete filter buttons let you manage your custom filters.</p>
+
+ <h3 id="ops-location">Emulating phone operations and location</h3>
+ <p>The Emulator control tab lets you simulate a
+ phone's voice and data network status. This is useful when you want to test your application's
+ robustness in differing network environments.</p>
+
+ <h4>Changing network state, speed, and latency</h4>
+ <p>The Telephony Status section of the Emulator
+ controls tab lets you change different aspects of the phone's networks status, speed and latency.
+ The following options are available to you and are effective immediately after you set them:</p>
+
+ <ul>
+ <li>Voice - unregistered, home, roaming, searching, denied</li>
+
+ <li>Data - unregistered, home, roaming, searching, denied</li>
+
+ <li>Speed - Full, GSM, HSCSD, GPRS, EDGE, UMTS, HSDPA</li>
+
+ <li>Latency - GPRS, EDGE, UMTS</li>
+ </ul>
+
+ <h4>Spoofing calls or SMS text messages</h4>
+ <p>The Telephony Actions section of the Emulator
+ controls tab lets you spoof calls and messages. This is useful when you want to to test your
+ application's robustness in responding to incoming calls and messages that are sent to the phone.
+ The following actions are available to you:</p>
+
+ <ul>
+ <li>Voice - Enter a number in the <strong>Incoming number</strong> field and click
+ <strong>Call</strong> to send a simulated call to the emulator or phone. Click the
+ <strong>Hang up</strong> button to terminate the call.</li>
+
+ <li>SMS - Enter a number in the <strong>Incoming number</strong> field and a message in the
+ <strong>Message:</strong> field and click the <strong>Send</strong> button to send the
+ message.</li>
+ </ul>
+
+ <h4>Setting the location of the phone</h4>
+ <p>If your application depends on the location of the phone, you can have DDMS send your
+ device or AVD a mock location. This is useful if you
+ want to test different aspects of your application's location specific features without
+ physically moving. The following geolocation data types are available to you:</p>
+
+ <ul>
+ <li>Manual - set the location by manually specifying decimal or sexagesimal longitude and
+ latitude values.</li>
+
+ <li>GPX - GPS eXchange file</li>
+
+ <li>KML - Keyhole Markup Language file</li>
+ </ul>
+
+ For more information about providing mock location data, see
+ <a href="{@docRoot}guide/topics/location/strategies.html#MockData">Location Strategies</a>.
+
diff --git a/docs/html/tools/debugging/debugging-devtools.jd b/docs/html/tools/debugging/debugging-devtools.jd
new file mode 100644
index 0000000..3a05120
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-devtools.jd
@@ -0,0 +1,77 @@
+page.title=Using the Dev Tools App
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+<p>The Dev Tools application is installed by default on all system images included with the SDK,
+ so you can use it with the Android Emulator. With the Dev Tools application, you can enable a
+ number of settings on your device that will make it easier to test and debug your applications.</p>
+
+ <p> The Dev Tools application relies on a number of permissions that are not available for
+ third party applications. If you'd like to install the Dev Tools application
+ on a real development device, you'd have to build a system image for that device and sign
+ the Dev Tools application with the same key as used for the system image.</p>
+
+ <p>To get started, launch the Dev Tools application and select <strong>Development Settings</strong>. This will
+ open the Development Settings page with the following options (among others):</p>
+
+ <dl>
+ <dt><strong>Debug app</strong></dt>
+
+ <dd>
+ Lets you select the application to debug. You do not need to set this to attach a debugger,
+ but setting this value has two effects:
+
+ <ul>
+ <li>It will prevent Android from throwing an error if you pause on a breakpoint for a long
+ time while debugging.</li>
+
+ <li>It will enable you to select the <em>Wait for Debugger</em> option to pause application
+ startup until your debugger attaches (described next).</li>
+ </ul>
+ </dd>
+
+ <dt><strong>Wait for debugger</strong></dt>
+
+ <dd>Blocks the selected application from loading until a debugger attaches. This way you can
+ set a breakpoint in {@link android.app.Activity#onCreate onCreate()},
+ which is important to debug the startup process of an Activity.
+ When you change this option, any currently running instances of the selected application will
+ be killed. In order to check this box, you must have selected a debug application as described
+ in the previous option. You can do the same thing by adding {@link
+ android.os.Debug#waitForDebugger()} to your code.</dd>
+
+ <dt><strong>Show screen updates</strong></dt>
+
+ <dd>Flashes a momentary pink rectangle on any screen sections that are being redrawn. This is
+ very useful for discovering unnecessary screen drawing.</dd>
+
+ <dt><strong>Immediately destroy activities</strong></dt>
+
+ <dd>Tells the system to destroy an activity as soon as it is stopped (as if Android had to
+ reclaim memory). This is very useful for testing the {@link
+ android.app.Activity#onSaveInstanceState} / {@link
+ android.app.Activity#onCreate(android.os.Bundle)} code path, which would otherwise be difficult
+ to force. Choosing this option will probably reveal a number of problems in your application
+ due to not saving state. For more information about saving an activity's state, see the
+ <a href="{@docRoot}guide/components/activities.html#SavingActivityState">Activities</a>
+document.</dd>
+
+ <dt><strong>Show CPU usage</strong></dt>
+
+ <dd>Displays CPU meters at the top of the screen, showing how much the CPU is being used. The
+ top red bar shows overall CPU usage, and the green bar underneath it shows the CPU time spent
+ in compositing the screen.
+ <p class="note">Note: You cannot turn this feature off once it is on, without
+ restarting the emulator.</p></dd>
+
+ <dt><strong>Show background</strong></dt>
+
+ <dd>Displays a background pattern when no activity screens are visible. This typically does not
+ happen, but can happen during debugging.</dd>
+ </dl>
+
+ <p>These settings will be remembered across emulator restarts.</p>
+
+
+
diff --git a/docs/html/tools/debugging/debugging-log.jd b/docs/html/tools/debugging/debugging-log.jd
new file mode 100644
index 0000000..d2baaf26
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-log.jd
@@ -0,0 +1,308 @@
+page.title=Reading and Writing Logs
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#logClass">The Log class</a></li>
+
+ <li><a href="#startingLogcat">Starting LogCat</a></li>
+
+ <li><a href="#filteringOutput">Filtering Log Output</a></li>
+
+ <li><a href="#outputFormat">Controlling Log Output Format</a></li>
+
+ <li><a href="#alternativeBuffers">Viewing Alternative Log Output Buffers</a></li>
+
+ <li><a href="#viewingStd">Viewing stdout and stderr</a></li>
+
+ <li><a href="#DebuggingWebPages">Debugging Web Pages</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The Android logging system provides a mechanism for collecting and viewing system debug
+ output. Logcat dumps a log of system messages, which include things such as stack traces when the
+ emulator throws an error and messages that you have written from your application by using the
+ {@link android.util.Log} class. You can run LogCat through ADB or from DDMS, which allows you to
+ read the messages in real time.</p>
+
+ <h2 id="logClass">The <code>Log</code> class</h2>
+
+ <p>{@link android.util.Log} is a logging class that you can utilize in your code to print out
+ messages to the LogCat. Common logging methods include:</p>
+
+ <ul>
+ <li>{@link android.util.Log#v(String,String)} (verbose)</li>
+
+ <li>{@link android.util.Log#d(String,String)} (debug)</li>
+
+ <li>{@link android.util.Log#i(String,String)} (information)</li>
+
+ <li>{@link android.util.Log#w(String,String)} (warning)</li>
+
+ <li>{@link android.util.Log#e(String,String)} (error)</li>
+ </ul>For example:
+ <pre class="no-pretty-print">
+Log.i("MyActivity", "MyClass.getView() — get item number " + position);
+</pre>
+
+ <p>The LogCat will then output something like:</p>
+ <pre class="no-pretty-print">
+I/MyActivity( 1557): MyClass.getView() — get item number 1
+</pre>
+
+ <h2 id="startingLogcat">Using LogCat</h2>
+
+ <p>You can use LogCat from within DDMS or call it on an ADB shell. For more information on how to
+ use LogCat within DDMS, see <a href="{@docRoot}tools/debugging/ddms.html#logcat">Using
+ DDMS</a>. To run LogCat, through the ADB shell, the general usage is:</p>
+ <pre>
+[adb] logcat [<option>] ... [<filter-spec>] ...
+</pre>
+
+ <p>You can use the <code>logcat</code> command from your development computer or from a remote
+ adb shell in an emulator/device instance. To view log output in your development computer, you
+ use</p>
+ <pre>
+$ adb logcat
+</pre>
+
+ <p>and from a remote adb shell you use</p>
+ <pre>
+# logcat
+</pre>
+
+ <p>The following table describes the <code>logcat</code> command line options:</p>
+
+ <table>
+ <tr>
+ <td><code>-c</code></td>
+
+ <td>Clears (flushes) the entire log and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-d</code></td>
+
+ <td>Dumps the log to the screen and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-f <filename></code></td>
+
+ <td>Writes log message output to <code><filename></code>. The default is
+ <code>stdout</code>.</td>
+ </tr>
+
+ <tr>
+ <td><code>-g</code></td>
+ <td>Prints the size of the specified log buffer and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-n <count></code></td>
+
+ <td>Sets the maximum number of rotated logs to <code><count></code>. The default value
+ is 4. Requires the <code>-r</code> option.</td>
+ </tr>
+
+ <tr>
+ <td><code>-r <kbytes></code></td>
+
+ <td>Rotates the log file every <code><kbytes></code> of output. The default value is
+ 16. Requires the <code>-f</code> option.</td>
+ </tr>
+
+ <tr>
+ <td><code>-s</code></td>
+
+ <td>Sets the default filter spec to silent.</td>
+ </tr>
+
+ <tr>
+ <td><code>-v <format></code></td>
+
+ <td>Sets the output format for log messages. The default is <code>brief</code> format. For a
+ list of supported formats, see <a href="#outputFormat">Controlling Log Output
+ Format</a>.</td>
+ </tr>
+ </table>
+
+ <h3 id="filteringOutput">Filtering Log Output</h3>
+
+ <p>Every Android log message has a <em>tag</em> and a <em>priority</em> associated with it.</p>
+
+ <ul>
+ <li>The tag of a log message is a short string indicating the system component from which the
+ message originates (for example, "View" for the view system).</li>
+
+ <li>The priority is one of the following character values, ordered from lowest to highest
+ priority:</li>
+
+ <li style="list-style: none; display: inline">
+ <ul>
+ <li><code>V</code> — Verbose (lowest priority)</li>
+
+ <li><code>D</code> — Debug</li>
+
+ <li><code>I</code> — Info</li>
+
+ <li><code>W</code> — Warning</li>
+
+ <li><code>E</code> — Error</li>
+
+ <li><code>F</code> — Fatal</li>
+
+ <li><code>S</code> — Silent (highest priority, on which nothing is ever printed)</li>
+ </ul>
+ </li>
+ </ul>
+
+ <p>You can obtain a list of tags used in the system, together with priorities, by running
+ LogCat and observing the first two columns of each message, given as
+ <code><priority>/<tag></code>.</p>
+
+ <p>Here's an example of logcat output that shows that the message relates to priority level "I"
+ and tag "ActivityManager":</p>
+ <pre>
+I/ActivityManager( 585): Starting activity: Intent { action=android.intent.action...}
+</pre>
+
+ <p>To reduce the log output to a manageable level, you can restrict log output using <em>filter
+ expressions</em>. Filter expressions let you indicate to the system the tags-priority
+ combinations that you are interested in — the system suppresses other messages for the
+ specified tags.</p>
+
+ <p>A filter expression follows this format <code>tag:priority ...</code>, where <code>tag</code>
+ indicates the tag of interest and <code>priority</code> indicates the <em>minimum</em> level of
+ priority to report for that tag. Messages for that tag at or above the specified priority are
+ written to the log. You can supply any number of <code>tag:priority</code> specifications in a
+ single filter expression. The series of specifications is whitespace-delimited.</p>
+
+ <p>Here's an example of a filter expression that suppresses all log messages except those with
+ the tag "ActivityManager", at priority "Info" or above, and all log messages with tag "MyApp",
+ with priority "Debug" or above:</p>
+ <pre>
+adb logcat ActivityManager:I MyApp:D *:S
+</pre>
+
+ <p>The final element in the above expression, <code>*:S</code>, sets the priority level for all
+ tags to "silent", thus ensuring only log messages with "View" and "MyApp" are displayed. Using
+ <code>*:S</code> is an excellent way to ensure that log output is restricted to the filters that
+ you have explicitly specified — it lets your filters serve as a "whitelist" for log
+ output.</p>
+
+ <p>The following filter expression displays all log messages with priority level "warning" and higher, on all tags:</p>
+ <pre>
+adb logcat *:W
+</pre>
+
+ <p>If you're running LogCat from your development computer (versus running it on a
+ remote adb shell), you can also set a default filter expression by exporting a value for the
+ environment variable <code>ANDROID_LOG_TAGS</code>:</p>
+ <pre>
+export ANDROID_LOG_TAGS="ActivityManager:I MyApp:D *:S"
+</pre>
+
+ <p>Note that <code>ANDROID_LOG_TAGS</code> filter is not exported to the emulator/device
+ instance, if you are running LogCat from a remote shell or using <code>adb shell
+ logcat</code>.</p>
+
+ <h3 id="outputFormat">Controlling Log Output Format</h3>
+
+ <p>Log messages contain a number of metadata fields, in addition to the tag and priority. You can
+ modify the output format for messages so that they display a specific metadata field. To do so,
+ you use the <code>-v</code> option and specify one of the supported output formats listed
+ below.</p>
+
+ <ul>
+ <li><code>brief</code> — Display priority/tag and PID of the process issuing the
+ message (the default format).</li>
+
+ <li><code>process</code> — Display PID only.</li>
+
+ <li><code>tag</code> — Display the priority/tag only.</li>
+
+ <li><code>raw</code> — Display the raw log message, with no other metadata fields.</li>
+
+ <li><code>time</code> — Display the date, invocation time, priority/tag, and PID of the
+ process issuing the message.</li>
+
+ <li><code>threadtime</code> — Display the date, invocation time, priority, tag, and
+ the PID and TID of the thread issuing the message.</li>
+
+ <li><code>long</code> — Display all metadata fields and separate messages with blank
+ lines.</li>
+ </ul>
+
+ <p>When starting LogCat, you can specify the output format you want by using the
+ <code>-v</code> option:</p>
+ <pre>
+[adb] logcat [-v <format>]
+</pre>
+
+ <p>Here's an example that shows how to generate messages in <code>thread</code> output
+ format:</p>
+ <pre>
+adb logcat -v thread
+</pre>
+
+ <p>Note that you can only specify one output format with the <code>-v</code> option.</p>
+
+ <h3 id="alternativeBuffers">Viewing Alternative Log Buffers</h3>
+
+ <p>The Android logging system keeps multiple circular buffers for log messages, and not all of
+ the log messages are sent to the default circular buffer. To see additional log messages, you can
+ run the <code>logcat</code> command with the <code>-b</code> option, to request viewing of an alternate
+ circular buffer. You can view any of these alternate buffers:</p>
+
+ <ul>
+ <li><code>radio</code> — View the buffer that contains radio/telephony related
+ messages.</li>
+
+ <li><code>events</code> — View the buffer containing events-related messages.</li>
+
+ <li><code>main</code> — View the main log buffer (default)</li>
+ </ul>
+
+ <p>The usage of the <code>-b</code> option is:</p>
+ <pre>
+[adb] logcat [-b <buffer>]
+</pre>
+
+ <p>Here's an example of how to view a log buffer containing radio and telephony messages:</p>
+ <pre>
+adb logcat -b radio
+</pre><a name="stdout"
+ id="stdout"></a>
+
+ <h2 id="viewingStd">Viewing stdout and stderr</h2>
+
+ <p>By default, the Android system sends <code>stdout</code> and <code>stderr</code>
+ (<code>System.out</code> and <code>System.err</code>) output to <code>/dev/null</code>. In
+ processes that run the Dalvik VM, you can have the system write a copy of the output to the log
+ file. In this case, the system writes the messages to the log using the log tags
+ <code>stdout</code> and <code>stderr</code>, both with priority <code>I</code>.</p>
+
+ <p>To route the output in this way, you stop a running emulator/device instance and then use the
+ shell command <code>setprop</code> to enable the redirection of output. Here's how you do it:</p>
+ <pre>
+$ adb shell stop
+$ adb shell setprop log.redirect-stdio true
+$ adb shell start
+</pre>
+
+ <p>The system retains this setting until you terminate the emulator/device instance. To use the
+ setting as a default on the emulator/device instance, you can add an entry to
+ <code>/data/local.prop</code> on the device.</p>
+
+ <h2 id="DebuggingWebPages">Debugging Web Apps</h2>
+ <p>
+ If you're developing a web application for Android, you can debug your JavaScript using the console JavaScript APIs,
+ which output messages to LogCat. For more information, see
+ <a href="{@docRoot}guide/webapps/debugging.html">Debugging Web Apps</a>.</p>
diff --git a/docs/html/tools/debugging/debugging-projects-cmdline.jd b/docs/html/tools/debugging/debugging-projects-cmdline.jd
new file mode 100644
index 0000000..0b79575
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-projects-cmdline.jd
@@ -0,0 +1,78 @@
+page.title=Debugging from Other IDEs
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#start-debugging">Starting a Debugging Environment</a>
+ <ul>
+ <li><a href="#debuggingPort">Configuring Your IDE to Attach to the Debugging Port</a></li>
+ </ul>
+ </li>
+ </ol>
+ </div>
+ </div>
+
+ <p>If you are not using Eclipse to develop, you can still take advantage of all the tools that
+ the Android SDK provides for debugging. A basic debugging environment consists of:</p>
+
+ <ul>
+ <li><a href="{@docRoot}tools/help/adb.html">ADB</a></li>
+
+ <li><a href="{@docRoot}tools/debugging/ddms.html">DDMS</a></li>
+
+ <li>Java Debugger</li>
+ </ul>
+
+ <p>You need to obtain a JDWP-compliant Java debugger to properly debug your application.
+ Most Java IDEs will already have one included, or you can use a command line debugger,
+ such as JDB, if you are using a simple text editor to develop applications.</p>
+
+ <h2 id="start-debugging">Starting a debugging environment</h2>
+ <p>A Java Debugger assists you in finding problems with
+ your code by letting you set breakpoints, step through execution of your application, and examine
+ variable values. Since you are not using Eclipse, you have to manually start up the debugging
+ environment yourself by running a few tools that are provided in the Android SDK. To begin
+ debugging your application, follow these general steps:</p>
+
+ <ol>
+ <li>Load an AVD with the Android emulator or connect a device to your computer.</li>
+
+ <li>Start DDMS from the sdk <code>/tools</code> directory. This also starts ADB if it is
+ not already started. You should see your device appear in DDMS.</li>
+
+ <li>Install and run your <code>.apk</code> file on the device or emulator. In DDMS, you should see your
+ application running under the device that you installed it to.</li>
+
+ <li>Attach your debugger to the debugging port 8700, or to the specific port shown for the
+ application in DDMS.</li>
+ </ol>
+
+ <h3 id="debuggingPort">Configuring Your IDE to Attach to the Debugging Port</h3>
+
+ <p>DDMS assigns a specific debugging port to every virtual machine that it finds on the
+ emulator. You must either attach your IDE to that port (listed on the Info tab for that VM), or
+ you can use a default port 8700 to connect to whatever application is currently selected on the
+ list of discovered virtual machines.</p>
+
+ <p>Your IDE should attach to your application running on the emulator, showing you its threads
+ and allowing you to suspend them, inspect their state, and set breakpoints. If you selected "Wait
+ for debugger" in the Development settings panel the application will run when Eclipse connects,
+ so you will need to set any breakpoints you want before connecting.</p>
+
+ <p>Changing either the application being debugged or the "Wait for debugger" option causes the
+ system to kill the selected application if it is currently running. You can use this to kill your
+ application if it is in a bad state by simply going to the settings and toggling the
+ checkbox.</p>
+
+
+
+
+
+
+
diff --git a/docs/html/tools/debugging/debugging-projects.jd b/docs/html/tools/debugging/debugging-projects.jd
new file mode 100644
index 0000000..2283f8b
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-projects.jd
@@ -0,0 +1,67 @@
+page.title=Debugging from Eclipse with ADT
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#tools">The Debug Perspective</a></li>
+
+ <li><a href="#toptips">The DDMS Perspective</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>If you are developing in Eclipse with the ADT plugin, you can use the built-in Java Debugger,
+ along with DDMS, to debug your applications. To access the debugger and
+ DDMS, Eclipse displays the debugger and DDMS features as perspectives, which are customized
+ Eclipse views that display certain tabs and windows depending on the perspective that you are in.
+ Eclipse also takes care of starting the ADB host daemon for you, so you do not have to run this
+ manually.</p>
+
+ <h2>The Debug Perspective in Eclipse</h2>
+
+ <p>The Debug Perspective in Eclipse gives you access to the following tabs:</p>
+
+ <ul>
+ <li>Debug - Displays previously and currently debugged Android applications and its currently
+ running threads</li>
+
+ <li>Variables - When breakpoints are set, displays variable values during code execution</li>
+
+ <li>Breakpoints - Displays a list of the set breakpoints in your application code</li>
+
+ <li>LogCat - Allows you to view system log messages in real time. The LogCat tab is also
+ available in the DDMS perspective.</li>
+ </ul>
+ <p>You can access the Debug Perspective by clicking <strong>Window > Open Perspective >
+ Debug</strong>. Refer to the appropriate documentation for the Eclipse debugger for more
+ information.</p>
+
+ <h2>The DDMS Perspective</h2>
+ <p>The DDMS Perspective in Eclipse lets you access all of the features
+ of DDMS from within the Eclipse IDE. The following sections of DDMS are available to you:</p>
+
+ <ul>
+ <li>Devices - Shows the list of devices and AVDs that are connected to ADB.</li>
+
+ <li>Emulator Control - Lets you carry out device functions.</li>
+
+ <li>LogCat - Lets you view system log messages in real time.</li>
+
+ <li>Threads - Shows currently running threads within a VM.</li>
+
+ <li>Heap - Shows heap usage for a VM.</li>
+
+ <li>Allocation Tracker - Shows the memory allocation of objects.</li>
+
+ <li>File Explorer - Lets you explore the device's file system.</li>
+ </ul>
+ <p>To access the DDMS perspective, go to <strong>Window > Open Perspective >
+ DDMS</strong>. If DDMS does not appear, go to <strong>Window > Open Perspective > Other
+ ...</strong> and select <strong>DDMS</strong> from the Open Perspective window that appears. For
+ more information on using DDMS, see <a href="ddms.html">Using the Dalvik Debug Monitor Server</a>.
+ </p>
\ No newline at end of file
diff --git a/docs/html/tools/debugging/debugging-tracing.jd b/docs/html/tools/debugging/debugging-tracing.jd
new file mode 100644
index 0000000..f0d0c0b
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-tracing.jd
@@ -0,0 +1,402 @@
+page.title=Profiling with Traceview and dmtracedump
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li>
+ <a href="#traceviewLayout">Traceview Layout</a>
+
+ <ol>
+ <li><a href="#timelinepanel">Timeline Panel</a></li>
+
+ <li><a href="#profilepanel">Profile Panel</a></li>
+ </ol>
+ </li>
+
+ <li>
+ <a href="#format">Traceview File Format</a>
+ <ol>
+ <li><a href="#datafileformat">Data File Format</a></li>
+
+ <li><a href="#keyfileformat">Key File Format</a></li>
+ </ol>
+ </li>
+
+ <li><a href="#creatingtracefiles">Creating Trace Files</a></li>
+
+ <li><a href="#copyingfiles">Copying Trace Files to a Host Machine</a></li>
+
+ <li><a href="#runningtraceview">Viewing Trace Files in Traceview</a></li>
+
+ <li><a href="#dmtracedump">Using dmtracedump</a></li>
+
+ <li><a href="#knownissues">Traceview Known Issues</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>Traceview is a graphical viewer for execution logs that you create by using the {@link
+ android.os.Debug} class to log tracing information in your code. Traceview can help you debug
+ your application and profile its performance.</p>
+
+ <h2 id="traceviewLayout">Traceview Layout</h2>
+
+ <p>When you have a trace log file (generated by adding tracing code to your application or by DDMS),
+ you can have Traceview load the log files and display their data in a window visualizes your application
+ in two panels:</p>
+
+ <ul>
+ <li>A <a href="#timelinepanel">timeline panel</a> -- describes when each thread and method
+ started and stopped</li>
+
+ <li>A <a href="#timelinepanel">profile panel</a> -- provides a summary of what happened inside
+ a method</li>
+ </ul>
+
+ <p>The sections below provide addition information about the traceview output panes.</p>
+
+ <h3 id="timelinepanel">Timeline Panel</h3>
+
+ <p>The image below shows a close up of the timeline panel. Each thread’s execution is shown
+ in its own row, with time increasing to the right. Each method is shown in another color (colors
+ are reused in a round-robin fashion starting with the methods that have the most inclusive time).
+ The thin lines underneath the first row show the extent (entry to exit) of all the calls to the
+ selected method. The method in this case is <code>LoadListener.nativeFinished()</code> and it was selected in
+ the profile view.</p>
+
+ <img src="{@docRoot}images/traceview_timeline.png"
+ alt="Traceview timeline panel"
+ width="893"
+ height="284" />
+ <p class="img-caption"><strong>Figure 1.</strong> The Traceview Timeline Panel</p>
+
+ <h3 id="profilepanel">Profile Panel</h3>
+
+ <p>Figure 2 shows the profile pane, a summary of all the time spent
+ in a method. The table shows both the inclusive and exclusive times (as well as the percentage of
+ the total time). Exclusive time is the time spent in the method. Inclusive time is the time spent
+ in the method plus the time spent in any called functions. We refer to calling methods as
+ "parents" and called methods as "children." When a method is selected (by clicking on it), it
+ expands to show the parents and children. Parents are shown with a purple background and children
+ with a yellow background. The last column in the table shows the number of calls to this method
+ plus the number of recursive calls. The last column shows the number of calls out of the total
+ number of calls made to that method. In this view, we can see that there were 14 calls to
+ <code>LoadListener.nativeFinished();</code> looking at the timeline panel shows that one of those calls took
+ an unusually long time.</p>
+
+ <img src="{@docRoot}images/traceview_profile.png"
+ alt="Traceview profile panel."
+ width="892"
+ height="630" />
+ <p class="img-caption"><strong>Figure 2.</strong> The Traceview Profile Panel</p>
+
+ <h2 id="format">Traceview File Format</h2>
+
+ <p>Tracing creates two distinct pieces of output: a <em>data</em> file, which holds the trace
+ data, and a <em>key</em> file, which provides a mapping from binary identifiers to thread and
+ method names. The files are concatenated when tracing completes, into a single <em>.trace</em>
+ file.</p>
+
+ <p class="note"><strong>Note:</strong> The previous version of Traceview did not concatenate
+ these files for you. If you have old key and data files that you'd still like to trace, you can
+ concatenate them yourself with <code>cat mytrace.key mytrace.data >
+ mytrace.trace</code>.</p>
+
+ <h3 id="datafileformat">Data File Format</h3>
+
+ <p>The data file is binary, structured as follows (all values are stored in little-endian
+ order):</p>
+ <pre>
+* File format:
+* header
+* record 0
+* record 1
+* ...
+*
+* Header format:
+* u4 magic 0x574f4c53 ('SLOW')
+* u2 version
+* u2 offset to data
+* u8 start date/time in usec
+*
+* Record format:
+* u1 thread ID
+* u4 method ID | method action
+* u4 time delta since start, in usec
+</pre>
+
+ <p>The application is expected to parse all of the header fields, then seek to "offset to data"
+ from the start of the file. From there it just reads 9-byte records until EOF is reached.</p>
+
+ <p><em>u8 start date/time in usec</em> is the output from <code>gettimeofday()</code>. It's mainly there so
+ that you can tell if the output was generated yesterday or three months ago.</p>
+
+ <p><em>method action</em> sits in the two least-significant bits of the <em>method</em> word. The
+ currently defined meanings are:</p>
+
+ <ul>
+ <li>0 - method entry</li>
+
+ <li>1 - method exit</li>
+
+ <li>2 - method "exited" when unrolled by exception handling</li>
+
+ <li>3 - (reserved)</li>
+ </ul>
+
+ <p>An unsigned 32-bit integer can hold about 70 minutes of time in microseconds.</p>
+
+ <h3 id="keyfileformat">Key File Format</h3>
+
+ <p>The key file is a plain text file divided into three sections. Each section starts with a
+ keyword that begins with '*'. If you see a '*' at the start of a line, you have found the start
+ of a new section.</p>
+
+ <p>An example file might look like this:</p>
+ <pre>
+*version
+1
+clock=global
+*threads
+1 main
+6 JDWP Handler
+5 Async GC
+4 Reference Handler
+3 Finalizer
+2 Signal Handler
+*methods
+0x080f23f8 java/io/PrintStream write ([BII)V
+0x080f25d4 java/io/PrintStream print (Ljava/lang/String;)V
+0x080f27f4 java/io/PrintStream println (Ljava/lang/String;)V
+0x080da620 java/lang/RuntimeException <init> ()V
+[...]
+0x080f630c android/os/Debug startMethodTracing ()V
+0x080f6350 android/os/Debug startMethodTracing (Ljava/lang/String;Ljava/lang/String;I)V
+*end
+</pre>
+<p>The following list describes the major sections of a key file:</p>
+ <dl>
+ <dt><em>version section</em></dt>
+
+ <dd>The first line is the file version number, currently 1. The second line,
+ <code>clock=global</code>, indicates that we use a common clock across all threads. A future
+ version may use per-thread CPU time counters that are independent for every thread.</dd>
+
+ <dt><em>threads section</em></dt>
+
+ <dd>One line per thread. Each line consists of two parts: the thread ID, followed by a tab,
+ followed by the thread name. There are few restrictions on what a valid thread name is, so
+ include everything to the end of the line.</dd>
+
+ <dt><em>methods section</em></dt>
+
+ <dd>One line per method entry or exit. A line consists of four pieces, separated by tab marks:
+ <em>method-ID</em> [TAB] <em>class-name</em> [TAB] <em>method-name</em> [TAB]
+ <em>signature</em> . Only the methods that were actually entered or exited are included in the
+ list. Note that all three identifiers are required to uniquely identify a method.</dd>
+ </dl>
+
+ <p>Neither the threads nor methods sections are sorted.</p>
+
+ <h2 id="creatingtracefiles">Creating Trace Files</h2>
+
+ <p>To use Traceview, you need to generate log files containing the trace information you want to
+ analyze.</p>
+
+ <p>There are two ways to generate trace logs:</p>
+ <ul>
+ <li>Include the {@link android.os.Debug} class in your code and call its
+ methods to start and stop logging of trace information to disk. This method is very precise because
+ you can specify in your code exactly where to start and stop logging trace data.</li>
+ <li>Use the method profiling feature of DDMS to generate trace logs. This method is less
+ precise since you do not modify code, but rather specify when to start and stop logging with
+ a DDMS. Although you have less control on exactly where the data is logged, this method is useful
+ if you don't have access to the application's code, or if you do not need the precision of the first method.
+ </li>
+ </ul>
+
+ <p>Before you start generating trace logs, be aware of the following restrictions:</p>
+ <ul>
+ <li>If you are using the {@link android.os.Debug} class, your device or emulator must have an SD card
+ and your application must have permission to write to the SD card. </li>
+ <li>If you are using DDMS, Android 1.5 devices are not supported.</li>
+ <li>If you are using DDMS, Android 2.1 and earlier devices must
+ have an SD card present and your application must have permission to write to the SD card.
+ <li>If you are using DDMS, Android 2.2 and later devices do not need an SD card. The trace log files are
+ streamed directly to your development machine.</li>
+ </ul>
+
+ <p>This document focuses on using the {@link android.os.Debug} class to generate trace data. For more information on using DDMS
+ to generate trace data, see <a href="ddms.html#profiling">Using the Dalvik Debug Monitor Server.</a>
+ </p>
+
+ <p>To create the trace files, include the {@link android.os.Debug} class and call one of the
+ {@link android.os.Debug#startMethodTracing() startMethodTracing()} methods. In the call, you
+ specify a base name for the trace files that the system generates. To stop tracing, call {@link
+ android.os.Debug#stopMethodTracing() stopMethodTracing()}. These methods start and stop method
+ tracing across the entire virtual machine. For example, you could call
+ {@link android.os.Debug#startMethodTracing() startMethodTracing()} in
+ your activity's {@link android.app.Activity#onCreate onCreate()} method, and call
+ {@link android.os.Debug#stopMethodTracing() stopMethodTracing()} in that activity's
+ {@link android.app.Activity#onDestroy()} method.</p>
+ <pre>
+ // start tracing to "/sdcard/calc.trace"
+ Debug.startMethodTracing("calc");
+ // ...
+ // stop tracing
+ Debug.stopMethodTracing();
+</pre>
+
+ <p>When your application calls startMethodTracing(), the system creates a file called
+ <code><trace-base-name>.trace</code>. This contains the binary method trace data and a
+ mapping table with thread and method names.</p>
+
+ <p>The system then begins buffering the generated trace data, until your application calls
+ stopMethodTracing(), at which time it writes the buffered data to the output file. If the system
+ reaches the maximum buffer size before stopMethodTracing() is called, the system stops tracing
+ and sends a notification to the console.</p>
+
+ <p>Interpreted code will run more slowly when profiling is enabled. Don't try to generate
+ absolute timings from the profiler results (i.e. "function X takes 2.5 seconds to run"). The
+ times are only useful in relation to other profile output, so you can see if changes have made
+ the code faster or slower.</p>
+
+ <p>When using the Android emulator, you must specify an SD card when you create your AVD because the trace files
+ are written to the SD card. Your application must have permission to write to the SD card as well.
+
+ <p>The format of the trace files is previously described <a href="#format">in this
+ document</a>.</p>
+
+ <h2 id="copyingfiles">Copying Trace Files to a Host Machine</h2>
+
+ <p>After your application has run and the system has created your trace files
+ <code><trace-base-name>.trace</code> on a device or emulator, you must copy those files to
+ your development computer. You can use <code>adb pull</code> to copy the files. Here's an example
+ that shows how to copy an example file, calc.trace, from the default location on the emulator to
+ the /tmp directory on the emulator host machine:</p>
+ <pre>
+adb pull /sdcard/calc.trace /tmp
+</pre>
+
+ <h2 id="runningtraceview">Viewing Trace Files in Traceview</h2>
+
+ <p>To run Traceview and view the trace files, enter <code>traceview
+ <trace-base-name></code>. For example, to run Traceview on the example files copied in the
+ previous section, use:</p>
+ <pre>
+traceview /tmp/calc
+</pre>
+
+ <p class="note"><strong>Note:</strong> If you are trying to view the trace logs of an application
+ that is built with ProGuard enabled (release mode build), some method and member names might be obfuscated.
+ You can use the Proguard <code>mapping.txt</code> file to figure out the original unobfuscated names. For more information
+ on this file, see the <a href="{@docRoot}tools/help/proguard.html">Proguard</a> documentation.</p>
+
+ <h2 id="dmtracedump">Using dmtracdedump</h2>
+
+ <p><code>dmtracedump</code> is a tool that gives you an alternate way of generating
+ graphical call-stack diagrams from trace log files. The tool uses the Graphviz Dot utility to
+ create the graphical output, so you need to install Graphviz before running dmtracedump.</p>
+
+ <p>The dmtracedump tool generates the call stack data as a tree diagram, with each call
+ represented as a node. It shows call flow (from parent node to child nodes) using arrows. The
+ diagram below shows an example of dmtracedump output.</p>
+ <img src=
+ "{@docRoot}images/tracedump.png"
+ width="485"
+ height="401" />
+ <p class="image-caption"><strong>Figure 3.</strong> Screenshot of dmtracedump</p>
+
+ <p>For each node, dmtracedump shows <code><ref>
+ <em>callname</em> (<inc-ms>, <exc-ms>,<numcalls>)</code>, where</p>
+
+ <ul>
+ <li><code><ref></code> -- Call reference number, as used in trace logs</li>
+
+ <li><code><inc-ms></code> -- Inclusive elapsed time (milliseconds spent in method,
+ including all child methods)</li>
+
+ <li><code><exc-ms></code> -- Exclusive elapsed time (milliseconds spent in method,
+ not including any child methods)</li>
+
+ <li><code><numcalls></code> -- Number of calls</li>
+ </ul>
+
+ <p>The usage for dmtracedump is:</p>
+ <pre>
+dmtracedump [-ho] [-s sortable] [-d trace-base-name] [-g outfile] <trace-base-name>
+</pre>
+
+ <p>The tool then loads trace log data from <code><trace-base-name>.data</code> and
+ <code><trace-base-name>.key</code>. The table below lists the options for dmtracedump.</p>
+
+ <table>
+ <tr>
+ <th>Option</th>
+
+ <th>Description</th>
+ </tr>
+
+ <tr>
+ <td><code>-d <trace-base-name></code></td>
+
+ <td>Diff with this trace name</td>
+ </tr>
+
+ <tr>
+ <td><code>-g <outfile></code></td>
+
+ <td>Generate output to <outfile></td>
+ </tr>
+
+ <tr>
+ <td><code>-h</code></td>
+
+ <td>Turn on HTML output</td>
+ </tr>
+
+ <tr>
+ <td><code>-o</code></td>
+
+ <td>Dump the trace file instead of profiling</td>
+ </tr>
+
+ <tr>
+ <td><code>-d <trace-base-name></code></td>
+
+ <td>URL base to the location of the sortable javascript file</td>
+ </tr>
+
+ <tr>
+ <td><code>-t <percent></code></td>
+
+ <td>Minimum threshold for including child nodes in the graph (child's inclusive time as a
+ percentage of parent inclusive time). If this option is not used, the default threshold
+ is 20%.</td>
+ </tr>
+ </table>
+
+
+
+ <h2 id="knownissues">Traceview Known Issues</h2>
+
+ <dl>
+ <dt>Threads</dt>
+
+ <dd>
+ Traceview logging does not handle threads well, resulting in these two problems:
+
+ <ol>
+ <li>If a thread exits during profiling, the thread name is not emitted;</li>
+
+ <li>The VM reuses thread IDs. If a thread stops and another starts, they may get the same
+ ID.</li>
+ </ol>
+ </dd>
+
+ </dl>
\ No newline at end of file
diff --git a/docs/html/tools/debugging/debugging-ui.jd b/docs/html/tools/debugging/debugging-ui.jd
new file mode 100644
index 0000000..c1976b8
--- /dev/null
+++ b/docs/html/tools/debugging/debugging-ui.jd
@@ -0,0 +1,547 @@
+page.title=Optimizing Your UI
+parent.title=Debugging
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li>
+ <a href="#HierarchyViewer">
+ Using Hierarchy Viewer
+ </a>
+ <ol>
+ <li><a href="#runhv">Running Hierarchy Viewer and choosing a window</a></li>
+ <li><a href="#viewhierarchy">About the View Hierarchy window</a></li>
+ <li><a href="#indiView">Working with an individual View in Tree View</a></li>
+ <li><a href="#hvdebugging">Debugging with View Hierarchy</a></li>
+ <li><a href="#hvoptimize">Optimizing with View Hierarchy</a></li>
+ </ol>
+ </li>
+ <li>
+ <a href="#pixelperfect">
+ Using Pixel Perfect
+ </a>
+ <ol>
+ <li><a href="#aboutpixelperfect">About the Pixel Perfect window</a></li>
+ <li><a href="#overlays">Working with Pixel Perfect overlays</a></li>
+ </ol>
+ </li>
+ <li><a href="#layoutopt">Using layoutopt</a></li>
+ </ol>
+ <h2>Related videos</h2>
+ <ol>
+ <li>
+<iframe title="Hierarchyviewer"
+ width="210" height="160"
+ src="http://www.youtube.com/embed/PAgE7saQUUY?rel=0&hd=1"
+ frameborder="0" allowfullscreen>
+</iframe>
+ </li>
+ <li>
+<iframe title="Pixel Perfect"
+ width="210" height="160"
+ src="http://www.youtube.com/embed/C45bMZGdN7Y?rel=0&hd=1"
+ frameborder="0"
+ allowfullscreen>
+</iframe>
+ </li>
+ </ol>
+ </div>
+ </div>
+
+ <p>
+Sometimes your application's layout can slow down your application.
+ To help debug issues in your layout, the Android SDK provides the Hierarchy Viewer and
+ <code>layoutopt</code> tools.
+ </p>
+
+ <p>The Hierarchy Viewer application allows you to debug and optimize your user interface. It
+ provides a visual representation of the layout's View hierarchy (the View Hierarchy window)
+ and a magnified view of the display (the Pixel Perfect window).</p>
+
+ <p><code>layoutopt</code> is a command-line tool that helps you optimize the layouts and layout
+ hierarchies of your applications. You can run it against your layout files or resource
+ directories to quickly check for inefficiencies or other types of problems that could be
+ affecting the performance of your application.</p>
+
+<h2 id="HierarchyViewer">Using Hierarchy Viewer</h2>
+
+<h3 id="runhv">Running Hierarchy Viewer and choosing a window</h3>
+<p>
+ To run Hierarchy Viewer, follow these steps:</p>
+<ol>
+ <li>
+ Connect your device or launch an emulator.
+ <p>
+ To preserve security, Hierarchy Viewer can only connect to devices running a
+ developer version of the Android system.
+ </p>
+ </li>
+ <li>
+ If you have not done so already, install the application you want to work with.
+ </li>
+ <li>
+ Run the application, and ensure that its UI is visible.
+ </li>
+ <li>
+ From a terminal, launch <code>hierarchyviewer</code> from the
+ <code><sdk>/tools/</code>
+ directory.
+ </li>
+ <li>
+ The first window you see displays a list of devices and emulators. To expand the list
+ of Activity objects for a device or emulator, click the arrow on the left. This displays a
+ list of the Activity objects whose UI is currently visible on the device or emulator. The
+ objects are listed by their Android component name. The list includes both your application
+ Activity and system Activity objects. A screenshot of this window appears in
+ figure 1.
+ </li>
+ <li>
+ Select the name of your Activity from the list. You can now look at its view
+ hierarchy using the View Hierarchy window, or look at a magnified image of the UI using
+ the Pixel Perfect window.
+ </li>
+</ol>
+<p>
+ To learn how to use the View Hierarchy window, go to
+ <a href="#viewhierarchy">About the View Hierarchy window</a>. To learn how to use the
+ Pixel Perfect window, go to <a href="#pixelperfect">About the Pixel Perfect window</a>.
+</p>
+<img id="Fig1" src="{@docRoot}images/developing/hv_device_window.png" alt="" height="600"/>
+<p class="img-caption"><strong>Figure 1.</strong> Hierarchy Viewer device window</p>
+<h3 id="viewhierarchy">About the View Hierarchy window</h3>
+<p>
+ The View Hierarchy window displays the View objects that form the UI of the
+ Activity that is running on your device or emulator. You use it to look at individual
+ View objects within the context of the entire View tree. For each View object, the View
+ Hierarchy window also displays rendering performance data.
+</p>
+<p>
+ To see the View Hierarchy window, run Hierarchy Viewer as described in
+ the section <a href="#runhv">Running Hierarchy Viewer and choosing a window</a>. Next, click
+ <strong>View Hierarchy</strong> at the top of the device window.
+</p>
+<p>
+ You should see four panes:
+</p>
+<ul>
+ <li>
+ <strong>Tree View</strong>: The left-hand pane displays the Tree View,
+ a diagram of the Activity object's hierarchy of views. Use Tree View to examine individual
+ View objects and see the relationships between View objects in your UI.
+ <p>
+ To zoom in on the pane, use the slider at the bottom of the pane, or use your mouse
+ scroll wheel. To move around in the pane or reveal View objects that are not currently
+ visible, click and drag the pane.
+ </p>
+ <p>
+ To highlight the nodes in the tree whose class or ID match a search string, enter the
+ string in the <strong>Filter by class or id:</strong> edit box at the bottom of the
+ window. The background of nodes that match the search string will change from gray to
+ bright blue.
+ </p>
+ <p>
+ To save a screenshot of Tree View to a PNG file, click <strong>Save As PNG</strong> at
+ the top of the View Hierarchy window. This displays a dialog in which you can choose
+ a directory and file name.
+ </p>
+ <p>
+ To save a layered screenshot of your device or emulator to an Adobe Photoshop (PSD)
+ file, click <strong>Capture Layers</strong> at the top of the View Hierarchy window.
+ This displays a dialog in which you can choose a directory or file name.
+ Each View in the UI is saved as a separate Photoshop layer.
+ </p>
+ <p>
+ In Photoshop (or similar program that accepts .psd files), you can hide, show or edit a
+ layer independently of others. When you save a layered screenshot, you can examine and
+ modify the image of an individual View object. This helps you experiment with design
+ changes.
+ </p>
+ </li>
+ <li>
+ The upper right-hand pane displays the <strong>Tree Overview</strong>, a smaller map
+ representation of the entire Tree View window. Use Tree Overview to identify the part of the
+ view tree that is being displayed in Tree View.
+ <p>
+ You can also use Tree Overview to move around in the Tree View pane. Click and drag
+ the shaded rectangle over an area to reveal it in Tree View.
+ </p>
+ </li>
+ <li>
+ The middle right-hand pane displays the <strong>Properties View</strong>,
+ a list of the properties for a selected View object. With Properties View, you can
+ examine all the properties without having to look at your application source.
+ <p>
+ The properties are organized by category. To find an individual property, expand
+ a category name by clicking the arrow on its left. This reveals all the properties
+ in that category.
+ </p>
+ </li>
+ <li>
+ The lower right-hand pane displays the <strong>Layout View</strong>,
+ a block representation of the UI. Layout View is another way to navigate through your UI.
+ When you click on a View object in Tree View, its position in the UI is highlighted.
+ Conversely, when you click in an area of Layout View, the View object for that area is
+ highlighted in Tree View.
+ <p>
+ The outline colors of blocks in Layout View provide additional information:
+ </p>
+ <ul>
+ <li>
+ Bold red: The block represents the the View that is currently selected in
+ Tree View.
+ </li>
+ <li>
+ Light red: The block represents the parent of the block outlined in bold red.
+ </li>
+ <li>
+ White: The block represents a visible View that is not a parent or child of the
+ View that is currently selected in Tree View.
+ </li>
+ </ul>
+ </li>
+</ul>
+<p>
+ When the UI of the current Activity changes, the View Hierarchy window is not automatically
+ updated. To update it, click <strong>Load View Hierarchy</strong> at the top of the window.
+</p>
+<p>
+ Also, the window is not updated if you switch to a new Activity. To update it, start by
+ clicking the window selection icon in the bottom left-hand corner of the window. This
+ navigates back to the Window Selection window. From this window, click the Android
+ component name of the new Activity and then click <strong>Load View Hierarchy</strong>
+ at the top of the window.
+</p>
+<p>
+ A screenshot of the View Hierarchy window appears in figure 2.
+</p>
+<img id="Fig2" src="{@docRoot}images/developing/hv_view_hierarchy_window.png" alt="" height="600"/>
+<p class="img-caption"><strong>Figure 2.</strong> The View Hierarchy window</p>
+<h3 id="indiView">Working with an individual View in Tree View</h3>
+<p>
+ Each node in Tree View represents a single View. Some information is always visible. Starting
+ at the top of the node, you see the following:
+</p>
+<ol>
+ <li>
+ View class: The View object's class.
+ </li>
+ <li>
+ View object address: A pointer to View object.
+ </li>
+ <li>
+ View object ID: The value of the
+ <code><a href="{@docRoot}guide/topics/resources/layout-resource.html#idvalue">android:id</a>
+ </code> attribute.
+ </li>
+ <li>
+ Performance indicators: A set of three colored dots that indicate the rendering
+ speed of this View relative to other View objects in the tree. The three dots
+ represent (from left to right) the measure, layout, and draw times of the rendering.
+ <p>
+ The colors indicate the following relative performance:
+ </p>
+ <ul>
+ <li>
+ Green: For this part of the render time, this View is in the faster 50% of all
+ the View objects in the tree. For example, a green dot for the measure time means
+ that this View has a faster measure time than 50% of the View objects in the tree.
+ </li>
+ <li>
+ Yellow: For this part of the render time, this View is in the slower 50% of all
+ the View objects in the tree. For example, a yellow dot for the layout time means
+ that this View has a slower layout time than 50% of the View objects in the tree.
+ </li>
+ <li>
+ Red: For this part of the render time, this View is the slowest one in the tree.
+ For example, a red dot for the draw time means that this View takes the most
+ time to draw of all the View objects in the tree.
+ </li>
+ </ul>
+ </li>
+ <li>
+ View index: The zero-based index of the View in its parent View. If it is the only child,
+ this is 0.
+ </li>
+</ol>
+<p>
+ When you select a node, additional information for the View appears in a small window above
+ the node. When you click one of the nodes, you see the following:
+</p>
+<ul>
+ <li>
+ Image: The actual image of the View, as it would appear in the emulator. If the View has
+ children, these are also displayed.
+ </li>
+ <li>
+ View count: The number of View objects represented by this node. This includes the View
+ itself and a count of its children. For example, this value is 4 for a View that has 3
+ children.
+ </li>
+ <li>
+ Render times: The actual measure, layout, and draw times for the View rendering, in
+ milliseconds. These represent the same values as the performance indicators mentioned in
+ the preceding section.
+ </li>
+</ul>
+<p>
+ An annotated screenshot of an individual node in the Tree View window appears in figure 3.
+</p>
+<img id="Fig3" src="{@docRoot}images/developing/hv_treeview_screenshot.png" alt="" height="600"/>
+<p class="img-caption"><strong>Figure 3.</strong> An annotated node in Tree View</p>
+<h3 id="hvdebugging">Debugging with View Hierarchy</h3>
+<p>
+ The View Hierarchy window helps you debug an application by providing a static display
+ of the UI. The display starts with your application's opening screen. As you step through
+ your application, the display remains unchanged until you redraw it by invalidating and
+ then requesting layout for a View.
+</p>
+<p>
+ To redraw a View in the display:
+</p>
+ <ul>
+ <li>
+ Select a View in Tree View. As you move up towards the root of the tree (to the
+ left in the Tree View), you see the highest-level View objects. Redrawing a high-level
+ object usually forces the lower-level objects to redraw as well.
+ </li>
+ <li>
+ Click <strong>Invalidate</strong> at the top of the window. This marks the View as
+ invalid, and schedules it for a redraw at the next point that a layout is requested.
+ </li>
+ <li>
+ Click <strong>Request Layout</strong> to request a layout. The View and its children
+ are redrawn, as well as any other View objects that need to be redrawn.
+ </li>
+ </ul>
+<p>
+ Manually redrawing a View allows you to watch the View object tree and examine the properties of
+ individual View objects one step at a time as you go through breakpoints in your code.
+</p>
+<h3 id="hvoptimize">Optimizing with View Hierarchy</h3>
+<p>
+ View Hierarchy also helps you identify slow render performance. You start by looking at the
+ View nodes with red or yellow performance indicators to identify the slower View objects. As you
+ step through your application, you can judge if a View is consistently slow or slow only in
+ certain circumstances.
+</p>
+<p>
+ Remember that slow performance is not necessarily evidence of a problem, especially for
+ ViewGroup objects. View objects that have more children and more complex View objects render
+ more slowly.
+</p>
+<p>
+ The View Hierarchy window also helps you find performance issues. Just by looking at the
+ performance indicators (the dots) for each View node, you can see which View objects are the
+ slowest to measure, layout, and draw. From that, you can quickly identify the problems you
+ should look at first.
+</p>
+<h2 id="pixelperfect">Using Pixel Perfect</h2>
+<p>
+ Pixel Perfect is a tool for examining pixel properties and laying out UIs from a design drawing.
+</p>
+<h3 id="aboutpixelperfect">About the Pixel Perfect window</h3>
+<p>
+ The Pixel Perfect window displays a magnified image of the screen that is currently
+ visible on the emulator or device. In it, you can examine the properties
+ of individual pixels in the screen image. You can also use the Pixel Perfect window
+ to help you lay out your application UI based on a bitmap design.
+</p>
+<p>
+ To see the Pixel Perfect window, run Hierarchy Viewer, as described in
+ the section <a href="#runhv">Running Hierarchy Viewer and choosing a window</a>. Next, click
+ <strong>Inspect Screenshot</strong> at the top of the device window. The Pixel Perfect window
+ appears.
+</p>
+<p>
+ In it, you see three panes:
+</p>
+<ul>
+ <li>
+ View Object pane: This is a hierarchical list of the View objects that are currently
+ visible on the device or emulator screen, including both the ones in your application and
+ the ones generated by the system. The objects are listed by their View class.
+ To see the class names of a View object's children, expand the View by clicking the
+ arrow to its left. When you click a View, its position is highlighted in the Pixel Perfect
+ pane on the right.
+ </li>
+ <li>
+ Pixel Perfect Loupe pane: This is the magnified screen image. It is overlaid by a grid in
+ which each square represents one pixel. To look at the information for a pixel, click in its
+ square. Its color and X,Y coordinates appear at the bottom of the pane.
+ <p>
+ The magenta crosshair in the pane corresponds to the positioning
+ crosshair in the next pane. It only moves when you move the crosshair in the next pane.
+ </p>
+ <p>
+ To zoom in or out on the image, use the <strong>Zoom</strong> slider at the bottom of
+ the pane, or use your mouse's scroll wheel.
+ </p>
+ <p>
+ When you select a pixel in the Loupe pane, you see the following information at the
+ bottom of the pane:
+ </p>
+ <ul>
+ <li>
+ Pixel swatch: A rectangle filled with the same color as the pixel.
+ </li>
+ <li>
+ HTML color code: The hexadecimal RGB code corresponding to the pixel color
+ </li>
+ <li>
+ RGB color values: A list of the (R), green (G), and blue (B) color values of the
+ pixel color. Each value is in the range 0-255.
+ </li>
+ <li>
+ X and Y coordinates: The pixel's coordinates, in device-specific pixel units.
+ The values are 0-based, with X=0 at the left of the screen and Y=0 at the top.
+ </li>
+ </ul>
+ </li>
+ <li>
+ Pixel Perfect pane: This displays the currently visible screen as it would appear in the
+ emulator.
+ <p>
+ You use the cyan crosshair to do coarse positioning. Drag the crosshair in the image,
+ and the Loupe crosshair will move accordingly. You can also click on a point in the
+ Pixel Perfect pane, and the crosshair will move to that point.
+ </p>
+ <p>
+ The image corresponding to the View object selected in the View Object pane is
+ outlined in a box that indicates the View object's position on the screen. For the
+ selected object, the box is bold red. Sibling and parent View objects have a light
+ red box. View objects that are neither parents nor siblings are in white.
+ </p>
+ <p>
+ The layout box may have other rectangles either inside or outside it, each of which
+ indicates part of the View. A purple or green rectangle indicates the View bounding box.
+ A white or black box inside the layout box represents the <strong>padding</strong>, the
+ defined distance between the View object's content and its bounding box. An outer white
+ or black rectangle represents the <strong>margins</strong>, the distance between the
+ View bounding box and adjacent View objects. The padding and margin boxes are white if
+ the layout background is black, and vice versa.
+ </p>
+ <p>
+ You can save the screen image being displayed in the Pixel Perfect pane as a PNG file.
+ This produces a screenshot of the current screen. To do this, click
+ <strong>Save as PNG</strong> at the top of the window. This displays a dialog,
+ in which you can choose a directory and filename for the file.
+ </p>
+ </li>
+</ul>
+<p>
+ The panes are not automatically refreshed when you change one of the View objects or go to
+ another Activity. To refresh the Pixel Perfect pane and the Loupe pane, click
+ <strong>Refresh Screenshot</strong> at the top of the window. This will change the panes
+ to reflect the current screen image. You still may need to refresh the View Object pane;
+ to do this, click <strong>Refresh Tree</strong> at the top of the window.
+</p>
+<p>
+ To automatically refresh the panes while you are debugging, set
+ <strong>Auto Refresh</strong> at the top of the window, and then set a refresh rate
+ with the <strong>Refresh Rate</strong> slider at the bottom of the Loupe pane.
+</p>
+<h3 id="overlays">Working with Pixel Perfect overlays</h3>
+<p>
+ You often construct a UI based on a design done as a bitmap image. The Pixel Perfect window
+ helps you match up your View layout to a bitmap image by allowing you to load the bitmap as an
+ <strong>overlay</strong> on the screen image.
+</p>
+<p>
+ To use a bitmap image as an overlay:
+</p>
+<ul>
+ <li>
+ Start your application in a device or emulator and navigate to the Activity whose UI you
+ want to work with.
+ </li>
+ <li>
+ Start Hierarchy Viewer and navigate to the Pixel Perfect window.
+ </li>
+ <li>
+ At the top of the window, click <strong>Load Overlay</strong>. A dialog opens, prompting
+ for the image file to load. Load the image file.
+ </li>
+ <li>
+ Pixel Perfect displays the overlay over the screen image in the Pixel Perfect pane. The
+ lower left corner of the bitmap image (X=0, Y=<em>max value</em>) is anchored on the lower
+ leftmost pixel (X=0, Y=<em>max screen</em>) of the screen.
+ <p>
+ By default, the overlay has a 50% transparency, which allows you to see the screen
+ image underneath. You can adjust this with the <strong>Overlay:</strong> slider at the
+ bottom of the Loupe pane.
+ </p>
+ <p>
+ Also by default, the overlay is not displayed in the Loupe pane. To display it,
+ set <strong>Show in Loupe</strong> at the top of the window.
+ </p>
+ </li>
+</ul>
+<p>
+ The overlay is not saved as part of the screenshot when you save the screen image as a PNG
+ file.
+</p>
+<p>
+ A screenshot of the Pixel Perfect window appears in figure 4.
+</p>
+<img id="Fig4" src="{@docRoot}images/developing/hv_pixelperfect.png"
+ alt=""
+ height="600"/>
+<p class="img-caption"><strong>Figure 4.</strong> The Pixel Perfect window</p>
+<h2 id="layoutopt">Using layoutopt</h2>
+<p>
+ The <code>layoutopt</code> tool lets you analyze the XML files that define your
+ application's UI to find inefficiencies in the view hierarchy.</p>
+
+<p>
+ To run the tool, open a terminal and launch <code>layoutopt <xmlfiles></code>
+ from your SDK <code>tools/</code> directory. The <xmlfiles> argument is a space-
+ delimited list of resources you want to analyze, either uncompiled resource xml files or
+ directories of such files.
+</p>
+<p>
+ The tool loads the specified XML files and analyzes their definitions and
+ hierarchies according to a set of predefined rules. For every issue it detects, it
+ displays the following information:
+</p>
+<ul>
+ <li>
+ The filename in which the issue was detected.
+ </li>
+ <li>
+ The line number for the issue.
+ </li>
+ <li>
+ A description of the issue, and for some types of issues it also suggests a resolution.
+ </li>
+</ul>
+<p>The following is a sample of the output from the tool:</p>
+<pre>
+$ layoutopt samples/
+samples/compound.xml
+ 7:23 The root-level <FrameLayout/> can be replaced with <merge/>
+ 11:21 This LinearLayout layout or its FrameLayout parent is useless
+samples/simple.xml
+ 7:7 The root-level <FrameLayout/> can be replaced with <merge/>
+samples/too_deep.xml
+ -1:-1 This layout has too many nested layouts: 13 levels, it should have <= 10!
+ 20:81 This LinearLayout layout or its LinearLayout parent is useless
+ 24:79 This LinearLayout layout or its LinearLayout parent is useless
+ 28:77 This LinearLayout layout or its LinearLayout parent is useless
+ 32:75 This LinearLayout layout or its LinearLayout parent is useless
+ 36:73 This LinearLayout layout or its LinearLayout parent is useless
+ 40:71 This LinearLayout layout or its LinearLayout parent is useless
+ 44:69 This LinearLayout layout or its LinearLayout parent is useless
+ 48:67 This LinearLayout layout or its LinearLayout parent is useless
+ 52:65 This LinearLayout layout or its LinearLayout parent is useless
+ 56:63 This LinearLayout layout or its LinearLayout parent is useless
+samples/too_many.xml
+ 7:413 The root-level <FrameLayout/> can be replaced with <merge/>
+ -1:-1 This layout has too many views: 81 views, it should have <= 80!
+samples/useless.xml
+ 7:19 The root-level <FrameLayout/> can be replaced with <merge/>
+ 11:17 This LinearLayout layout or its FrameLayout parent is useless
+</pre>
diff --git a/docs/html/tools/debugging/index.jd b/docs/html/tools/debugging/index.jd
new file mode 100644
index 0000000..45fbc9e
--- /dev/null
+++ b/docs/html/tools/debugging/index.jd
@@ -0,0 +1,186 @@
+page.title=Debugging
+@jd:body
+
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#stack">Debugging Environment</a></li>
+
+ <li><a href="#addltools">Additional Debugging Tools</a></li>
+
+ <li><a href="#tips">Debugging Tips</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The Android SDK provides most of the tools that you need to debug your applications. You need
+ a JDWP-compliant debugger if you want to be able to do things such as step through code,
+ view variable values, and pause execution of an application. If you are using Eclipse, a
+ JDWP-compliant debugger is already included and there is no setup required. If you are using
+ another IDE, you can use the debugger that comes with it and attach the debugger to a special
+ port so it can communicate with the application VMs on your devices. The main components that
+ comprise a typical Android debugging environment are:</p>
+
+ <dl>
+ <dt><a href="{@docRoot}tools/help/adb.html"><strong>adb</strong></a></dt>
+
+ <dd><code>adb</code> acts as a middleman between a device and your development system. It provides various
+ device management capabilities, including moving and syncing files to the emulator, running a
+ UNIX shell on the device or emulator, and providing a general means to communicate with
+ connected emulators and devices.</dd>
+
+ <dt><a href="{@docRoot}tools/debugging/ddms.html"><strong>Dalvik Debug Monitor
+ Server</strong></a></dt>
+
+ <dd>DDMS is a graphical program that communicates with your devices through <code>adb</code>. DDMS can
+ capture screenshots, gather thread and stack information, spoof incoming calls and SMS
+ messages, and has many other features.</dd>
+
+ <dt><strong><a href="{@docRoot}tools/device.html">Device</a> or
+ <a href="{@docRoot}tools/devices/index.html">Android Virtual Device</a></strong></dt>
+
+ <dd>Your application must run in a device or in an AVD so that it can be debugged. An <code>adb</code> device
+ daemon runs on the device or emulator and provides a means for the <code>adb</code> host daemon to
+ communicate with the device or emulator.</dd>
+
+ <dt><strong>JDWP debugger</strong></dt>
+
+ <dd>The Dalvik VM (Virtual Machine) supports the JDWP protocol to allow debuggers to attach to
+ a VM. Each application runs in a VM and exposes a unique port that you can attach a debugger to
+ via DDMS. If you want to debug multiple applications, attaching to each port might become
+ tedious, so DDMS provides a port forwarding feature that can forward a specific VM's debugging
+ port to port 8700. You can switch freely from application to application by highlighting it in the
+ Devices tab of DDMS. DDMS forwards the appropriate port to port 8700. Most modern Java IDEs include a JDWP debugger,
+ or you can use a command line debugger such as <a href="http://download.oracle.com/javase/6/docs/technotes/tools/">
+ <code>jdb</code></a>.</dd>
+ </dl>
+
+ <h2>Debugging Environment</h2>
+
+ <p>Figure 1 shows how the various debugging tools work together in a typical
+ debugging environment.</p>
+ <img src="{@docRoot}images/debugging.png"
+ alt="Debugging workflow" />
+ <p class="img-caption><strong>Figure 1. </strong> Debugging Workflow</p>
+
+ <p>On your emulator or device, each application runs in its own instance of a Dalvik VM. The <code>adb</code>
+ device daemon allows communication with the VMs from an outside party.</p>
+
+ <p>On your development machine, the <code>adb</code> host daemon communicates with the <code>adb</code> device daemon and
+ allows tools such as DDMS to communicate with the device or emulator. The <code>adb</code> host daemon also
+ allows you to access shell commands on the device as well as providing capabilities such as
+ application installation and file transferring.</p>
+
+ <p>Each application VM on the device or emulator exposes a debugging port that you can attach to
+ via DDMS. DDMS can forward any of these ports to a static debugging port (typically port 8700) by
+ selecting the application that you want to debug in the DDMS user interface. A JDWP debugger can
+ attach to this static debugging port and debug all the applications that are running on the
+ device or emulator without having to attach to multiple ports.</p>
+
+ <p>If you are using Eclipse, much of these interconnections are hidden from you. DDMS, <code>adb</code>, and a
+ JDWP debugger are all setup for you and you can access them through the Debug and DDMS
+ perspectives in Eclipse. If you are developing in a non-Eclipse environment, you have to invoke
+ these tools manually.</p>
+
+ <h2 id="addltools">Additional Debugging Tools</h2>
+
+ <p>In addition to the main debugging tools, the Android SDK provides additional tools to help you
+ debug and profile your applications:</p>
+
+ <dl>
+ <dt><strong><a href="{@docRoot}tools/debugging/debugging-ui.html">Heirarchy Viewer
+ and layoutopt</a></strong></dt>
+
+ <dd>Graphical programs that let you debug and profile user interfaces.</dd>
+
+ <dt><strong><a href=
+ "{@docRoot}tools/debugging/debugging-tracing.html">Traceview</a></strong></dt>
+
+ <dd>A graphical viewer that displays trace file data for method calls and times saved by your
+ application, which can help you profile the performance of your application.</dd>
+
+ <dt><strong><a href="{@docRoot}tools/debugging/debugging-devtools.html">Dev Tools
+ Android application</a></strong></dt>
+
+ <dd>The Dev Tools application included in the emulator system image exposes several settings
+ that provide useful information such as CPU usage and frame rate. You can also transfer the
+ application to a hardware device.</dd>
+ </dl>
+
+
+ <h2 id="tips">Debugging Tips</h2>
+
+<p>While debugging, keep these helpful tips in mind to help you figure out common problems with your
+applications:</p>
+
+<dl>
+<dt><strong>Dump the stack trace</strong></dt>
+<dd>To obtain a stack dump from emulator, you can log
+in with <code>adb shell</code>, use <code>ps</code> to find the process you
+want, and then <code>kill -3</code>. The stack trace appears in the log file.
+</dd>
+
+<dt><strong>Display useful info on the emulator screen</strong></dt>
+<dd>The device can display useful information such as CPU usage or highlights
+around redrawn areas. Turn these features on and off in the developer settings
+window as described in <a href="{@docRoot}tools/debugging/debugging-devtools.html">
+Debugging with the Dev Tools App</a>.
+</dd>
+
+<dt><strong>Get application and system state information from the emulator</strong></dt>
+<dd>You can access dumpstate information from the <code>adb shell</code> commands. See
+<a href="{@docRoot}tools/help/adb.html#dumpsys">dumpsys and
+dumpstate</a> on the adb topic page.</dd>
+
+
+
+<dt><strong>Get wireless connectivity information</strong></dt>
+<dd>You can get information about wireless connectivity using DDMS.
+From the <strong>Device</strong> menu, select <strong>Dump
+radio state</strong>.</dd>
+
+<dt><strong>Log trace data</strong></dt>
+<dd>You can log method calls and other tracing data in an activity by calling
+{@link android.os.Debug#startMethodTracing(String) startMethodTracing()}. See <a
+href="{@docRoot}tools/debugging/debugging-tracing.html">Profiling with Traceview and
+dmtracedump</a> for details. </dd>
+
+<dt><strong>Log radio data</strong></dt>
+<dd>By default, radio information is not logged to the system (it is a lot of
+data). However, you can enable radio logging using the following commands:
+
+<pre class="no-pretty-print">
+adb shell
+logcat -b radio
+</pre>
+</dd>
+
+<dt><strong>Capture screenshots</strong></dt>
+<dd>The Dalvik Debug Monitor Server (DDMS) can capture screenshots from the emulator. Select
+<strong>Device > Screen capture</strong>.</dd>
+
+<dt><strong>Use debugging helper classes</strong></dt>
+<dd>Android provides debug helper classes such as {@link android.util.Log
+ util.Log} and {@link android.os.Debug} for your convenience. </dd>
+
+<dt><strong>Garbage collection</strong></dt>
+<dd>
+The debugger and garbage collector are currently loosely integrated. The VM guarantees that any
+object the debugger is aware of is not garbage collected until after the debugger disconnects.
+This can result in a buildup of objects over time while the debugger is connected. For example,
+if the debugger sees a running thread, the associated {@link java.lang.Thread} object is not
+garbage collected even after the thread terminates.
+</dd>
+
+</dl>
+
+
+
+
+
+
+
+
diff --git a/docs/html/tools/device.jd b/docs/html/tools/device.jd
new file mode 100644
index 0000000..d5fd581
--- /dev/null
+++ b/docs/html/tools/device.jd
@@ -0,0 +1,267 @@
+page.title=Using Hardware Devices
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#setting-up">Setting up a Device for Development</a>
+ <ol>
+ <li><a href="#VendorIds">USB Vendor IDs</a></li>
+ </ol>
+ </li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}sdk/win-usb.html">Google USB Driver</a></li>
+ <li><a href="{@docRoot}tools/extras/oem-usb.html">OEM USB Drivers</a></li>
+ </ol>
+</div>
+</div>
+
+<p>When building a mobile application, it's important that you always test your application on a
+real device before releasing it to users. This page describes how to set up your development
+environment and Android-powered device for testing and debugging on the device.</p>
+
+<p>You can use any Android-powered device as an environment for running,
+debugging, and testing your applications. The tools included in the SDK make it easy to install and
+run your application on the device each time you compile. You can install your application on the
+device directly from Eclipse or from the command line with ADB. If
+you don't yet have a device, check with the service providers in your area to determine which
+Android-powered devices are available.</p>
+
+<p>If you want a SIM-unlocked phone, then you might consider the Google Nexus S. To find a place
+to purchase the Nexus S and other Android-powered devices, visit <a
+href="http://www.google.com/phone/detail/nexus-s">google.com/phone</a>.</p>
+
+<p class="note"><strong>Note:</strong> When developing on a device, keep in mind that you should
+still use the <a
+href="{@docRoot}tools/devices/emulator.html">Android emulator</a> to test your
+application
+on configurations that are not equivalent to those of your real device. Although the emulator
+does not allow you to test every device feature (such as the accelerometer), it does
+allow you to verify that your application functions properly on different versions of the Android
+platform, in different screen sizes and orientations, and more.</p>
+
+
+<h2 id="setting-up">Setting up a Device for Development</h2>
+
+<p>With an Android-powered device, you can develop and debug your Android applications just as you
+would on the emulator. Before you can start, there are just a few things to do:</p>
+
+<ol>
+ <li>Declare your application as "debuggable" in your Android Manifest.
+ <p>When using Eclipse, you can skip this step, because running your app directly from
+the Eclipse IDE automatically enables debugging.</p>
+ <p>In the <code>AndroidManifest.xml</code> file, add <code>android:debuggable="true"</code> to
+the <code><application></code> element.</p>
+ <p class="note"><strong>Note:</strong> If you manually enable debugging in the manifest
+ file, be sure to disable it before you build for release (your published application
+should usually <em>not</em> be debuggable).</p></li>
+ <li>Turn on "USB Debugging" on your device.
+ <p>On the device, go to <strong>Settings > Applications > Development</strong>
+ and enable <strong>USB debugging</strong>
+ (on an Android 4.0 device, the setting is
+located in <strong>Settings > Developer options</strong>).</p>
+ </li>
+ <li>Set up your system to detect your device.
+ <ul>
+ <li>If you're developing on Windows, you need to install a USB driver for adb. For an
+installation guide and links to OEM drivers, see the <a href="{@docRoot}tools/extras/oem-usb.html">OEM USB
+Drivers</a> document.</li>
+ <li>If you're developing on Mac OS X, it just works. Skip this step.</li>
+ <li>If you're developing on Ubuntu Linux, you need to add a
+<code>udev</code> rules file that contains a USB configuration for each type of device
+you want to use for development. In the rules file, each device manufacturer
+is identified by a unique vendor ID, as specified by the
+<code>ATTR{idVendor}</code> property. For a list of vendor IDs, see <a
+href="#VendorIds">USB Vendor IDs</a>, below. To set up device detection on
+Ubuntu Linux:
+
+ <ol type="a">
+ <li>Log in as root and create this file:
+ <code>/etc/udev/rules.d/51-android.rules</code></span>.
+ <p>Use this format to add each vendor to the file:<br/>
+ <code>SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", MODE="0666", GROUP="plugdev"</code>
+ <br /><br />
+
+ In this example, the vendor ID is for HTC. The <code>MODE</code>
+assignment specifies read/write permissions, and <code>GROUP</code> defines
+which Unix group owns the device node. </p>
+
+ <p class="note"><strong>Note:</strong> The rule syntax
+may vary slightly depending on your environment. Consult the <code>udev</code>
+documentation for your system as needed. For an overview of rule syntax, see
+this guide to <a
+href="http://www.reactivated.net/writing_udev_rules.html">writing udev
+rules</a>.</p>
+ </li>
+ <li>Now execute:<br/>
+ <code>chmod a+r /etc/udev/rules.d/51-android.rules</code>
+ </li>
+ </ol>
+ </li>
+ </ul>
+ </li>
+</ol>
+
+<p>When plugged in over USB, can verify that your device is connected by executing <code>adb
+devices</code> from your SDK {@code platform-tools/} directory. If connected,
+you'll see the device name listed as a "device."</p>
+
+<p>If using Eclipse, run or debug your application as usual. You will be
+presented with a <b>Device Chooser</b> dialog that lists the available
+emulator(s) and connected device(s). Select the device upon which you want to
+install and run the application.</p>
+
+<p>If using the <a href="{@docRoot}tools/help/adb.html">Android
+Debug Bridge</a> (adb), you can issue commands with the <code>-d</code> flag to
+target your connected device.</p>
+
+<h3 id="VendorIds">USB Vendor IDs</h3>
+
+<p>This table provides a reference to the vendor IDs needed in order to add USB
+device support on Linux. The USB Vendor ID is the value given to the
+<code>ATTR{idVendor}</code> property in the rules file, as described
+above.</p>
+
+<table>
+ <tr>
+ <th>Company</th><th>USB Vendor ID</th></tr>
+ <tr>
+ <td>Acer</td>
+ <td><code>0502</code></td>
+ </tr>
+ <tr>
+ <td>ASUS</td>
+ <td><code>0b05</code></td>
+ </tr>
+ <tr>
+ <td>Dell</td>
+ <td><code>413c</code></td>
+ </tr>
+ <tr>
+ <td>Foxconn</td>
+ <td><code>0489</code></td>
+ </tr>
+ <tr>
+ <td>Fujitsu</td>
+ <td><code>04c5</code></td>
+ </tr>
+ <tr>
+ <td>Fujitsu Toshiba</td>
+ <td><code>04c5</code></td>
+ </tr>
+ <tr>
+ <td>Garmin-Asus</td>
+ <td><code>091e</code></td>
+ </tr>
+ <tr>
+ <td>Google</td>
+ <td><code>18d1</code></td>
+ </tr>
+ <tr>
+ <td>Hisense</td>
+ <td><code>109b</code></td>
+ </tr>
+ <tr>
+ <td>HTC</td>
+ <td><code>0bb4</code></td>
+ </tr>
+ <tr>
+ <td>Huawei</td>
+ <td><code>12d1</code></td>
+ </tr>
+ <tr>
+ <td>K-Touch</td>
+ <td><code>24e3</code></td>
+ </tr>
+ <tr>
+ <td>KT Tech</td>
+ <td><code>2116</code></td>
+ </tr>
+ <tr>
+ <td>Kyocera</td>
+ <td><code>0482</code></td>
+ </tr>
+ <tr>
+ <td>Lenovo</td>
+ <td><code>17ef</code></td>
+ </tr>
+ <tr>
+ <td>LG</td>
+ <td><code>1004</code></td>
+ </tr>
+ <tr>
+ <td>Motorola</td>
+ <td><code>22b8</code></td>
+ </tr>
+ <tr>
+ <td>NEC</td>
+ <td><code>0409</code></td>
+ </tr>
+ <tr>
+ <td>Nook</td>
+ <td><code>2080</code></td>
+ </tr>
+ <tr>
+ <td>Nvidia</td>
+ <td><code>0955</code></td>
+ </tr>
+ <tr>
+ <td>OTGV</td>
+ <td><code>2257</code></td>
+ </tr>
+ <tr>
+ <td>Pantech</td>
+ <td><code>10a9</code></td>
+ </tr>
+ <tr>
+ <td>Pegatron</td>
+ <td><code>1d4d</code></td>
+ </tr>
+ <tr>
+ <td>Philips</td>
+ <td><code>0471</code></td>
+ </tr>
+ <tr>
+ <td>PMC-Sierra</td>
+ <td><code>04da</code></td>
+ </tr>
+ <tr>
+ <td>Qualcomm</td>
+ <td><code>05c6</code></td>
+ </tr>
+ <tr>
+ <td>SK Telesys</td>
+ <td><code>1f53</code></td>
+ </tr>
+ <tr>
+ <td>Samsung</td>
+ <td><code>04e8</code></td>
+ </tr>
+ <tr>
+ <td>Sharp</td>
+ <td><code>04dd</code></td>
+ </tr>
+ <tr>
+ <td>Sony</td>
+ <td><code>054c</code></td>
+ </tr>
+ <tr>
+ <td>Sony Ericsson</td>
+ <td><code>0fce</code></td>
+ </tr>
+ <tr>
+ <td>Teleepoch</td>
+ <td><code>2340</code></td>
+ </tr>
+ <tr>
+ <td>Toshiba</td>
+ <td><code>0930</code></td>
+ </tr>
+ <tr>
+ <td>ZTE</td>
+ <td><code>19d2</code></td>
+ </tr>
+</table>
diff --git a/docs/html/tools/devices/emulator.jd b/docs/html/tools/devices/emulator.jd
new file mode 100644
index 0000000..cee6473
--- /dev/null
+++ b/docs/html/tools/devices/emulator.jd
@@ -0,0 +1,1571 @@
+page.title=Using the Android Emulator
+parent.title=Managing Virtual Devices
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#overview">Overview</a></li>
+ <li><a href="#avds">Android Virtual Devices and the Emulator</a></li>
+ <li><a href="#starting">Starting and Stopping the Emulator</a></li>
+ <li><a href="#apps">Installing Applications on the Emulator</a></li>
+ <li><a href="#acceleration">Using Hardware Acceleration</a>
+ <ol>
+ <li><a href="#accel-graphics">Configuring Graphics Acceleration</a></li>
+ <li><a href="#accel-vm">Configuring Virtual Machine Acceleration</a></li>
+ </ol>
+ </li>
+ <li><a href="#sdcard">SD Card Emulation</a>
+ <ol>
+ <li><a href="#sdcard-creating">Creating an SD card image</a></li>
+ <li><a href="#sdcard-files">Copying files to an SD card image</a></li>
+ <li><a href="#sdcard-loading">Loading an SD card image</a></li>
+ </ol>
+ </li>
+ <li><a href="#diskimages">Working with Emulator Disk Images</a>
+ <ol>
+ <li><a href="#defaultimages">Default image files</a></li>
+ <li><a href="#runtimeimages">Runtime images: user data and SD card</a></li>
+ <li><a href="#temporaryimages">Temporary images</a></li>
+ </ol>
+ </li>
+ <li><a href="#emulatornetworking">Emulator Networking</a>
+ <ol>
+ <li><a href="#networkaddresses">Network Address Space</a></li>
+ <li><a href="#networkinglimitations">Local Networking Limitations</a></li>
+ <li><a href="#redirection">Using Network Redirection</a></li>
+ <li><a href="#dns">Configuring the Emulator's DNS Settings</a></li>
+ <li><a href="#proxy">Using the Emulator with a Proxy</a></li>
+ <li><a href="#connecting">Interconnecting Emulator Instances</a></li>
+ <li><a href="#calling">Sending a Voice Call or SMS to Another Emulator Instance</a></li>
+ </ol>
+ </li>
+ <li><a href="#console">Using the Emulator Console</a>
+ <ol>
+ <li><a href="#portredirection">Port Redirection</a></li>
+ <li><a href="#geo">Geo Location Provider Emulation</a></li>
+ <li><a href="#events">Hardware Events Emulation</a></li>
+ <li><a href="#power">Device Power Characteristics</a></li>
+ <li><a href="#netstatus">Network Status</a></li>
+ <li><a href="#netdelay">Network Delay Emulation</a></li>
+ <li><a href="#netspeed">Network Speed Emulation</a></li>
+ <li><a href="#telephony">Telephony Emulation</a></li>
+ <li><a href="#sms">SMS Emulation</a></li>
+ <li><a href="#vm">VM State</a></li>
+ <li><a href="#window">Emulator Window</a></li>
+ <li><a href="#terminating">Terminating an Emulator Instance</a></li>
+ </ol>
+ </li>
+ <li><a href="#limitations">Emulator Limitations</a></li>
+ <li><a href="#troubleshooting">Troubleshooting Emulator Problems</a></li>
+ </ol>
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/help/emulator.html">Android Emulator</a></li>
+ <li><a href="{@docRoot}tools/devices/managing-avds.html">Managing AVDs with AVD Manager</a></li>
+ </ol>
+</div>
+</div>
+
+<p>The Android SDK includes a virtual mobile device emulator
+that runs on your computer. The emulator lets you prototype, develop and test
+Android applications without using a physical device. </p>
+
+<p>The Android emulator mimics all of the hardware and software features
+of a typical mobile device, except that it cannot place actual phone
+calls. It provides a variety of navigation and control keys, which you can "press"
+using your mouse or keyboard to generate events for your application. It also
+provides a screen in which your application is displayed, together with any other
+active Android applications. </p>
+
+<img src="{@docRoot}images/emulator-wvga800l.png" width="367" height="349" />
+
+<p>To let you model and test your application more easily, the emulator utilizes
+Android Virtual Device (AVD) configurations. AVDs let you define certain hardware
+aspects of your emulated phone and allow you to create many configurations to test
+many Android platforms and hardware permutations. Once your application is running on
+the emulator, it can use the services of the Android platform to invoke other
+applications, access the network, play audio and video, store and retrieve data,
+notify the user, and render graphical transitions and themes. </p>
+
+<p>The emulator also includes a variety of debug capabilities, such as a console
+from which you can log kernel output, simulate application interrupts (such as
+arriving SMS messages or phone calls), and simulate latency effects and dropouts
+on the data network.</p>
+
+
+
+<h2 id="overview">Overview</h2>
+
+<p>The Android emulator is an application that provides a virtual
+mobile device on which you can run your Android applications. It runs a full
+Android system stack, down to the kernel level, that includes a set of
+preinstalled applications (such as the dialer) that you can access from your
+applications. You can choose what version of the Android system you want to
+run in the emulator by configuring AVDs, and you can also customize the
+mobile device skin and key mappings. When launching the emulator and at runtime,
+you can use a variety of commands and options to control its behavior.
+</p>
+
+<p>The Android system images available through the Android SDK Manager contain
+code for the Android Linux kernel, the native libraries, the Dalvik VM, and the
+various Android packages (such as the Android framework and preinstalled
+applications). The emulator provides dynamic binary translation of device
+machine code to the OS and processor architecture of your development
+machine.</p>
+
+<p>The Android emulator supports many hardware features likely to be found on
+mobile devices, including: </p>
+
+<ul>
+ <li>An ARMv5 CPU and the corresponding memory-management unit (MMU)</li>
+ <li>A 16-bit LCD display</li>
+ <li>One or more keyboards (a Qwerty-based keyboard and associated Dpad/Phone
+buttons)</li>
+ <li>A sound chip with output and input capabilities</li>
+ <li>Flash memory partitions (emulated through disk image files on the
+development machine)</li>
+ <li>A GSM modem, including a simulated SIM Card</li>
+ <li>A camera, using a webcam connected to your development computer.</li>
+ <li>Sensors like an accelerometer, using data from a USB-connected Android device.</li>
+</ul>
+
+<p>The following sections describe the emulator and its use for development of Android
+applications in more detail.</p>
+
+
+<h2 id="avds">Android Virtual Devices and the Emulator</h2>
+
+<p>To use the emulator, you first must create one or more AVD configurations. In each
+configuration, you specify an Android platform to run in the emulator and the set of hardware
+options and emulator skin you want to use. Then, when you launch the emulator, you specify
+the AVD configuration that you want to load. </p>
+
+<p>Each AVD functions as an independent device, with its own private storage for
+user data, SD card, and so on. When you launch the emulator with an AVD configuration,
+it automatically loads the user data and SD card data from the AVD directory. By default,
+the emulator stores the user data, SD card data, and cache in the AVD directory.</p>
+
+<p>To create and manage AVDs you use the AVD Manager UI or the <code>android</code> tool
+that is included in the SDK.
+For complete information about how to set up AVDs, see <a
+href="{@docRoot}tools/devices/index.html">Managing Virtual Devices</a>.</p>
+
+
+<h2 id="starting">Starting and Stopping the Emulator</h2>
+
+<p>During development and testing of your application, you install and run your
+application in the Android emulator. You can launch the emulator as a standalone
+application from a command line, or you can run it from within your Eclipse
+development environment. In either case, you specify the AVD configuration to
+load and any startup options you want to use, as described in this document.
+</p>
+
+<p>You can run your application on a single instance of the emulator or,
+depending on your needs, you can start multiple emulator instances and run your
+application in more than one emulated device. You can use the emulator's
+built-in commands to simulate GSM phone calling or SMS between emulator
+instances, and you can set up network redirection that allows emulators to send
+data to one another. For more information, see <a href="#telephony">Telephony
+Emulation</a>, <a href="#sms">SMS Emulation</a>, and
+<a href="#emulatornetworking">Emulator Networking</a></p>
+
+<p>To start an instance of the emulator from the command line, navigate to the
+<code>tools/</code> folder of the SDK. Enter <code>emulator</code> command
+like this: </p>
+
+<pre>emulator -avd <avd_name> [<options>]</pre>
+
+<p>This initializes the emulator, loads an AVD configuration and displays the emulator
+window. For more information about command line options for the emulator, see the
+<a href="{@docRoot}tools/help/emulator.html">Android Emulator</a> tool reference.</p>
+
+<p class="note"><strong>Note:</strong> You can run multiple
+instances of the emulator concurrently, each with its own AVD configuration and
+storage area for user data, SD card, and so on.</p>
+
+<p>If you are working in Eclipse, the ADT plugin for Eclipse installs your
+application and starts the emulator automatically, when you run or debug
+the application. You can specify emulator startup options in the Run/Debug
+dialog, in the Target tab. When the emulator is running, you can issue
+console commands as described later in this document.</p>
+
+<p>If you are not working in Eclipse, see <a href="#apps">Installing Applications
+on the Emulator</a> for information about how to install your application.</p>
+
+<p>To stop an emulator instance, just close the emulator's window.</p>
+
+<p>For a reference of the emulator's startup commands and keyboard mapping, see
+the <a href="{@docRoot}tools/help/emulator.html">Android Emulator</a> tool
+reference.</p>
+
+
+<h2 id="apps">Installing Applications on the Emulator</h2>
+
+<p>If you don't have access to Eclipse or the ADT Plugin, you can install your application on the
+emulator using the <a href="{@docRoot}tools/help/adb.html#move">adb</a> utility. Before
+installing the application, you need to build and package it into an <code>.apk</code> as described
+in <a href="{@docRoot}tools/building/index.html">Building and
+Running Apps</a>. Once the application is installed, you can start the emulator from the command
+line as described previously, using any startup options necessary.
+When the emulator is running, you can also connect to the emulator instance's
+<a href="#console">console</a> to issue commands as needed.</p>
+
+<p>As you update your code, you periodically package and install it on the emulator.
+The emulator preserves the application and its state data across restarts,
+in a user-data disk partition. To ensure that the application runs properly
+as you update it, you may need to delete the emulator's user-data partition.
+To do so, start the emulator with the <code>-wipe-data</code> option.
+For more information about the user-data partition and other emulator storage,
+see <a href="#diskimages">Working with Emulator Disk Images</a>.</p>
+
+
+<h2 id="acceleration">Using Hardware Acceleration</h2>
+
+<p>In order to make the Android emulator run faster and be more responsive, you can configure it to
+take advantage of hardware acceleration, using a combination of configuration options, specific
+Android system images and hardware drivers.</p>
+
+
+<h3 id="accel-graphics">Configuring Graphics Acceleration</h3>
+
+<p class="caution"><strong>Caution:</strong> As of SDK Tools Revision 17, the graphics
+acceleration feature for the emulator is experimental; be alert for incompatibilities and
+errors when using this feature. </p>
+
+<p>Graphics acceleration for the emulator takes advantage of your development computer's graphics
+hardware, specifically its graphics processing unit (GPU), to make screen drawing faster. To use
+the graphics acceleration feature, you must have the following versions of the Android development
+tools installed:</p>
+
+<ul>
+ <li>Android SDK Tools, Revision 17 or higher</li>
+ <li>Android SDK Platform API 15, Revision 3 or higher</li>
+</ul>
+
+<p>Use the <a href="{@docRoot}sdk/installing/index.html#AddingComponents">Android SDK
+Manager</a> to install these components:</p>
+
+<p class="note"><strong>Note:</strong> Not all applications are compatible with graphics hardware
+acceleration. In particular, the Browser application and applications using the {@link
+android.webkit.WebView} component are not compatible with graphics acceleration.</p>
+
+<p>To configure an AVD to use graphics acceleration:</p>
+
+<ol>
+ <li>Make sure you have the required SDK components installed (listed above).</li>
+ <li>Start the AVD Manager and create a new AVD with the <strong>Target</strong> value of
+<strong>Android 4.0.3 (API Level 15)</strong>, revision 3 or higher.</li>
+ <li>If you want to have graphics acceleration enabled by default for this AVD, in the
+<strong>Hardware</strong> section, click <strong>New</strong>, select <strong>GPU emulation</strong>
+and set the value to <strong>Yes</strong>.
+ <p class="note"><strong>Note:</strong> You can also enable graphics acceleration when you
+start an emulator using command line options as describe in the next section.</p>
+ </li>
+ <li>Name the AVD instance and select any other configuration options.
+ <p class="caution"><strong>Caution:</strong> Do not select the <strong>Snapshot: Enabled</strong>
+option. Snapshots are not supported for emulators with graphics acceleration enabled.</p>
+ </li>
+ <li>Click <strong>Create AVD</strong> to save the emulator configuration.</li>
+</ol>
+
+<p>If you set <strong>GPU emulation</strong> to <strong>Yes</strong> for your AVD, then graphics
+acceleration is automatically enabled when you run it. If you did not enable <strong>GPU
+emulation</strong> when you created the AVD, you can still enable it at runtime.</p>
+
+<p>To enable graphics acceleration at runtime for an AVD:</p>
+
+<ul>
+ <li>If you are running the emulator from the command line, just include the {@code -gpu on}
+option:
+<pre>emulator -avd <avd_name> -gpu on</pre>
+ <p class="note"><strong>Note:</strong> You must specify an AVD configuration that uses
+Android 4.0.3 (API Level 15, revision 3) or higher system image target. Graphics acceleration is not
+available for earlier system images.</p>
+ </li>
+ <li>If you are running the emulator from Eclipse, run your Android application using an AVD with
+the {@code -gpu on} option enabled:
+ <ol>
+ <li>In Eclipse, click your Android project folder and then select <strong>Run > Run
+Configurations...</strong></li>
+ <li>In the left panel of the <strong>Run Configurations</strong> dialog, select your Android
+project run configuration or create a new configuration.</li>
+ <li>Click the <strong>Target</strong> tab.</li>
+ <li>Select the AVD you created in the previous procedure.</li>
+ <li>In the <strong>Additional Emulator Command Line Options</strong> field, enter:<br>
+ {@code -gpu on}</li>
+ <li>Run your Android project using this run configuration.</li>
+ </ol>
+ </li>
+</ul>
+
+
+<h3 id="accel-vm">Configuring Virtual Machine Acceleration</h2>
+
+<p class="caution"><strong>Caution:</strong> As of SDK Tools Revision 17, the virtual machine
+acceleration feature for the emulator is experimental; be alert for incompatibilities and errors
+when using this feature.</p>
+
+<p>Many modern CPUs provide extensions for running virtual machines (VMs) more efficiently. Taking
+advantage of these extensions with the Android emulator requires some additional configuration of
+your development system, but can significantly improve the execution speed. Before attempting to use
+this type of acceleration, you should first determine if your development system’s CPU supports one
+of the following virtualization extensions technologies:</p>
+
+<ul>
+ <li>Intel Virtualization Technology (VT, VT-x, vmx) extensions</li>
+ <li>AMD Virtualization (AMD-V, SVM) extensions (only supported for Linux)</li>
+</ul>
+
+<p>The specifications from the manufacturer of your CPU should indicate if it supports
+virtualization extensions. If your CPU does not support one of these virtualization technologies,
+then you cannot use virtual machine acceleration.</p>
+
+<p class="note"><strong>Note:</strong> Virtualization extensions are typically enabled through
+your computer's BIOS and are frequently turned off by default. Check the documentation for your
+system's motherboard to find out how to enable virtualization extensions.</p>
+
+<p>Once you have determined that your CPU supports virtualization extensions, make sure you can work
+within these additional requirements of running an emulator inside an accelerated virtual
+machine:</p>
+
+<ul>
+ <li><strong>x86 AVD Only</strong> - You must use an AVD that is uses an x86 system image target.
+AVDs that use ARM-based system images cannot be accelerated using the emulator configurations
+described here.</li>
+ <li><strong>Not Inside a VM</strong> - You cannot run a VM-accelerated emulator inside another
+virtual machine, such as a VirtualBox or VMWare-hosted virtual machine. You must run the emulator
+directly on your system hardware.</li>
+ <li><strong>Other VM Drivers</strong> - If you are running another virtualization technology on
+your system such as VirtualBox or VMWare, you may need to unload the driver for that virtual machine
+hosting software before running an accelerated emulator.</li>
+ <li><strong>OpenGL® Graphics</strong> - Emulation of OpenGL ES graphics may not perform at the
+same level as an actual device.</li>
+</ul>
+
+<p>To use virtual machine acceleration with the emulator, you need the following version of Android
+development tools. Use the <a href="{@docRoot}sdk/installing/index.html#AddingComponents">Android SDK
+Manager</a> to install these components:</p>
+
+<ul>
+ <li>Android SDK Tools, Revision 17 or higher</li>
+ <li>Android x86-based system image</li>
+</ul>
+
+<p>If your development environment meets all of the requirements for running a VM-accelerated
+emulator, you can use the AVD Manager to create an x86-based AVD configuration:</p>
+
+<ol>
+ <li>In the Android SDK Manager, make sure you have an x86-based <strong>System Image</strong>
+ installed for your target Android version. If you do not have an x86 <strong>System
+ Image</strong> installed, select one in the Android SDK Manager and install it.
+ <p class="note"><strong>Tip:</strong> System images are listed under each API Level in the SDK
+ Manager. An x86 system image may not be available for all API levels.</p>
+ </li>
+ <li>Start the AVD Manager and create a new AVD with an x86 value for the
+<strong>CPU/ABI</strong> field. You may need to select a specific <strong>Target</strong> value, or
+select a <strong>Target</strong> value and then select a specific <strong>CPU/ABI</strong>
+option.</li>
+ <li>Name the emulator instance and select any other configuration options.</li>
+ <li>Click <strong>Create AVD</strong> to save the emulator configuration.</li>
+</ol>
+
+<h4 id="vm-windows">Configuring VM Acceleration on Windows</h4>
+
+<p>Virtual machine acceleration for Windows requires the installation of the Intel Hardware
+Accelerated Execution Manager (Intel HAXM). The software requires an Intel CPU with
+Virtualization Technology (VT) support and one of the following operating systems:</p>
+
+<ul>
+ <li>Windows 7 (32/64-bit)</li>
+ <li>Windows Vista (32/64-bit)</li>
+ <li>Windows XP (32-bit only)</li>
+</ul>
+
+<p>To install the virtualization driver:</p>
+
+<ol>
+ <li>Start the Android SDK Manager, select <strong>Extras</strong> and then select <strong>Intel
+Hardware Accelerated Execution Manager</strong>.</li>
+ <li>After the download completes, execute {@code
+<sdk>/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.exe}.</li>
+ <li>Follow the on-screen instructions to complete installation.</li>
+ <li>After installation completes, confirm that the virtualization driver is operating correctly by
+opening a command prompt window and running the following command:
+ <pre>sc query intelhaxm</pre>
+ <p>You should see a status message including the following information:</p>
+<pre>
+SERVICE_NAME: intelhaxm
+ ...
+ STATE : 4 RUNNING
+ ...
+</pre>
+ </li>
+</ol>
+
+<p>To run an x86-based emulator with VM acceleration:</p>
+<ul>
+ <li>If you are running the emulator from the command line, just specify an x86-based AVD:
+<pre>emulator -avd <avd_name></pre>
+ <p class="note"><strong>Note:</strong> You must provide an x86-based AVD configuration
+name, otherwise VM acceleration will not be enabled.</p>
+ </li>
+ <li>If you are running the emulator from Eclipse, run your Android application with an x86-based
+AVD:
+ <ol>
+ <li>In Eclipse, click your Android project folder and then select <strong>Run > Run
+Configurations...</strong></li>
+ <li>In the left panel of the <strong>Run Configurations</strong> dialog, select your Android
+project run configuration or create a new configuration.</li>
+ <li>Click the <strong>Target</strong> tab.</li>
+ <li>Select the x86-based AVD you created previously.</li>
+ <li>Run your Android project using this run configuration.</li>
+ </ol>
+ </li>
+</ul>
+
+<p>You can adjust the amount of memory available to the Intel HAXM kernel extension by re-running
+its installer.</p>
+
+<p>You can stop using the virtualization driver by uninstalling it. Re-run the installer or use
+the Control Panel to remove the software.</p>
+
+
+<h4 id="vm-mac">Configuring VM Acceleration on Mac</h4>
+
+<p>Virtual machine acceleration on a Mac requires the installation of the Intel Hardware Accelerated
+Execution Manager (Intel HAXM) kernel extension to allow the Android emulator to make use of CPU
+virtualization extensions. The kernel extension is compatible with Mac OS X Snow Leopard (version
+10.6.0) and higher.</p>
+
+<p>To install the Intel HAXM kernel extension:</p>
+
+<ol>
+ <li>Start the Android SDK Manager, select <strong>Extras</strong> and then select <strong>Intel
+Hardware Accelerated Execution Manager</strong>.
+ <li>After the download completes, execute
+ {@code <sdk>/extras/intel/Hardware_Accelerated_Execution_Manager/IntelHAXM.dmg}.</li>
+ <li>Double click the <strong>IntelHAXM.mpkg</strong> icon to begin installation.</li>
+ <li>Follow the on-screen instructions to complete installation.</li>
+ <li>After installation completes, confirm that the new kernel extension is operating correctly by
+opening a terminal window and running the following command:
+ <pre>kextstat | grep intel</pre>
+ <p>You should see a status message containing the following extension name, indicating that the
+ kernel extension is loaded:</p>
+ <pre>com.intel.kext.intelhaxm</pre>
+ </li>
+</ol>
+
+<p>To run an x86-based emulator with VM acceleration:</p>
+<ul>
+ <li>If you are running the emulator from the command line, just specify an x86-based AVD:
+<pre>emulator -avd <avd_name></pre>
+ <p class="note"><strong>Note:</strong> You must provide an x86-based AVD configuration
+name, otherwise VM acceleration will not be enabled.</p>
+ </li>
+ <li>If you are running the emulator from Eclipse, run your Android application with an x86-based
+AVD:
+ <ol>
+ <li>In Eclipse, click your Android project folder and then select <strong>Run > Run
+Configurations...</strong></li>
+ <li>In the left panel of the <strong>Run Configurations</strong> dialog, select your Android
+project run configuration or create a new configuration.</li>
+ <li>Click the <strong>Target</strong> tab.</li>
+ <li>Select the x86-based AVD you created previously.</li>
+ <li>Run your Android project using this run configuration.</li>
+ </ol>
+ </li>
+</ul>
+
+<p>You can adjust the amount of memory available to the Intel HAXM kernel extension by re-running
+the installer.</p>
+
+<p>You can stop using the virtualization kernel driver by uninstalling it. Before removing it, shut
+down any running x86 emulators. To unload the virtualization kernel driver, run the following
+command in a terminal window:</p>
+
+<pre>sudo /System/Library/Extensions/intelhaxm.kext/Contents/Resources/uninstall.sh</pre>
+
+<h4 id="vm-linux">Configuring VM Acceleration on Linux</h4>
+
+<p>Linux-based systems support virtual machine acceleration through the KVM software package. Follow
+<a href="https://www.google.com/?q=kvm+installation">instructions for installing KVM</a> on your
+Linux system, and verify that KVM is enabled. In addition to following the installation
+instructions, be aware of these configuration requirements:</p>
+
+<ul>
+ <li>Running KVM requires specific user permissions, make sure you have sufficient permissions
+according to the KVM installation instructions.</li>
+ <li>If you use another virtualization technology in your Linux platform, unload its kernel driver
+before running the x86 emulator. For example, the VirtualBox driver program is {@code vboxdrv}.</li>
+</ul>
+
+<p>To run an x86-based emulator with VM acceleration:</p>
+
+<ul>
+ <li>If you are running the emulator from the command line, start the emulator with an x86-based
+AVD and include the KVM options:
+<pre>emulator -avd <avd_name> -qemu -m 512 -enable-kvm</pre>
+ <p class="note"><strong>Note:</strong> You must provide an x86-based AVD configuration
+name, otherwise VM acceleration will not be enabled.</p>
+ </li>
+ <li>If you are running the emulator from Eclipse, run your Android application with an x86-based
+AVD and include the KVM options:
+ <ol>
+ <li>In Eclipse, click your Android project folder and then select <strong>Run > Run
+Configurations...</strong></li>
+ <li>In the left panel of the <strong>Run Configurations</strong> dialog, select your Android
+project run configuration or create a new configuration.</li>
+ <li>Click the <strong>Target</strong> tab.</li>
+ <li>Select the x86-based AVD you created previously.</li>
+ <li>In the <strong>Additional Emulator Command Line Options</strong> field, enter:
+ <pre>-qemu -m 512 -enable-kvm</pre>
+ </li>
+ <li>Run your Android project using this run configuration.</li>
+ </ol>
+ </li>
+</ul>
+
+<p class="note"><strong>Important:</strong> When using the {@code -qemu} command line option, make sure
+it is the last parameter in your command. All subsequent options are interpreted as qemu-specific
+parameters.</p>
+
+
+<h2 id="sdcard">SD Card Emulation</h2>
+
+<p>You can create a disk image and then load it to the emulator at startup, to
+simulate the presence of a user's SD card in the device. To do this, you can specify
+an SD card image when you create an AVD, or you can use the mksdcard utility included
+in the SDK.</p>
+
+<p>The following sections describe how to create an SD card disk image, how to copy
+files to it, and how to load it in the emulator at startup. </p>
+
+<p>Note that you can only load a disk image at emulator startup. Similarly, you
+can not remove a simulated SD card from a running emulator. However, you can
+browse, send files to, and copy/remove files from a simulated SD card either
+with adb or the emulator. </p>
+
+<p>The emulator supports emulated SDHC cards, so you can create an SD card image
+of any size up to 128 gigabytes.</p>
+
+
+<h3 id="sdcard-creating">Creating an SD card image</h3>
+
+<p>There are several ways of creating an SD card image. The easiest way is to use the
+<strong>AVD Manager</strong> to create a new SD card by specifying a size when you create an AVD.
+You can also use the {@code android} command line tool when creating an AVD. Just add the
+<code>-c</code> option to your command: </p>
+
+<pre>android create avd -n <avd_name> -t <targetID> -c <size>[K|M]</pre>
+
+<p>The <code>-c</code> option can also be used to to specify a path to an SD card
+image for the new AVD. For more information, see <a
+href="{@docRoot}tools/devices/managing-avds-cmdline.html">Managing Virtual Devices
+from the Command Line</a>.
+</p>
+
+<p>You can also use the mksdcard tool, included in the SDK, to create a FAT32 disk
+image that you can load in the emulator at startup. You can access mksdcard in
+the tools/ directory of the SDK and create a disk image like this: </p>
+
+<pre>mksdcard <size> <file></pre>
+
+<p>For example:</p>
+
+<pre>mksdcard 1024M sdcard1.iso</pre>
+
+<p>For more information, see <a
+href="{@docRoot}tools/help/mksdcard.html"><code>mksdcard</code></a>.</p>
+
+
+<h3 id="sdcard-files">Copying files to an SD card image</h3>
+
+<p>Once you have created the disk image, you can copy files to it prior to
+loading it in the emulator. To copy files, you can mount the image as a loop
+device and then copy the files to it, or you can use a utility such as {@code mtools} to
+copy the files directly to the image. The {@code mtools} package is available for Linux,
+Mac, and Windows.</p>
+
+<p>Alternatively, you can use the {@code adb push} command to move files onto an SD card image
+while it is loaded in an emulator. For more information see the <a
+href="{@docRoot}tools/help/adb.html#copyfiles">{@code adb push}</a> documentation.</p>
+
+<h3 id="sdcard-loading">Loading an SD card image</h3>
+
+<p>By default, the emulator loads the SD card image that is stored with the active
+AVD (see the <code>-avd</code> startup option).</p>
+
+<p>Alternatively, you can start the emulator with the
+<code>-sdcard</code> flag and specify the name and path of your image (relative
+to the current working directory): </p>
+
+<pre>emulator -sdcard <filepath></pre>
+
+
+<h2 id="diskimages">Working with Emulator Disk Images</h2>
+
+<p>The emulator uses mountable disk images stored on your development machine to
+simulate flash (or similar) partitions on an actual device. For example, it uses a
+disk image containing an emulator-specific kernel, the Android system, a
+ramdisk image, and writeable images for user data and simulated SD card.</p>
+
+<p>To run properly, the emulator requires access to a specific set of disk image
+files. By default, the Emulator always looks for the disk images in the
+private storage area of the AVD in use. If no images exist there when
+the Emulator is launched, it creates the images in the AVD directory based on
+default versions stored in the SDK. </p>
+
+<p class="note"><strong>Note:</strong> The default storage location for
+AVDs is in <code>~/.android/avd</code> on OS X and Linux, <code>C:\Documents and
+Settings\<user>\.android\</code> on Windows XP, and
+<code>C:\Users\<user>\.android\</code>
+on Windows Vista.</p>
+
+<p>To let you use alternate or custom versions of the image files, the emulator
+provides startup options that override the default locations and filenames of
+the image files. When you use one of these options, the emulator searches for the image
+file under the image name or location that you specify; if it can not locate the
+image, it reverts to using the default names and location.</p>
+
+<p>The emulator uses three types of image files: default image files, runtime
+image files, and temporary image files. The sections below describe how to
+override the location/name of each type of file. </p>
+
+<h3 id="defaultimages">Default image files</h3>
+
+<p>When the emulator launches, but does not find an existing user data image in
+the active AVD's storage area, it creates a new one from a default version
+included in the SDK. The default user data image is read-only. The image
+files are read-only.</p>
+
+<p>The emulator provides the <code>-system <dir></code> startup option to
+let you override the location where the emulator looks for the default
+user data image. </p>
+
+<p>The emulator also provides a startup option that lets you override the name
+of the default user data image, as described in the following table. When you use the
+option, the emulator looks in the default directory, or in a custom location
+(if you specified <code>-system <dir></code>). </p>
+
+
+<table>
+<tr>
+ <th width="10%" >Name</th>
+ <th width="30%" >Description</th>
+ <th width="40%" >Comments</th>
+</tr>
+
+<!--
+<tr>
+ <td><code>kernel-qemu.img</code></td>
+ <td>The emulator-specific Linux kernel image</td>
+ <td>Override using <code>-kernel <file></code></td>
+</tr>
+
+<tr>
+ <td><code>ramdisk.img</code></td>
+ <td>The ramdisk image used to boot the system.</td>
+ <td>Override using <code>-ramdisk <file></code></td>
+</tr>
+
+<tr>
+ <td><code>system.img</code></td>
+ <td>The <em>initial</em> Android system image.</td>
+ <td>Override using <code>-image <file></code></td>
+</tr>
+-->
+<tr>
+ <td><code>userdata.img</code></td>
+ <td>The <em>initial</em> user-data disk image</td>
+ <td>Override using <code>-initdata <file></code>. Also see
+<code>-data <file></code>, below.</td>
+</tr>
+
+</table>
+
+<h3 id="runtimeimages">Runtime images: user data and SD card</h3>
+
+<p>At runtime, the emulator reads and writes data to two disk images: a
+user-data image and (optionally) an SD card image. These images emulate the user-data
+partition and removable storage media on actual device. </p>
+
+<p>The emulator provides a default user-data disk image. At startup, the emulator
+creates the default image as a copy of the system user-data image (user-data.img),
+described above. The emulator stores the new image with the files of the active AVD.</p>
+
+<!--
+<p>The emulator provides a startup option, <code>-datadir <dir></code>,
+that you can use to override the location under which the emulator looks for the runtime
+image files. </p>
+-->
+
+<p>The emulator provides startup options to let you override the actual names and storage
+locations of the runtime images to load, as described in the following table. When you use one
+of these options, the emulator looks for the specified file(s) in the current working directory,
+in the AVD directory, or in a custom location (if you specified a path with the filename). </p>
+
+<table>
+<tr>
+ <th width="10%" >Name</th>
+ <th width="30%" >Description</th>
+ <th width="40%" >Comments</th>
+</tr>
+<tr>
+ <td><code>userdata-qemu.img</code></td>
+ <td>An image to which the emulator writes runtime user-data for a unique user.</td>
+ <td>Override using <code>-data <filepath></code>, where <code><filepath></code> is the
+path the image, relative to the current working directory. If you supply a filename only,
+the emulator looks for the file in the current working directory. If the file at <code><filepath></code> does
+not exist, the emulator creates an image from the default userdata.img, stores it under the name you
+specified, and persists user data to it at shutdown. </td>
+</tr>
+
+<tr>
+ <td><code>sdcard.img</code></td>
+ <td>An image representing an SD card inserted into the emulated device.</td>
+ <td>Override using <code>-sdcard <filepath></code>, where <code><filepath></code> is the
+path the image, relative to the current working directory. If you supply a filename only,
+the emulator looks for the file in the current working directory. </td>
+</tr>
+
+</table>
+
+<h4>User-Data Image</h4>
+
+<p>Each emulator instance uses a writeable user-data image to store user- and
+session-specific data. For example, it uses the image to store a unique user's
+installed application data, settings, databases, and files. </p>
+
+<p>At startup, the emulator attempts to load a user-data image stored during
+a previous session. It looks for the file in the current working directory,
+in the AVD directory described in a previous section and at the custom location/name
+that you specified at startup. </p>
+
+<ul>
+<li>If it finds a user-data image, it mounts the image and makes it available
+to the system for reading and writing of user data. </li>
+<li>If it does not find one, it creates an image by copying the system user-data
+image (userdata.img), described above. At device power-off, the system persists
+the user data to the image, so that it will be available in the next session.
+Note that the emulator stores the new disk image at the location/name that you
+specify in <code>-data</code> startup option.</li>
+</ul>
+
+<p class="note"><strong>Note:</strong> Because of the AVD configurations used in the emulator,
+each emulator instance gets its own dedicated storage. There is no longer a need
+to use the <code>-d</code> option to specify an instance-specific storage area.</p>
+
+<h4>SD Card</h4>
+
+<P>Optionally, you can create a writeable disk image that the emulator can use
+to simulate removeable storage in an actual device. For information about how to create an
+emulated SD card and load it in the emulator, see <a href="#sdcard">SD Card Emulation</a></p>
+
+<p>You can also use the android tool to automatically create an SD Card image
+for you, when creating an AVD. For more information, see <a
+href="{@docRoot}tools/devices/managing-avds.html">Managing Virtual Devices with AVD
+Manager</a>.
+
+
+<h3 id="temporaryimages">Temporary Images</h3>
+
+<p>The emulator creates two writeable images at startup that it deletes at
+device power-off. The images are: </p>
+
+<ul>
+ <li>A writable copy of the Android system image</li>
+ <li>The <code>/cache</code> partition image</li>
+</ul>
+
+<p>The emulator does not permit renaming the temporary system image or
+persisting it at device power-off. </p>
+
+<p>The <code>/cache</code> partition image is initially empty, and is used by
+the browser to cache downloaded web pages and images. The emulator provides an
+<code>-cache <file></code>, which specifies the name of the file in which
+to persist the <code>/cache</code> image at device power-off. If <code><file>
+</code> does not exist, the emulator creates it as an empty file. </p>
+
+<p>You can also disable the use of the cache partition by specifying the
+<code>-nocache</code> option at startup. </p>
+
+
+<h2 id="emulatornetworking">Emulator Networking</h2>
+
+<p>The emulator provides versatile networking capabilities that you can use to
+set up complex modeling and testing environments for your application. The
+sections below introduce the emulator's network architecture and capabilities.
+</p>
+
+<h3 id="networkaddresses">Network Address Space</h3>
+
+<p>Each instance of the emulator runs behind a virtual router/firewall service
+that isolates it from your development machine's network interfaces and settings
+and from the internet. An emulated device can not see your development machine
+or other emulator instances on the network. Instead, it sees only that it is
+connected through Ethernet to a router/firewall.</p>
+
+<p>The virtual router for each instance manages the 10.0.2/24 network address
+space — all addresses managed by the router are in the form of
+10.0.2.<xx>, where <xx> is a number. Addresses within this space are
+pre-allocated by the emulator/router as follows:</p>
+
+<table>
+ <tr>
+ <th>Network Address</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td>10.0.2.1</td>
+ <td>Router/gateway address </td>
+ </tr>
+ <tr>
+ <td>10.0.2.2</td>
+ <td>Special alias to your host loopback interface (i.e., 127.0.0.1 on your
+development machine)</td>
+ </tr>
+ <tr>
+ <td>10.0.2.3</td>
+ <td>First DNS server</td>
+ </tr>
+ <tr>
+ <td>10.0.2.4 / 10.0.2.5 / 10.0.2.6</td>
+ <td>Optional second, third and fourth DNS server (if any) </td>
+ </tr>
+ <tr>
+ <td>10.0.2.15</td>
+ <td>The emulated device's own network/ethernet interface</td>
+ </tr>
+ <tr>
+ <td>127.0.0.1</td>
+ <td>The emulated device's own loopback interface </td>
+ </tr>
+</table>
+
+<p>Note that the same address assignments are used by all running emulator
+instances. That means that if you have two instances running concurrently on
+your machine, each will have its own router and, behind that, each will have an
+IP address of 10.0.2.15. The instances are isolated by a router and can
+<em>not</em> see each other on the same network. For information about how to
+let emulator instances communicate over TCP/UDP, see <a
+href="#connecting">Connecting Emulator Instances</a>.</p>
+
+<p>Also note that the address 127.0.0.1 on your development machine corresponds
+to the emulator's own loopback interface. If you want to access services running
+on your development machine's loopback interface (a.k.a. 127.0.0.1 on your
+machine), you should use the special address 10.0.2.2 instead.</p>
+
+<p>Finally, note that each emulated device's pre-allocated addresses are
+specific to the Android emulator and will probably be very different on real
+devices (which are also very likely to be NAT-ed, i.e., behind a
+router/firewall)</p>
+
+
+<h3 id="networkinglimitations">Local Networking Limitations</h3>
+
+<p>Android applications running in an emulator can connect to the network available on your
+workstation. However, they connect through the emulator, not directly to hardware, and the emulator
+acts like a normal application on your workstation. This means that the emulator, and thus your
+Android applications, are subject to some limitations:</p>
+
+<ul>
+ <li>Communication with the emulated device may be blocked by a firewall
+program running on your machine.</li>
+ <li>Communication with the emulated device may be blocked by another
+(physical) firewall/router to which your machine is connected.</li>
+</ul>
+
+<p>The emulator's virtual router should be able to handle all outbound TCP and
+UDP connections/messages on behalf of the emulated device, provided your
+development machine's network environment allows it to do so. There are no
+built-in limitations on port numbers or ranges except the one imposed by your
+host operating system and network.</p>
+
+<p>Depending on the environment, the emulator may not be able to support other
+protocols (such as ICMP, used for "ping") might not be supported. Currently, the
+emulator does not support IGMP or multicast. </p>
+
+<h3 id="redirection">Using Network Redirection</h3>
+
+<p>To communicate with an emulator instance behind its virtual router, you need
+to set up network redirection on the virtual router. Clients can then connect
+to a specified guest port on the router, while the router directs traffic
+to/from that port to the emulated device's host port. </p>
+
+<p>To set up the network redirection, you create a mapping of host and guest
+ports/addresses on the the emulator instance. There are two ways to set up
+network redirection: using emulator console commands and using the ADB tool, as
+described below. </p>
+
+
+<h4 id="consoleredir">Setting up Redirection through the Emulator Console</h4>
+
+<p>Each emulator instance provides a control console the you can connect to, to
+issue commands that are specific to that instance. You can use the
+<code>redir</code> console command to set up redirection as needed for an
+emulator instance. </p>
+
+<p>First, determine the console port number for the target emulator instance.
+For example, the console port number for the first emulator instance launched is
+5554. Next, connect to the console of the target emulator instance, specifying
+its console port number, as follows: </p>
+
+<pre><code>telnet localhost 5554</code></pre>
+
+<p>Once connected, use the <code>redir</code> command to work with redirection.
+To add a redirection, use:</p>
+
+<pre><code>add <protocol>:<host-port>:<guest-port></code>
+</pre>
+
+<p>where <code><protocol></code> is either <code>tcp</code> or <code>udp</code>,
+and <code><host-port></code> and <code><guest-port></code> sets the
+mapping between your own machine and the emulated system, respectively. </p>
+
+<p>For example, the following command sets up a redirection that handles all
+incoming TCP connections to your host (development) machine on 127.0.0.1:5000
+and will pass them through to the emulated system's 10.0.2.15:6000.:</p>
+
+<pre>redir add tcp:5000:6000</pre>
+
+<p>To delete a redirection, you can use the <code>redir del</code> command. To
+list all redirection for a specific instance, you can use <code>redir
+list</code>. For more information about these and other console commands, see
+<a href="#console">Using the Emulator Console</a>. </p>
+
+<p>Note that port numbers are restricted by your local environment. this typically
+means that you cannot use host port numbers under 1024 without special
+administrator privileges. Also, you won't be able to set up a redirection for a
+host port that is already in use by another process on your machine. In that
+case, <code>redir</code> generates an error message to that effect. </p>
+
+<h4 id="adbredir">Setting Up Redirection through ADB</h4>
+
+<p>The Android Debug Bridge (ADB) tool provides port forwarding, an alternate
+way for you to set up network redirection. For more information, see <a
+href="{@docRoot}tools/help/adb.html#forwardports">Forwarding Ports</a> in the ADB
+documentation.</p>
+
+<p>Note that ADB does not currently offer any way to remove a redirection,
+except by killing the ADB server.</p>
+
+
+<h3 id="dns">Configuring the Emulator's DNS Settings</h3>
+
+<p>At startup, the emulator reads the list of DNS servers that your system is
+currently using. It then stores the IP addresses of up to four servers on this
+list and sets up aliases to them on the emulated addresses 10.0.2.3, 10.0.2.4,
+10.0.2.5 and 10.0.2.6 as needed. </p>
+
+<p>On Linux and OS X, the emulator obtains the DNS server addresses by parsing
+the file <code>/etc/resolv.conf</code>. On Windows, the emulator obtains the
+addresses by calling the <code>GetNetworkParams()</code> API. Note that this
+usually means that the emulator ignores the content of your "hosts" file
+(<code>/etc/hosts</code> on Linux/OS X, <code>%WINDOWS%/system32/HOSTS</code>
+ on Windows).</P>
+
+<p>When starting the emulator at the command line, you can also use the
+<code>-dns-server <serverList></code> option to manually specify the
+addresses of DNS servers to use, where <serverList> is a comma-separated
+list of server names or IP addresses. You might find this option useful if you
+encounter DNS resolution problems in the emulated network (for example, an
+"Unknown Host error" message that appears when using the web browser).</p>
+
+
+<h3 id="proxy">Using the Emulator with a Proxy</h3>
+
+<p>If your emulator must access the Internet through a proxy server, you can use
+the <code>-http-proxy <proxy></code> option when starting the emulator, to
+set up the appropriate redirection. In this case, you specify proxy information
+in <code><proxy></code> in one of these formats:</p>
+
+<pre>http://<machineName>:<port></pre>
+
+<p>or</p>
+
+<pre>http://<username>:<password>@<machineName>:<port></pre>
+
+<p>The <code>-http-proxy</code> option forces the emulator to use the specified
+HTTP/HTTPS proxy for all outgoing TCP connections. Redirection for UDP is not
+currently supported.</p>
+
+<p>Alternatively, you can define the environment variable
+<code>http_proxy</code> to the value you want to use for
+<code><proxy></code>. In this case, you do not need to specify a value for
+<code><proxy></code> in the <code>-http-proxy</code> command — the
+emulator checks the value of the <code>http_proxy</code> environment variable at
+startup and uses its value automatically, if defined. </p>
+
+<p>You can use the <code>-verbose-proxy</code> option to diagnose proxy
+connection problems.</p>
+
+
+<h3 id="connecting">Interconnecting Emulator Instances</h3>
+
+<p>To allow one emulator instance to communicate with another, you must set up
+the necessary network redirection as illustrated below. </p>
+
+<p>Assume that your environment is</p>
+
+<ul>
+ <li>A is you development machine</li>
+ <li>B is your first emulator instance, running on A</li>
+ <li>C is your second emulator instance, also running on A</li>
+</ul>
+
+<p>and you want to run a server on B, to which C will connect, here is how you
+could set it up: </p>
+
+<ol>
+ <li>Set up the server on B, listening to
+<code>10.0.2.15:<serverPort></code></li>
+ <li>On B's console, set up a redirection from
+<code>A:localhost:<localPort></code> to <code>
+B:10.0.2.15:<serverPort></code></li>
+ <li>On C, have the client connect to <code>10.0.2.2:<localPort></code></li>
+</ol>
+
+<p>For example, if you wanted to run an HTTP server, you can select
+<code><serverPort></code> as 80 and <code><localPort></code> as
+8080:</p>
+
+<ul>
+ <li>B listens on 10.0.2.15:80</li>
+ <li>On B's console, issue <code>redir add tcp:8080:80</code></li>
+ <li>C connects to 10.0.2.2:8080</li>
+</ul>
+
+<h3 id="calling">Sending a Voice Call or SMS to Another Emulator Instance</h3>
+
+<p>The emulator automatically forwards simulated voice calls and SMS messages from one instance to
+another. To send a voice call or SMS, use the dialer application or SMS application, respectively,
+from one of the emulators.</p>
+
+<p>To initiate a simulated voice call to another emulator instance:</p>
+<ol>
+<li>Launch the dialer application on the originating emulator instance.</li>
+<li>As the number to dial, enter the console port number of the instance you'd like to call. You can determine
+ the console port number of the target instance by checking its window title, where the
+ console port number is reported as "Android Emulator (<port>). </li>
+<li>Press "Dial". A new inbound call appears in the target emulator instance. </li>
+</ol>
+
+<p>To send an SMS message to another emulator instance, launch the SMS application (if available). Specify the console port number of the target emulator instance as as the SMS address, enter the message text, and send the message. The message is delivered to the target emulator instance. </p>
+
+<p>You can also connect to an emulator instance's console to simulate an incoming voice call or SMS. For more information, see <a href="#telephony">Telephony Emulation</a> and <a href="#sms">SMS Emulation</a>.
+
+
+<h2 id="console">Using the Emulator Console</h2>
+
+<p>Each running emulator instance provides a console that lets you query and control the emulated
+device environment. For example, you can use the console to manage port redirection, network
+characteristics, and telephony events while your application is running on the emulator. To
+access the console and enter commands, use telnet to connect to the console's port number.</p>
+
+<p>To connect to the console of any running emulator instance at any time, use this command: </p>
+
+<pre>telnet localhost <console-port></pre>
+
+<p>An emulator instance occupies a pair of adjacent ports: a console port and an {@code adb} port.
+The port numbers differ by 1, with the {@code adb} port having the higher port number. The console
+of the first emulator instance running on a given machine uses console port 5554 and {@code adb}
+port 5555. Subsequent instances use port numbers increasing by two — for example, 5556/5557,
+5558/5559, and so on. Up to 16 concurrent emulator instances can run a console facility. </p>
+
+<p>To connect to the emulator console, you must specify a valid console port. If multiple emulator instances are running, you need to determine the console port of the emulator instance you want to connect to. You can find the instance's console port listed in the title of the instance window. For example, here's the window title for an instance whose console port is 5554:</p>
+
+<p><code>Android Emulator (5554)</code></p>
+
+<p>Alternatively, you can use the <code>adb devices</code> command, which prints a list of running emulator instances and their console port numbers. For more information, see <a href="{@docRoot}tools/help/adb.html#devicestatus">Querying for Emulator/Device Instances</a> in the adb documentation.</p>
+
+<p class="note">Note: The emulator listens for connections on ports 5554-5587 and accepts connections only from localhost.</p>
+
+<p>Once you are connected to the console, you can then enter <code>help [command]</code> to see a list of console commands and learn about specific commands. </p>
+
+<p>To exit the console session, use <code>quit</code> or <code>exit</code>.</p>
+
+<p>The following sections below describe the major functional areas of the console.</p>
+
+
+<h3 id="portredirection">Port Redirection</h3>
+
+<p>You can use the console to add and remove port redirection while the emulator is running. After
+you connect to the console, manage port redirection by entering the following command:</p>
+
+<pre>redir <list|add|del> </pre>
+
+<p>The <code>redir</code> command supports the subcommands listed in the table below. </p>
+
+<table>
+<tr>
+ <th width="25%" >Subcommand
+ <th width="30%" >Description</th>
+ <th width="35%">Comments</th>
+</tr>
+
+ <tr>
+ <td><code>list</code></td>
+ <td>List the current port redirection.</td>
+ <td> </td>
+ </tr>
+
+
+<tr>
+ <td><code>add <protocol>:<host-port>:<guest-port></code></td>
+ <td>Add a new port redirection.</td>
+<td><ul><li><protocol> must be either "tcp" or "udp"</li>
+<li><host-port> is the port number to open on the host</li>
+<li><guest-port> is the port number to route data to on the emulator/device</li>
+</ul></td>
+</tr>
+<tr>
+ <td><code>del <protocol>:<host-port></code></td>
+ <td>Delete a port redirection.</td>
+<td>The meanings of <protocol> and <host-port> are listed in the previous row.</td>
+</tr>
+</table>
+
+
+<h3 id="geo">Geo Location Provider Emulation</h3>
+
+<p>You can use the console to set the geographic location reported to the applications running
+inside an emulator. Use the <code>geo</code> command to send a simple GPS fix to the
+emulator, with or without NMEA 1083 formatting:</p>
+
+<pre>geo <fix|nmea></pre>
+
+<p>The <code>geo</code> command supports the subcommands listed in the table below.</p>
+
+<table>
+<tr>
+ <th width="25%">Subcommand</th>
+ <th width="30%">Description</th>
+ <th width="35%">Comments</th>
+</tr>
+
+ <tr>
+ <td><code>fix <longitude> <latitude> [<altitude>]</code></td>
+ <td>Send a simple GPS fix to the emulator instance.</td>
+ <td>Specify longitude and latitude in decimal degrees. Specify altitude in meters.</td>
+ </tr>
+<tr>
+ <td><code>nmea <sentence></code></td>
+ <td>Send an NMEA 0183 sentence to the emulated device, as if it were sent from an emulated GPS modem.</td>
+<td><code><sentence></code> must begin with '$GP'. Only '$GPGGA' and '$GPRCM' sentences are currently supported.</td>
+</tr>
+</table>
+
+<p>You can issue the <code>geo</code> command as soon as an emulator instance is running. The
+emulator sets the location you enter by creating a mock location provider. This provider responds to
+location listeners set by applications, and also supplies the location to the {@link
+android.location.LocationManager}. Any application can query the location manager to obtain the
+current GPS fix for the emulated device by calling:
+
+<pre>LocationManager.getLastKnownLocation("gps")</pre>
+
+<p>For more information about the Location Manager, see {@link android.location.LocationManager}.
+</p>
+
+<h3 id="events">Hardware Events Emulation</h3>
+
+<p>The {@code event} console commands sends hardware events to the emulator. The syntax for this
+command is as follows:</p>
+
+<pre>event <send|types|codes|text></pre>
+
+<p>The <code>event</code> command supports the subcommands listed in the table below. </p>
+
+<table>
+<tr>
+ <th width="25%" >Subcommand
+ <th width="30%" >Description</th>
+ <th width="35%">Comments</th>
+</tr>
+
+ <tr>
+ <td><code>send <type>:<code>:<value> [...]</code></td>
+ <td>Send one or more events to the Android kernel. </td>
+ <td>You can use text names or integers for <code><type></code> and <code><value></code>.</td>
+ </tr>
+<tr>
+ <td><code>types</code></td>
+ <td>List all <code><type></code> string aliases supported by the <code>event</code> subcommands.</td>
+<td> </td>
+</tr>
+<tr>
+ <td><code>codes <type></code></td>
+ <td>List all <code><codes></code> string aliases supported by the <code>event</code>
+ subcommands for the specified <code><type></code>.</td>
+<td> </td>
+</tr>
+<tr>
+ <td><code>event text <message></code></td>
+ <td>Simulate keypresses to send the specified string of characters as a message,</td>
+<td>The message must be a UTF-8 string. Unicode posts will be reverse-mapped according to the current device keyboard. Unsupported characters will be discarded silently.</td>
+</tr>
+</table>
+
+
+<h3 id="power">Device Power Characteristics</h3>
+
+<p>The {@code power} command controls the power state reported by the emulator to applications. The
+syntax for this command is as follows: </p>
+
+<pre>power <display|ac|status|present|health|capacity></pre>
+
+<p>The <code>event</code> command supports the subcommands listed in the table below. </p>
+
+<table>
+<tr>
+ <th width="25%" >Subcommand </th>
+ <th width="30%" >Description</th>
+ <th width="35%">Comments</th>
+</tr>
+
+ <tr>
+ <td><code>display</code></td>
+ <td>Display battery and charger state.</td>
+ <td> </td>
+ </tr>
+<tr>
+ <td><code>ac <on|off></code></td>
+ <td>Set AC charging state to on or off. </td>
+<td> </td>
+</tr>
+<tr>
+ <td><code>status <unknown|charging|discharging|not-charging|full></code></td>
+ <td>Change battery status as specified.</td>
+<td> </td>
+</tr>
+
+<tr>
+ <td><code>present <true|false></code></td>
+ <td>Set battery presence state.</td>
+<td> </td>
+</tr>
+<tr>
+ <td><code>health <unknown|good|overheat|dead|overvoltage|failure></code></td>
+ <td>Set battery health state.</td>
+<td> </td>
+</tr>
+<tr>
+ <td><code>power health <percent></code></td>
+ <td>Set remaining battery capacity state (0-100).</td>
+<td> </td>
+</tr>
+</table>
+
+
+<h3 id="netstatus">Network Status</h3>
+
+<p>You can use the console to check the network status and current delay and speed characteristics. To do so, connect to the console and use the <code>netstatus</code> command. Here's an example of the command and its output. </p>
+
+<pre>network status
+</pre>
+
+
+<h3 id="netdelay">Network Delay Emulation</h3>
+
+<p>The emulator lets you simulate various network latency levels, so that you can test your
+application in an environment more typical of the actual conditions in which it will run. You can
+set a latency level or range at emulator startup or you can use the console to change the latency,
+while the application is running in the emulator. </p>
+
+<p>To set latency at emulator startup, use the <code>-netdelay</code> emulator option with a
+supported <code><delay></code> value, as listed in the table below. Here are some
+examples:</p>
+
+<pre>emulator -netdelay gprs
+emulator -netdelay 40 100</pre>
+
+<p>To make changes to network delay while the emulator is running, connect to the console and use
+the <code>netdelay</code> command with a supported <code><delay></code> value from the table
+below.</p>
+
+<pre>network delay gprs</pre>
+
+<p>The format of network <delay> is one of the following (numbers are milliseconds):</p>
+
+<table style="clear:right;width:100%;">
+<tr>
+ <th width="30%" >Value</th>
+ <th width="35%" >Description</th><th width="35%">Comments</th></tr>
+
+ <tr><td><code>gprs</code></td><td>GPRS</td>
+ <td>(min 150, max 550)</td>
+ </tr>
+
+<tr><td><code>edge</code></td><td>EDGE/EGPRS</td>
+<td>(min 80, max 400)</td>
+</tr>
+<tr><td><code>umts</code></td><td>UMTS/3G</td>
+<td>(min 35, max 200)</td>
+</tr>
+<tr><td><code>none</code></td><td>No latency</td><td>(min 0, max 0)</td></tr>
+<tr><td><code><num></code></td>
+<td>Emulate an exact latency (milliseconds).</td>
+<td> </td></tr>
+<tr><td><code><min>:<max></code></td>
+<td>Emulate an specified latency range (min, max milliseconds).</td>
+<td> </td></tr>
+</table>
+
+
+<h3 id="netspeed">Network Speed Emulation</h3>
+
+<p>The emulator also lets you simulate various network transfer rates.
+You can set a transfer rate or range at emulator startup or you can use the console to change the
+rate, while the application is running in the emulator.</p>
+
+<p>To set the network speed at emulator startup, use the <code>-netspeed</code> emulator option with a supported
+<code><speed></code> value, as listed in the table below. Here are some examples:</p>
+
+<pre>emulator -netspeed gsm
+emulator -netspeed 14.4 80</pre>
+
+<p>To make changes to network speed while the emulator is running, connect to the console and use
+the <code>netspeed</code> command with a supported <code><speed></code> value from the table
+below.</p>
+
+<pre>network speed 14.4 80</pre>
+
+<p>The format of network <code><speed></code> is one of the following (numbers are
+kilobits/sec):</p>
+<table style="clear:right;width:100%;">
+<tbody>
+<tr>
+ <th width="30%">Value</th>
+ <th width="35%">Description</th><th width="35%">Comments</th></tr>
+
+ <tr>
+ <td><code>gsm</code></td>
+ <td>GSM/CSD</td><td>(Up: 14.4, down: 14.4)</td></tr>
+<tr>
+ <td><code>hscsd</code></td>
+ <td>HSCSD</td><td>(Up: 14.4, down: 43.2)</td></tr>
+<tr>
+ <td><code>gprs</code></td>
+ <td>GPRS</td><td>(Up: 40.0, down: 80.0)</td></tr>
+<tr>
+ <td><code>edge</code></td>
+ <td>EDGE/EGPRS</td>
+ <td>(Up: 118.4, down: 236.8)</td>
+</tr>
+<tr>
+ <td><code>umts</code></td>
+ <td>UMTS/3G</td><td>(Up: 128.0, down: 1920.0)</td></tr>
+<tr>
+ <td><code>hsdpa</code></td>
+ <td>HSDPA</td><td>(Up: 348.0, down: 14400.0)</td></tr>
+<tr>
+ <td><code>full</code></td>
+ <td>no limit</td><td>(Up: 0.0, down: 0.0)</td></tr>
+<tr>
+ <td><code><num></code></td>
+ <td>Set an exact rate used for both upload and download.</td><td></td></tr>
+<tr>
+ <td><code><up>:<down></code></td>
+ <td>Set exact rates for upload and download separately.</td><td></td></tr>
+</table>
+
+
+<h3 id="telephony">Telephony Emulation</h3>
+
+<p>The Android emulator includes its own GSM emulated modem that lets you simulate telephony
+functions in the emulator. For example, you can simulate inbound phone calls, establish data
+connections and terminate them. The Android system handles simulated calls exactly as it would
+actual calls. The emulator does not support call audio.</p>
+
+<p>You can use the {@code gsm} command to access the emulator's telephony functions after connecting
+to the console. The syntax for this command is as follows:</p>
+
+<pre>gsm <call|accept|busy|cancel|data|hold|list|voice|status> </pre>
+
+<p>The <code>gsm</code> command supports the subcommands listed in the table below. </p>
+<table>
+ <tr>
+ <th>Subcommand </th>
+ <th width="25%">Description</th>
+ <th>Comments</th>
+ </tr>
+ <tr>
+ <td><code>call <phonenumber></code></td>
+ <td>Simulate an inbound phone call from <phonenumber>.</td>
+ <td> </td>
+ </tr>
+ <tr>
+ <td><code>accept <phonenumber></code></td>
+ <td>Accept an inbound call from <phonenumber> and change the call's state "active".</td>
+ <td>You can change a call's state to "active" only if its current state is "waiting" or "held".</td>
+ </tr>
+ <tr>
+ <td><code>busy <phonenumber></code></td>
+ <td>Close an outbound call to <phonenumber> and change the call's state to "busy".</td>
+ <td>You can change a call's state to "busy" only if its current state is "waiting".</td>
+ </tr>
+ <tr>
+ <td><code>cancel <phonenumber></code></td>
+ <td>Terminate an inbound or outbound phone call to/from <phonenumber>.</td>
+ <td> </td>
+ </tr>
+ <tr>
+ <td><code>data <state></code></td>
+ <td>Change the state of the GPRS data connection to <state>.</td>
+ <td>Supported <state> values are:<br />
+ <ul>
+ <li><code>unregistered</code> -- No network available</li>
+ <li><code>home</code> -- On local network, non-roaming</li>
+ <li><code>roaming</code> -- On roaming network</li>
+ <li><code>searching</code> -- Searching networks</li>
+ <li><code>denied</code> -- Emergency calls only</li>
+ <li><code>off</code> -- Same as 'unregistered'</li>
+ <li><code>on</code> -- same as 'home'</li>
+ </ul>
+ </td>
+ </tr>
+ <tr>
+ <td><code>hold</code></td>
+ <td>Change the state of a call to "held". </td>
+ <td>You can change a call's state to "held" only if its current state is "active" or "waiting". </td>
+ </tr>
+ <tr>
+ <td><code>list</code></td>
+ <td>List all inbound and outbound calls and their states.</td>
+ <td> </td>
+ </tr>
+ <tr>
+ <td><code>voice <state></code></td>
+ <td>Change the state of the GPRS voice connection to <state>.</td>
+ <td>Supported <state> values are:<br />
+ <ul>
+ <li><code>unregistered</code> -- No network available</li>
+ <li><code>home</code> -- On local network, non-roaming</li>
+ <li><code>roaming</code> -- On roaming network</li>
+ <li><code>searching</code> -- Searching networks</li>
+ <li><code>denied</code> -- Emergency calls only</li>
+ <li><code>off</code> -- Same as 'unregistered'</li>
+ <li><code>on</code> -- Same as 'home'</li>
+ </ul>
+ </td>
+ </tr>
+
+ <tr>
+ <td><code>status</code></td>
+ <td>Report the current GSM voice/data state.</td>
+ <td>Values are those described for the <code>voice</code> and <code>data</code> commands.</td>
+ </tr>
+</table>
+
+
+<h3 id="sms">SMS Emulation</h3>
+
+<p>The Android emulator console lets you generate an SMS message and direct it to an emulator
+instance. Once you connect to an emulator instance, you can generate an emulated incoming SMS using
+the following command:</p>
+
+<pre>sms send <senderPhoneNumber> <textmessage></pre>
+
+<p>where <code><senderPhoneNumber></code> contains an arbitrary numeric string. </p>
+
+<p>The console forwards the SMS message to the Android framework, which passes it through to an application that handles that message type. </p>
+
+
+<h3 id="vm">VM State</h3>
+
+<p>You can use the <code>vm</code> command to control the VM on an emulator instance. The syntax for
+this command is as follows: </p>
+
+<pre>vm <start|stop|status></pre>
+
+<p>The <code>vm</code> command supports the subcommands listed in the table below. </p>
+
+<table>
+<tr>
+ <th width="25%">Subcommand</th>
+ <th width="30%">Description</th>
+ <th width="35%">Comments</th>
+</tr>
+<tr>
+ <td><code>start</code></td>
+ <td>Start the VM on the instance. </td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>stop</code></td>
+ <td>Stop the VM on the instance. </td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>start</code></td>
+ <td>Display the current status of the VM (running or stopped). </td>
+ <td> </td>
+</tr>
+</table>
+
+
+<h3 id="window">Emulator Window</h3>
+
+<p>You can use the <code>window</code> command to manage the emulator window. The syntax for this
+command is as follows: </p>
+
+<pre>window <scale></pre>
+
+<p>The <code>vm</code> command supports the subcommands listed in the table below. </p>
+
+<table>
+<tr>
+ <th width="25%">Subcommand</th>
+ <th width="30%">Description</th>
+ <th width="35%">Comments</th>
+</tr>
+<tr>
+ <td><code>scale <scale></code></td>
+ <td>Scale the emulator window.</td>
+ <td>A number between 0.1 and 3 that sets the scaling factor. You can
+ also specify scale as a DPI value if you add the suffix "dpi" to the scale value. A value of "auto"
+ tells the emulator to select the best window size.</td>
+</tr>
+</table>
+
+
+<h3 id="terminating">Terminating an Emulator Instance</h3>
+
+<p>You can terminate an emulator instance through the console, using the <code>kill</code> command.</p>
+
+
+<h2 id="limitations">Emulator Limitations</h2>
+
+<p>The functional limitations of the emulator include: </p>
+<ul>
+ <li>No support for placing or receiving actual phone calls. You can simulate phone calls (placed
+ and received) through the emulator console, however. </li>
+ <li>No support for USB connections</li>
+ <li>No support for device-attached headphones</li>
+ <li>No support for determining network connected state</li>
+ <li>No support for determining battery charge level and AC charging state</li>
+ <li>No support for determining SD card insert/eject</li>
+ <li>No support for Bluetooth</li>
+</ul>
+
+
+<h2 id="troubleshooting">Troubleshooting Emulator Problems</h2>
+
+<p>The {@code adb} utility sees the emulator as an actual physical device. For this reason, you
+might have to use the {@code -d} flag with some common {@code adb} commands, such as
+<code>install</code>. The {@code -d} flag lets you specify which of several connected devices to use
+as the target of a command. If you don't specify {@code -d}, the emulator targets the first
+device in its list. For more information about {@code adb}, see <a
+href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a>.</p>
+
+<p>For emulators running on Mac OS X, if you see an error {@code Warning: No DNS servers found}
+when starting the emulator, check to see whether you have an <code>/etc/resolv.conf</code> file. If
+not, please run the following line in a command window:</p>
+ <pre>ln -s /private/var/run/resolv.conf /etc/resolv.conf</pre>
+
+<p>See <a href="{@docRoot}resources/faq/index.html">Frequently Asked Questions</a> for more
+troubleshooting information. </p>
diff --git a/docs/html/tools/devices/index.jd b/docs/html/tools/devices/index.jd
new file mode 100644
index 0000000..bec2268
--- /dev/null
+++ b/docs/html/tools/devices/index.jd
@@ -0,0 +1,78 @@
+page.title=Managing Virtual Devices
+@jd:body
+
+
+ <p>An Android Virtual Device (AVD) is an emulator configuration that lets you model an actual
+ device by defining hardware and software options to be emulated by the Android Emulator.</p>
+
+ <p>The easiest way to create an AVD is to use the graphical <a href=
+ "{@docRoot}tools/devices/managing-avds.html">AVD Manager</a>, which you launch
+ from Eclipse by clicking <strong>Window > AVD Manager</strong>. You can also start the AVD
+Manager from the command line by calling the <code>android</code> tool with the <code>avd</code>
+options, from the <strong><sdk>/tools/</strong> directory.</p>
+
+ <p>You can also create AVDs on the command line by passing the <code>android</code> tool options.
+ For more information on how to create AVDs in this manner, see <a href=
+ "{@docRoot}tools/devices/managing-avds-cmdline.html">Managing Virtual
+ Devices from the Command Line</a>.</p>
+
+ <p>An AVD consists of:</p>
+
+ <ul>
+ <li>A hardware profile: Defines the hardware features of the virtual
+ device. For example, you can define whether the device has a camera, whether it uses a physical
+ QWERTY keyboard or a dialing pad, how much memory it has, and so on.</li>
+
+ <li>A mapping to a system image: You can define what version of the Android platform will run
+ on the virtual device. You can choose a version of the standard Android platform or the system
+ image packaged with an SDK add-on.</li>
+
+ <li>Other options: You can specify the emulator skin you want to use with the AVD, which lets
+ you control the screen dimensions, appearance, and so on. You can also specify the emulated SD
+ card to use with the AVD.</li>
+
+ <li>A dedicated storage area on your development machine: the device's user data (installed
+ applications, settings, and so on) and emulated SD card are stored in this area.</li>
+ </ul>
+
+ <p>You can create as many AVDs as you need, based on the types of device you want to model.
+ To thoroughly test your application, you should create an AVD for each general device configuration
+ (for example, different screen sizes and platform versions) with which your application is compatible
+ and test your application on each one.</p>
+
+ <p>Keep these points in mind when you are selecting a system image target for your AVD:</p>
+
+ <ul>
+ <li>The API Level of the target is important, because your application will not be able to run
+ on a system image whose API Level is less than that required by your application, as specified
+ in the <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html">
+ <code>minSdkVersion</code></a> attribute of the application's manifest file. For more
+ information about the relationship between system API Level and application
+ <code>minSdkVersion</code>, see <a href=
+ "{@docRoot}tools/publishing/versioning.html">Specifying Minimum System API Version</a>.</li>
+
+ <li>You should create at least one AVD that uses a target whose API Level is greater than that required
+ by your application, because it allows you to test the
+ forward-compatibility of your application. Forward-compatibility testing ensures that, when
+ users who have downloaded your application receive a system update, your application will
+ continue to function normally.</li>
+
+ <li>If your application declares a
+ <a href="{@docRoot}guide/topics/manifest/uses-library-element.html"><code>uses-library</code></a>
+ element in its manifest file, the application can only run on a system image in which that external
+ library is present. If you want to run your application on an emulator, create an AVD that
+ includes the required library. Usually, you must create such an AVD using an Add-on component for the
+ AVD's platform (for example, the Google APIs Add-on contains the Google Maps library).</li>
+ </ul>
+
+ <p>To learn how to manage AVDs using a graphical tool, read <a href=
+ "{@docRoot}tools/devices/managing-avds.html">Managing AVDs with AVD Manager</a>. To
+learn how to manage AVDs on the command line, read
+ <a href="{@docRoot}tools/devices/managing-avds-cmdline.html">Managing AVDs
+ from the Command Line</a>.</p>
+
+
+
+
+
+
diff --git a/docs/html/tools/devices/managing-avds-cmdline.jd b/docs/html/tools/devices/managing-avds-cmdline.jd
new file mode 100644
index 0000000..ba353c1
--- /dev/null
+++ b/docs/html/tools/devices/managing-avds-cmdline.jd
@@ -0,0 +1,369 @@
+page.title=Managing AVDs from the Command Line
+parent.title=Managing Virtual Devices
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#listingtargets">Listing Targets</a></li>
+ <li><a href="#AVDCmdLine">Creating AVDs</a>
+ <ol>
+ <li><a href="#CustomDensity">Customize the device resolution or density</a></li>
+ <li><a href="#DefaultLocation">Default location of AVD files</a></li>
+ <li><a href="#hardwareopts">Setting hardware emulation options</a></li>
+ </ol>
+ </li>
+ <li><a href="#moving">Moving an AVD</a></li>
+ <li><a href="#updating">Updating an AVD</a></li>
+ <li><a href="#deleting">Deleting an AVD</a></li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/building/building-cmdline.html">Building and Running
+from the Command Line</a></li>
+ <li><a href="{@docRoot}tools/devices/emulator.html">Using the Android
+Emulator</a></li>
+ </ol>
+ </div>
+</div>
+
+
+<p>The <code>android</code> tool lets you manage AVDs on the command line. For a complete reference
+of the command line options that you can use, see the reference for the
+<a href="{@docRoot}tools/help/android.html"><code>android</code></a> tool.</p>
+
+
+
+<h2 id="listingtargets">Listing Targets</h2>
+
+<p>To generate a list of system image targets, use this command: </p>
+
+<pre>android list targets</pre>
+
+<p>The <code>android</code> tool scans the <code><sdk>/platforms/</code> and
+<code><sdk>/add-ons/</code> directories looking for valid system images and
+then generates the list of targets. Here's an example of the command output:
+</p>
+
+<pre>Available Android targets:
+id: 1 or "android-3"
+ Name: Android 1.5
+ Type: Platform
+ API level: 3
+ Revision: 4
+ Skins: QVGA-L, HVGA-L, HVGA (default), HVGA-P, QVGA-P
+id: 2 or "android-4"
+ Name: Android 1.6
+ Type: Platform
+ API level: 4
+ Revision: 3
+ Skins: QVGA, HVGA (default), WVGA800, WVGA854
+id: 3 or "android-7"
+ Name: Android 2.1-update1
+ Type: Platform
+ API level: 7
+ Revision: 2
+ Skins: QVGA, WQVGA400, HVGA (default), WVGA854, WQVGA432, WVGA800
+id: 4 or "android-8"
+ Name: Android 2.2
+ Type: Platform
+ API level: 8
+ Revision: 2
+ Skins: WQVGA400, QVGA, WVGA854, HVGA (default), WVGA800, WQVGA432
+id: 5 or "android-9"
+ Name: Android 2.3
+ Type: Platform
+ API level: 9
+ Revision: 1
+ Skins: HVGA (default), WVGA800, WQVGA432, QVGA, WVGA854, WQVGA400
+</pre>
+
+
+
+<h2 id="AVDCmdLine">Creating AVDs</h2>
+
+<p>In addition to creating AVDs with the
+<a href="{@docRoot}tools/devices/managing-avds-cmdline.html">AVD Manager user interface</a>,
+you can also create them by passing in command line arguments to the <code>android</code> tool.
+</p>
+
+<p>Open a terminal window and change to
+the <code><sdk>/tools/</code> directory, if needed.</p>
+
+<p>To create each AVD, you issue the command <code>android create avd</code>,
+with options that specify a name for the new AVD and the system image you want
+to run on the emulator when the AVD is invoked. You can specify other options on
+the command line also, such as the emulated SD card size, the emulator skin, or a custom
+location for the user data files.</p>
+
+<p>Here's the command-line usage for creating an AVD: </p>
+
+<pre>android create avd -n <name> -t <targetID> [-<option> <value>] ... </pre>
+
+<p>You can use any name you want for the AVD, but since you are likely to be
+creating multiple AVDs, you should choose a name that lets you recognize the
+general characteristics offered by the AVD. The target ID is an integer assigned by the
+<code>android</code> tool. The target ID is not derived from the system image name,
+version, or API Level, or other attribute, so you need to run the <code>android list targets</code>
+command to list the target ID of each system image. You should do this <em>before</em> you run
+the <code>android create avd</code> command. See the <a
+href="{@docRoot}tools/help/android.html">android</a>
+tool documentation for more information on the command line options.</p>
+
+
+<p>When you've selected the target you want to use and made a note of its ID,
+use the <code>android create avd</code> command to create the AVD, supplying the
+target ID as the <code>-t</code> argument. Here's an example that creates an
+AVD with name "my_android1.5" and target ID "2" (the standard Android 1.5
+system image in the list above): </p>
+
+<pre>android create avd -n my_android1.5 -t 2</pre>
+
+<p>If the target you selected was a standard Android system image ("Type:
+platform"), the <code>android</code> tool next asks you whether you want to
+create a custom hardware profile. </p>
+<pre>Android 1.5 is a basic Android platform.
+Do you wish to create a custom hardware profile [no]</pre>
+
+<p>If you want to set custom hardware emulation options for the AVD, enter
+"yes" and set values as needed. If you want to use the default hardware
+emulation options for the AVD, just press the return key (the default is "no").
+The <code>android</code> tool creates the AVD with name and system image mapping you
+requested, with the options you specified. For more information, see <a href="#hardwareopts">
+Setting Hardware Emulation Options</a>.
+
+<p class="note"><strong>Note:</strong> If you are creating an AVD whose target is an SDK add-on, the
+<code>android</code> tool does not allow you to set hardware emulation options.
+It assumes that the provider of the add-on has set emulation options
+appropriately for the device that the add-on is modeling, and so prevents you
+from resetting the options. </p>
+
+
+<h3 id="CustomDensity">Customize the device resolution or density</h3>
+
+<p>When testing your application, we recommend that you test your application in several different
+AVDs, using different screen configurations (different combinations of size and density). In
+addition, you should set up the AVDs to run at a physical size that closely matches an actual
+device.</p>
+
+<p>To set up your AVDs for a specific resolution or density, follow these steps:</p>
+
+<ol>
+ <li>Use the <code>create avd</code> command to create a new AVD, specifying
+the <code>--skin</code> option with a value that references either a default
+skin name (such as "WVGA800") or a custom skin resolution (such as 240x432).
+Here's an example:
+ <pre>android create avd -n <name> -t <targetID> --skin WVGA800</pre>
+ </li>
+ <li>To specify a custom density for the skin, answer "yes" when asked whether
+you want to create a custom hardware profile for the new AVD.</li>
+ <li>Continue through the various profile settings until the tool asks you to
+specify "Abstracted LCD density" (<em>hw.lcd.density</em>). Enter an appropriate
+value, such as "120" for a low-density screen, "160" for a medium density screen,
+or "240" for a high-density screen.</li>
+ <li>Set any other hardware options and complete the AVD creation.</li>
+</ol>
+
+<p>In the example above (WVGA medium density), the new AVD will emulate a 5.8"
+WVGA screen.</p>
+
+<p>As an alternative to adjusting the emulator skin configuration, you can use
+the emulator skin's default density and add the <code>-dpi-device</code> option
+to the <a href="{@docRoot}tools/help/emulator.html">emulator</a> command line when
+starting the AVD. For example:</p>
+
+<pre>emulator -avd WVGA800 -scale 96dpi -dpi-device 160</pre>
+
+
+
+<h3 id="DefaultLocation">Default location of AVD files</h3>
+
+<p>When you create an AVD, the <code>android</code> tool creates a dedicated directory for it
+on your development computer. The directory contains the AVD configuration file,
+the user data image and SD card image (if available), and any other files
+associated with the device. Note that the directory does not contain a system
+image — instead, the AVD configuration file contains a mapping to the
+system image, which it loads when the AVD is launched. </p>
+
+<p>The <code>android</code> tool also creates an <code><AVD_name>.ini</code> file for the AVD at the
+root of the <code>.android/avd/</code> directory on your computer. The file specifies the
+location of the AVD directory and always remains at the root the .android
+directory.</p>
+
+<p>By default, the <code>android</code> tool creates the AVD directory inside
+<code>~/.android/avd/</code> (on Linux/Mac), <code>C:\Documents and
+Settings\<user>\.android\</code> on Windows XP, and
+<code>C:\Users\<user>\.android\</code> on Windows 7 and Vista.
+If you want to use a custom location for the AVD directory, you
+can do so by using the <code>-p <path></code> option when
+you create the AVD: </p>
+
+<pre>android create avd -n my_android1.5 -t 2 -p path/to/my/avd</pre>
+
+<p>If the .android directory is hosted on a network drive, we recommend using
+the <code>-p</code> option to place the AVD directory in another location.
+The AVD's .ini file remains in the .android directory on the network
+drive, regardless of the location of the AVD directory.
+
+
+<h3 id="hardwareopts">Setting hardware emulation options</h3>
+
+<p>When you are creating a new AVD that uses a standard Android system image ("Type:
+platform"), the <code>android</code> tool lets you set hardware emulation
+options for virtual device. The table below lists the options available and the
+default values, as well as the names of properties that store the emulated
+hardware options in the AVD's configuration file (the config.ini file in the
+AVD's local directory). </p>
+
+<p class="table-caption"><strong>Table 1.</strong> Available hardware profile options for AVDs and
+the default values </p>
+
+<table>
+<tr>
+<th>Characteristic</th>
+<th>Description</th>
+<th>Property</th>
+</tr>
+
+<tr>
+<td>Device ram size</td>
+<td>The amount of physical RAM on the device, in megabytes. Default value is "96".
+<td>hw.ramSize</td>
+</tr>
+
+<tr>
+<td>Touch-screen support</td>
+<td>Whether there is a touch screen or not on the device. Default value is "yes".</td>
+<td>hw.touchScreen
+
+<tr>
+<td>Trackball support </td>
+<td>Whether there is a trackball on the device. Default value is "yes".</td>
+<td>hw.trackBall</td>
+</tr>
+
+<tr>
+<td>Keyboard support</td>
+<td>Whether the device has a QWERTY keyboard. Default value is "yes".</td>
+<td>hw.keyboard</td>
+</tr>
+
+<tr>
+<td>DPad support</td>
+<td>Whether the device has DPad keys. Default value is "yes".</td>
+<td>hw.dPad</td>
+</tr>
+
+<tr>
+<td>GSM modem support</td>
+<td>Whether there is a GSM modem in the device. Default value is "yes".</td>
+<td>hw.gsmModem</td>
+</tr>
+
+<tr>
+<td>Camera support</td>
+<td>Whether the device has a camera. Default value is "no".</td>
+<td>hw.camera</td>
+</tr>
+
+<tr>
+<td>Maximum horizontal camera pixels</td>
+<td>Default value is "640".</td>
+<td>hw.camera.maxHorizontalPixels</td>
+</tr>
+
+<tr>
+<td>Maximum vertical camera pixels</td>
+<td>Default value is "480".</td>
+<td>hw.camera.maxVerticalPixels</td>
+</tr>
+
+<tr>
+<td>GPS support</td>
+<td>Whether there is a GPS in the device. Default value is "yes".</td>
+<td>hw.gps</td>
+</tr>
+
+<tr>
+<td>Battery support</td>
+<td>Whether the device can run on a battery. Default value is "yes".</td>
+<td>hw.battery</td>
+</tr>
+
+<tr>
+<td>Accelerometer</td>
+<td>Whether there is an accelerometer in the device. Default value is "yes".</td>
+<td>hw.accelerometer</td>
+</tr>
+
+<tr>
+<td>Audio recording support</td>
+<td>Whether the device can record audio. Default value is "yes".</td>
+<td>hw.audioInput</td>
+</tr>
+
+<tr>
+<td>Audio playback support</td>
+<td>Whether the device can play audio. Default value is "yes".</td>
+<td>hw.audioOutput</td>
+</tr>
+
+<tr>
+<td>SD Card support</td>
+<td>Whether the device supports insertion/removal of virtual SD Cards. Default value is "yes".</td>
+<td>hw.sdCard</td>
+</tr>
+
+<tr>
+<td>Cache partition support</td>
+<td>Whether we use a /cache partition on the device. Default value is "yes".</td>
+<td>disk.cachePartition</td>
+</tr>
+
+<tr>
+<td>Cache partition size</td>
+<td>Default value is "66MB".</td>
+<td>disk.cachePartition.size </td>
+</tr>
+
+<tr>
+<td>Abstracted LCD density</td>
+<td>Sets the generalized density characteristic used by the AVD's screen. Default value is "160".</td>
+<td>hw.lcd.density </td>
+</tr>
+
+<tr>
+<td>Trackball support</td>
+<td>Whether there is a trackball present.</td>
+<td>hw.trackBall </td>
+</tr>
+</table>
+
+
+<h2 id="moving">Moving an AVD</h2>
+
+<p>If you want to move or rename an AVD, you can do so using this command:</p>
+
+<pre>android move avd -n <name> [-<option> <value>] ...</pre>
+
+<h2 id="updating">Updating an AVD</h2>
+
+<p>If, for any reason, the platform/add-on root folder has its name changed (maybe because the user has installed an update of the platform/add-on) then the AVD will not be able to load the system image that it is mapped to. In this case, the <code>android list targets</code> command will produce this output:
+
+<pre>The following Android Virtual Devices could not be loaded:
+Name: foo
+Path: <path>/.android/avd/foo.avd
+Error: Invalid value in image.sysdir. Run 'android update avd -n foo' </pre>
+
+<p>To fix this error, use the <code>android update avd</code> command to recompute the path to the system images.</p>
+
+<h2 id="deleting">Deleting an AVD</h2>
+
+<p>You can use the <code>android</code> tool to delete an AVD. Here is the command usage:</p>
+
+<pre>android delete avd -n <name> </pre>
+
+<p>When you issue the command, the <code>android</code> tool looks for an AVD matching the
+specified name deletes the AVD's directory and files. </p>
diff --git a/docs/html/tools/devices/managing-avds.jd b/docs/html/tools/devices/managing-avds.jd
new file mode 100644
index 0000000..412bd91
--- /dev/null
+++ b/docs/html/tools/devices/managing-avds.jd
@@ -0,0 +1,237 @@
+page.title=Managing AVDs with AVD Manager
+parent.title=Managing Virtual Devices
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#createavd">Creating an AVD</a>
+ <ol>
+ <li><a href="#hardwareopts">Hardware options</a></li>
+ </ol>
+ </li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The AVD Manager is an easy to use user interface to manage your AVD (Android Virtual Device)
+ configurations. An AVD is a device configuration for the Android emulator that allows you to
+ model different configurations of Android-powered devices. When you start the AVD Manager in Eclipse
+ or run the <code>android</code> tool on the command line, you will see the AVD Manager as shown in
+ figure 1:</p>
+
+ <img src="{@docRoot}images/avd-manager.png">
+
+ <p class="img-caption"><strong>Figure 1. </strong>Screenshot of the AVD Manager. </p>
+
+ <p>From the main screen, you can create, delete, repair and start AVDs as well as see the details
+ of each AVD. </p>
+
+
+ <h2 id="createavd">Creating an AVD</h2>
+
+ <p>You can create as many AVDs as you would like to test on. It is recommended that you test your
+ applications on all API levels higher than the target API level for your application.</p>
+
+ <p>To create an AVD:</p>
+
+ <ol>
+ <li>Start the AVD Manager:
+
+ <ul>
+ <li>In Eclipse: select <strong>Window > AVD Manager</strong>, or click
+ the AVD Manager icon in the Eclipse toolbar.</li>
+
+ <li>In other IDEs: Navigate to your SDK's <code>tools/</code> directory and execute the
+ <code>android</code> tool with no arguments.</li>
+ </ul>
+ </li>
+
+ <li><p>In the <em>Virtual Devices</em> panel, you'll see a list of existing AVDs. Click
+ <strong>New</strong> to create a new AVD. The <strong>Create New AVD</strong> dialog appears.</p>
+
+ <img src="{@docRoot}images/developing/avd-dialog.png" alt="AVD Dialog">
+ <p class="img-caption"><strong>Figure 2.</strong> Screenshot of the Create AVD window</p>
+ </li>
+
+ <li>Fill in the details for the AVD.
+
+ <p>Give it a name, a platform target, an SD card size, and a skin (HVGA is default). You can
+ also add specific hardware features of the emulated device by clicking the
+ <strong>New...</strong> button and selecting the feature. For a list of hardware features,
+ see <a href="#hardwareopts">Hardware options</a>.</p>
+
+ <p class="note"><strong>Note:</strong> Be sure to define a target for your AVD that satisfies
+ your application's Build Target (the AVD platform target must have an API Level equal to or
+ greater than the API Level that your application compiles against).</p>
+ </li>
+
+ <li>Click <strong>Create AVD</strong>.</li>
+ </ol>
+
+ <p>Your AVD is now ready and you can either close the AVD Manager, create more AVDs, or
+ launch an emulator with the AVD by selecting a device and clicking <strong>Start</strong>.</p>
+
+<h3 id="hardwareopts">Hardware options</h3>
+<p>If you are creating a new AVD, you can specify the following hardware options for the AVD
+to emulate:</p>
+
+ <table>
+ <tr>
+ <th>Characteristic</th>
+
+ <th>Description</th>
+
+ <th>Property</th>
+ </tr>
+
+ <tr>
+ <td>Device ram size</td>
+
+ <td>The amount of physical RAM on the device, in megabytes. Default value is "96".</td>
+
+ <td>hw.ramSize</td>
+ </tr>
+
+ <tr>
+ <td>Touch-screen support</td>
+
+ <td>Whether there is a touch screen or not on the device. Default value is "yes".</td>
+
+ <td>hw.touchScreen</td>
+ </tr>
+
+ <tr>
+ <td>Trackball support</td>
+
+ <td>Whether there is a trackball on the device. Default value is "yes".</td>
+
+ <td>hw.trackBall</td>
+ </tr>
+
+ <tr>
+ <td>Keyboard support</td>
+
+ <td>Whether the device has a QWERTY keyboard. Default value is "yes".</td>
+
+ <td>hw.keyboard</td>
+ </tr>
+
+ <tr>
+ <td>DPad support</td>
+
+ <td>Whether the device has DPad keys. Default value is "yes".</td>
+
+ <td>hw.dPad</td>
+ </tr>
+
+ <tr>
+ <td>GSM modem support</td>
+
+ <td>Whether there is a GSM modem in the device. Default value is "yes".</td>
+
+ <td>hw.gsmModem</td>
+ </tr>
+
+ <tr>
+ <td>Camera support</td>
+
+ <td>Whether the device has a camera. Default value is "no".</td>
+
+ <td>hw.camera</td>
+ </tr>
+
+ <tr>
+ <td>Maximum horizontal camera pixels</td>
+
+ <td>Default value is "640".</td>
+
+ <td>hw.camera.maxHorizontalPixels</td>
+ </tr>
+
+ <tr>
+ <td>Maximum vertical camera pixels</td>
+
+ <td>Default value is "480".</td>
+
+ <td>hw.camera.maxVerticalPixels</td>
+ </tr>
+
+ <tr>
+ <td>GPS support</td>
+
+ <td>Whether there is a GPS in the device. Default value is "yes".</td>
+
+ <td>hw.gps</td>
+ </tr>
+
+ <tr>
+ <td>Battery support</td>
+
+ <td>Whether the device can run on a battery. Default value is "yes".</td>
+
+ <td>hw.battery</td>
+ </tr>
+
+ <tr>
+ <td>Accelerometer</td>
+
+ <td>Whether there is an accelerometer in the device. Default value is "yes".</td>
+
+ <td>hw.accelerometer</td>
+ </tr>
+
+ <tr>
+ <td>Audio recording support</td>
+
+ <td>Whether the device can record audio. Default value is "yes".</td>
+
+ <td>hw.audioInput</td>
+ </tr>
+
+ <tr>
+ <td>Audio playback support</td>
+
+ <td>Whether the device can play audio. Default value is "yes".</td>
+
+ <td>hw.audioOutput</td>
+ </tr>
+
+ <tr>
+ <td>SD Card support</td>
+
+ <td>Whether the device supports insertion/removal of virtual SD Cards. Default value is
+ "yes".</td>
+
+ <td>hw.sdCard</td>
+ </tr>
+
+ <tr>
+ <td>Cache partition support</td>
+
+ <td>Whether we use a /cache partition on the device. Default value is "yes".</td>
+
+ <td>disk.cachePartition</td>
+ </tr>
+
+ <tr>
+ <td>Cache partition size</td>
+
+ <td>Default value is "66MB".</td>
+
+ <td>disk.cachePartition.size</td>
+ </tr>
+
+ <tr>
+ <td>Abstracted LCD density</td>
+
+ <td>Sets the generalized density characteristic used by the AVD's screen. Default value is
+ "160".</td>
+
+ <td>hw.lcd.density</td>
+ </tr>
+ </table>
+
diff --git a/docs/html/tools/eclipse-adt.html b/docs/html/tools/eclipse-adt.html
new file mode 100644
index 0000000..0d59d49
--- /dev/null
+++ b/docs/html/tools/eclipse-adt.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/projects/projects-eclipse.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/projects/projects-eclipse.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/extras/index.jd b/docs/html/tools/extras/index.jd
new file mode 100644
index 0000000..8da26dc
--- /dev/null
+++ b/docs/html/tools/extras/index.jd
@@ -0,0 +1,5 @@
+page.title=Extras
+page.noplus=1
+@jd:body
+
+<p>SDK extras add functionality to your development environment. You can download all of the SDK extras into your development environment using the SDK Manager. </p>
diff --git a/docs/html/tools/extras/oem-usb.jd b/docs/html/tools/extras/oem-usb.jd
new file mode 100644
index 0000000..f7aa192
--- /dev/null
+++ b/docs/html/tools/extras/oem-usb.jd
@@ -0,0 +1,328 @@
+page.title=OEM USB Drivers
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#InstallingDriver">Installing a USB Driver</a>
+ <ol>
+ <li><a href="#Win7">Windows 7</a></li>
+ <li><a href="#WinXp">Windows XP</a></li>
+ <li><a href="#WinVista">Windows Vista</a></li>
+ </ol>
+ </li>
+ <li><a href="#Drivers">OEM Drivers</a></li>
+ </ol>
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/device.html">Using Hardware Devices</a></li>
+ <li><a href="{@docRoot}sdk/win-usb.html">Google USB Driver</a></li>
+ </ol>
+</div>
+</div>
+
+<p>If you are developing on Windows and would like to connect an Android-powered device
+to test your applications, then you need to install the appropriate USB driver. This document
+provides links to the web sites for several original equipment manufacturers (OEMs),
+where you can download the appropriate USB driver for your device. However, this list is
+not exhaustive for all available Android-powered devices.</p>
+
+<p>If you're developing on Mac OS X or Linux, then you probably don't need to install a USB driver.
+To start developing with your device, read <a
+href="{@docRoot}tools/device.html">Using Hardware Devices</a>.</p>
+
+<p class="note"><strong>Note:</strong> If your device is one of the Android Developer Phones
+(ADP), a Nexus One, or a Nexus S, then you need
+the <a href="{@docRoot}sdk/win-usb.html">Google USB Driver</a>, instead of an OEM driver. The Galaxy
+Nexus driver, however, is distributed by <a
+href="http://www.samsung.com/us/support/downloads/verizon-wireless/SCH-I515MSAVZW">Samsung</a>
+(listed as model SCH-I515).</p>
+
+
+<h2 id="InstallingDriver">Installing a USB Driver</h2>
+
+<p>First, find the appropriate driver for your device from the <a href="#Drivers">OEM drivers</a>
+table below.</p>
+
+<p>Once you've downloaded your USB driver, follow the instructions below to install or upgrade the
+driver, based on your version of Windows and whether you're installing for the first time
+or upgrading an existing driver.</p>
+
+<p class="note"><strong>Tip:</strong> When you finish the USB driver installation,
+see <a
+href="{@docRoot}tools/device.html">Using Hardware Devices</a> for
+other important information about using an Android-powered device for
+development.</p>
+
+<ol class="nolist">
+ <li><a href="#Win7">Windows 7</a></li>
+ <li><a href="#WinXp">Windows XP</a></li>
+ <li><a href="#WinVista">Windows Vista</a></li>
+</ol>
+
+
+<p class="caution"><strong>Caution:</strong>
+You may make changes to <code>android_winusb.inf</code> file found inside
+<code>usb_driver\</code> (for example, to add support for other devices),
+however, this will lead to security warnings when you install or upgrade the
+driver. Making any other changes to the driver files may break the installation
+process.</p>
+
+
+<h3 id="Win7">Windows 7</h3>
+
+
+<p>To install the Android USB driver on Windows 7 for the first time:</p>
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port.</li>
+ <li>Right-click on <em>Computer</em> from your desktop or Windows Explorer,
+ and select <strong>Manage</strong>.</li>
+ <li>Select <strong>Devices</strong> in the left pane.</li>
+ <li>Locate and expand <em>Other device</em> in the right pane.</li>
+ <li>Right-click the device name (such as <em>Nexus S</em>) and select <strong>Update
+ Driver Software</strong>.
+ This will launch the Hardware Update Wizard.</li>
+ <li>Select <strong>Browse my computer for driver software</strong> and click
+ <strong>Next</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
+ <li>Click <strong>Next</strong> to install the driver.</li>
+</ol>
+
+<p>Or, to <em>upgrade</em> an existing Android USB driver on Windows 7 with the new
+driver:</p>
+
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port.</li>
+ <li>Right-click on <em>Computer</em> from your desktop or Windows Explorer,
+ and select <strong>Manage</strong>.</li>
+ <li>Select <strong>Device Manager</strong> in the left pane of the Computer Management
+ window.</li>
+ <li>Locate and expand <em>Android Phone</em> in the right pane.</li>
+ <li>Right-click <em>Android Composite ADB Interface</em> and select <strong>Update
+ Driver</strong>.
+ This will launch the Hardware Update Wizard.</li>
+ <li>Select <strong>Install from a list or specific location</strong> and click
+ <strong>Next</strong>.</li>
+ <li>Select <strong>Search for the best driver in these locations</strong>; un-check
+<strong>Search removable media</strong>; and check <strong>Include this location in the
+search</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
+ <li>Click <strong>Next</strong> to upgrade the driver.</li>
+</ol>
+
+
+
+
+
+<h3 id="WinXp">Windows XP</h3>
+
+<p>To install the Android USB driver on Windows XP for the first time:</p>
+
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port. Windows
+ will detect the device and launch the Hardware Update Wizard.</li>
+ <li>Select <strong>Install from a list or specific location</strong> and click
+ <strong>Next</strong>.</li>
+ <li>Select <strong>Search for the best driver in these locations</strong>; un-check
+<strong>Search
+ removable media</strong>; and check <strong>Include
+this location in the search</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
+ <li>Click <strong>Next</strong> to install the driver.</li>
+</ol>
+
+<p>Or, to <em>upgrade</em> an existing Android USB driver on Windows XP with the new
+driver:</p>
+
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port.</li>
+ <li>Right-click on <em>My Computer</em> from your desktop or Windows Explorer,
+ and select <strong>Manage</strong>.</li>
+ <li>Select <strong>Device Manager</strong> in the left pane.</li>
+ <li>Locate and expand <em>Android Phone</em> in the right pane.</li>
+ <li>Right-click <em>Android Composite ADB Interface</em> and select <strong>Update
+ Driver</strong>.
+ This will launch the Hardware Update Wizard.</li>
+ <li>Select <strong>Install from a list or specific location</strong> and click
+ <strong>Next</strong>.</li>
+ <li>Select <strong>Search for the best driver in these locations</strong>; un-check <strong>Search
+ removable media</strong>; and check <strong>Include
+this location in the search</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.)</li>
+ <li>Click <strong>Next</strong> to upgrade the driver.</li>
+</ol>
+
+
+
+<h3 id="WinVista">Windows Vista</h3>
+
+<p>To install the Android USB driver on Windows Vista for the first time:</p>
+
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port. Windows
+ will detect the device and launch the Found New Hardware wizard.</li>
+ <li>Select <strong>Locate and install driver software</strong>.</li>
+ <li>Select <strong>Don't search online</strong>.</li>
+ <li>Select <strong>I don't have the disk. Show me other options</strong>.</li>
+ <li>Select <strong>Browse my computer for driver software</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.) As long as you specified the
+exact location of the
+ installation package, you may leave <strong>Include subfolders</strong> checked or
+ unchecked—it doesn't matter.</li>
+ <li>Click <strong>Next</strong>. Vista may prompt you to confirm the privilege elevation
+ required for driver installation. Confirm it.</li>
+ <li>When Vista asks if you'd like to install the Google ADB Interface device,
+ click <strong>Install</strong> to install the driver.</li>
+</ol>
+
+<p>Or, to <em>upgrade</em> an existing Android USB driver on Windows Vista with the new
+driver:</p>
+
+<ol>
+ <li>Connect your Android-powered device to your computer's USB port.</li>
+ <li>Right-click on <em>Computer</em> from your desktop or Windows Explorer,
+ and select <strong>Manage</strong>.</li>
+ <li>Select <strong>Device Manager</strong> in the left pane.</li>
+ <li>Locate and expand <em>ADB Interface</em> in the right pane.</li>
+ <li>Right-click on <em>HTC Dream Composite ADB Interface</em>, and select <strong>Update
+ Driver Software</strong>.</li>
+ <li>When Vista starts updating the driver, a prompt will ask how you want to
+ search for the driver
+ software. Select <strong>Browse my computer for driver software</strong>.</li>
+ <li>Click <strong>Browse</strong> and locate the USB driver folder. (The Google USB
+Driver is located in {@code <sdk>\extras\google\usb_driver\}.) As long as you specified the
+exact location of the
+ installation package, you may leave <strong>Include subfolders</strong> checked or
+ unchecked—it doesn't matter.</li>
+ <li>Click <strong>Next</strong>. Vista might prompt you to confirm the privilege elevation
+ required for driver installation. Confirm it.</li>
+ <li>When Vista asks if you'd like to install the Google ADB Interface device,
+ click <strong>Install</strong> to upgrade the driver.</li>
+</ol>
+
+
+<h2 id="Drivers">OEM Drivers</h2>
+
+<p class="note"><strong>Note:</strong> If your device is one of the Android Developer Phones
+(purchased from the Google Play publisher site), a Nexus One, or a Nexus S, then you need
+the <a href="{@docRoot}sdk/win-usb.html">Google USB Driver</a>, instead of an OEM driver. The Galaxy
+Nexus driver, however, is distributed by <a
+href="http://www.samsung.com/us/support/downloads/verizon-wireless/SCH-I515MSAVZW">Samsung</a>
+(listed as model SCH-I515).</p>
+
+
+<table><tr>
+ <th>OEM</th>
+ <th>Driver URL</th></tr>
+<tr><td>Acer</td> <td><a
+href="http://www.acer.com/worldwide/support/mobile.html">http://www.acer.com/worldwide/support/mobile.html</a>
+ </td></tr>
+ <tr>
+ <td style="font-variant:small-caps">alcatel one touch</td>
+ <td><a
+href="http://www.alcatel-mobilephones.com/global/Android-Downloads">http://www.alcatel-mobilephones.com/global/Android-Downloads</a></td>
+ </tr>
+ <tr>
+ <td>Asus</td>
+ <td><a href="http://support.asus.com/download/">http://support.asus.com/download/</a></td>
+ </tr>
+ <tr><td>
+ Dell
+ </td> <td>
+ <a
+href="http://support.dell.com/support/downloads/index.aspx?c=us&cs=19&l=en&s=dhs&~ck=anavml">http://support.dell.com/support/downloads/index.aspx?c=us&cs=19&l=en&s=dhs&~ck=anavml</a> </td></tr>
+
+<tr><td>Foxconn</td> <td><a
+href="http://drivers.cmcs.com.tw/">http://drivers.cmcs.com.tw/</a></td>
+</tr>
+ <tr>
+ <td>
+ Fujitsu
+ </td>
+ <td><a
+href="http://www.fmworld.net/product/phone/sp/android/develop/">http://www.fmworld.net/product/phone/sp/android/develop/</a>
+ </td>
+ </tr>
+ <tr>
+ <td>
+ Fujitsu Toshiba
+ </td>
+ <td><a
+href="http://www.fmworld.net/product/phone/sp/android/develop/">http://www.fmworld.net/product/phone/sp/android/develop/</a>
+ </td>
+ </tr>
+ <tr><td>
+ Garmin-Asus
+ </td> <td><a
+href="https://www.garminasus.com/en_US/support/pcsync/">https://www.garminasus.com/en_US/support/pcsync/</a></td>
+</tr>
+
+<tr><td>Hisense</td>
+ <td><a
+href="http://app.hismarttv.com/dss/resourcecontent.do?method=viewResourceDetail&resourceId=16&type=5">http://app.hismarttv.com/dss/resourcecontent.do?method=viewResourceDetail&resourceId=16&type=5 </a></td>
+</tr>
+
+<tr><td>HTC</td> <td><a href="http://www.htc.com">http://www.htc.com </a> <br>Click on the
+support tab to select your products/device. Different regions will have different links.</td>
+</tr>
+
+<tr><td>Huawei</td> <td><a
+href="http://www.huaweidevice.com/worldwide/downloadCenter.do?method=index">http://www.huaweidevice.com/worldwide/downloadCenter.do?method=index</a></td>
+</tr>
+
+<tr><td>Intel</td> <td><a
+href="http://www.intel.com/software/android">http://www.intel.com/software/android</a></td>
+</tr>
+
+<tr><td>KT Tech</td> <td><a
+href="http://www.kttech.co.kr/cscenter/download05.asp">http://www.kttech.co.kr/cscenter/download05.asp</a> for EV-S100 (Take)</td>
+</tr>
+ <tr>
+ <td>
+ Kyocera
+ </td>
+ <td><a href="http://www.kyocera-wireless.com/support/phone_drivers.htm">http://www.kyocera-wireless.com/support/phone_drivers.htm</a>
+ </td>
+ </tr>
+ <tr>
+ <td>Lenevo</td>
+ <td><a href="http://developer.lenovomm.com/developer/download.jsp"
+ >http://developer.lenovomm.com/developer/download.jsp</a>
+ </td>
+ </tr>
+ <tr><td>LGE</td> <td><a
+href="http://www.lg.com/us/mobile-phones/mobile-support/mobile-lg-mobile-phone-support.jsp">http://www.lg.com/us/mobile-phones/mobile-support/mobile-lg-mobile-phone-support.jsp</a></td>
+</tr><tr><td>Motorola</td> <td><a
+href="http://developer.motorola.com/docstools/USB_Drivers/">http://developer.motorola.com/docstools/USB_Drivers/</a></td>
+</tr><tr><td>Pantech</td> <td><a
+href="http://www.isky.co.kr/cs/software/software.sky?fromUrl=index">http://www.isky.co.kr/cs/software/software.sky?fromUrl=index</a></td>
+</tr><tr><td>Pegatron</td> <td><a
+href="http://www.pegatroncorp.com/download/New_Duke_PC_Driver_0705.zip">http://www.pegatroncorp.com/download/New_Duke_PC_Driver_0705.zip</a> (ZIP download)</td>
+</tr><tr><td>Samsung</td> <td><a
+href="http://www.samsung.com/us/support/downloads">http://www.samsung.com/us/support/downloads</a></td>
+</tr><tr><td>Sharp</td> <td><a
+href="http://k-tai.sharp.co.jp/support/">http://k-tai.sharp.co.jp/support/</a></td>
+</tr><tr><td>SK Telesys</td> <td><a
+href="http://www.sk-w.com/service/wDownload/wDownload.jsp">http://www.sk-w.com/service/wDownload/wDownload.jsp</a></td></tr><tr>
+<td>Sony Ericsson</td> <td><a
+href="http://developer.sonyericsson.com/wportal/devworld/search-downloads/driver?cc=gb&lc=en">http://developer.sonyericsson.com/wportal/devworld/search-downloads/driver?cc=gb&lc=en</a></td></tr>
+
+<tr><td>Teleepoch</td> <td><a
+href="http://www.teleepoch.com/android.html">http://www.teleepoch.com/android.html</a></td>
+</tr>
+
+<tr><td>Yulong Coolpad</td> <td><a
+href="http://www.yulong.com/product/product/product/downloadList.html#downListUL">http://www.yulong.com/product/product/product/downloadList.html#downListUL</a></td>
+</tr>
+
+<tr>
+<td>ZTE</td> <td><a
+href="http://support.zte.com.cn/support/news/NewsDetail.aspx?newsId=1000442">http://support.zte.com.cn/support/news/NewsDetail.aspx?newsId=1000442</a></td></tr>
+</table>
diff --git a/docs/html/tools/extras/support-library.jd b/docs/html/tools/extras/support-library.jd
new file mode 100644
index 0000000..7258c77
--- /dev/null
+++ b/docs/html/tools/extras/support-library.jd
@@ -0,0 +1,507 @@
+page.title=Support Library
+
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>In this document</h2>
+<ol>
+ <li><a href="#Notes">Revisions</a></li>
+ <li><a href="#Downloading">Downloading the Support Package</a></li>
+ <li><a href="#SettingUp">Setting Up a Project to Use a Library</a></li>
+ <li><a href="#Using">Using the v4 Library APIs</a></li>
+ <li><a href="#Docs">Reference Docs</a></li>
+ <li><a href="#Samples">Samples</a></li>
+</ol>
+
+<h2>See also</h2>
+<ol>
+ <li><a
+href="{@docRoot}guide/practices/optimizing-for-3.0.html">Optimizing Apps for Android 3.0</a></li>
+ <li><a href="http://code.google.com/p/iosched/">Google I/O App source code</a></li>
+</ol>
+
+</div>
+</div>
+
+<p><em>Minimum API level supported:</em> <b>4</b></p>
+
+<p>The Support Package includes static "support libraries" that you can add to your Android
+application in order to use APIs that are either not available for older platform versions or that
+offer "utility" APIs that aren't a part of the framework APIs. The goal is to simplify your
+development by offering more APIs that you can bundle with your application so you can
+worry less about platform versions.</p>
+
+<p class="note"><strong>Note:</strong> The Support Package includes more than one support
+library. Each one has a different <em>minimum API level</em>. For example, one library requires API
+level 4 or higher, while another requires API level 13 or higher (v13 is a superset of v4 and
+includes additional
+support classes to work with v13 APIs). The minimum version is indicated
+by the directory name, such as {@code v4/} and {@code v13/}.</p>
+
+
+<h2 id="Notes">Revisions</h2>
+
+<p>The sections below provide notes about successive releases of
+the Support Package, as denoted by revision number.</p>
+
+<div class="toggle-content open">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-content-img" />
+ Support Package, revision 8 (April 2012)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Fixed intent flags for {@link android.app.PendingIntent} objects generated
+ by {@link android.support.v4.app.TaskStackBuilder}.</li>
+ <li>Removed unused attributes from the gridlayout library projects to make sure
+ the library can be built with API Level 7 and higher.</li>
+ <li>Added {@code .classpath} and {@code .project} files for the gridlayout
+ library project.</li>
+ </ul>
+ </dd>
+ </dl>
+</div>
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Support Package, revision 7 (March 2012)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Added {@link android.support.v4.app.ShareCompat}, which provides helper classes
+for sending and receiving content for social sharing applications, including new metadata for
+attributing shared data to the source app. This class also provides compatible integration with the
+new {@link android.widget.ShareActionProvider} in Android 4.0.</li>
+ <li>Added {@link android.support.v4.app.NavUtils} and {@link
+android.support.v4.app.TaskStackBuilder} to provide support for implementing the
+<a href="{@docRoot}design/index.html">Android Design</a> guidelines for navigation. These
+additions include a way to implement the action bar's <em>Up</em> button across versions.
+For an example implementation of this pattern, see the AppNavigation sample in
+({@code <em><sdk></em>/samples/<em><platform></em>/AppNavigation}).</li>
+ <li>Added {@link android.support.v4.app.NotificationCompat.Builder} to provide a
+compatibility implementation of Android 3.0's {@link android.app.Notification.Builder} helper class
+for creating standardized system notifications.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Support Package, revision 6 (December 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <p class="note"><strong>Note:</strong> Reference for support library APIs are now available with
+ the framework references, for example: {@link android.support.v4.app}.</p>
+<dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Changes to ViewPager:
+ <ul>
+ <li>Added extra decorative view support for {@link android.support.v4.view.ViewPager}.
+ Decorative views may be supplied as child views of a pager in XML layout.</li>
+ <li>Added {@link android.support.v4.view.PagerAdapter#getPageTitle
+ PagerAdapter.getPageTitle()} to supply title strings for pages, which defaults to no
+ title for each page.</li>
+ <li>Added {@link android.support.v4.view.PagerTitleStrip}, a non-interactive title
+ strip, that can be added as a child of ViewPager. Developers can supply text
+ appearance and color, as well as layout sizing and gravity information.</li>
+ <li>Updated {@link android.support.v4.view.PagerAdapter} methods to take ViewGroup
+ objects, rather than View to avoid class casting in adapter implementations.</li>
+ <li>Updated {@link android.support.v4.view.ViewPager} to use Launcher-style
+ fling behavior.</li>
+ <li>Bug fixes for user interface interaction and test automation.</li>
+ </ul>
+ </li>
+
+ <li>Support for Fragments:
+ <ul>
+ <li>Changed {@code setStartDeferred()} method to {@link
+ android.support.v4.app.Fragment#setUserVisibleHint}.</li>
+ <li>Added deferred start for off-screen pages to improve performance.</li>
+ </ul>
+ </li>
+
+ <li>Support for Accessiblity APIs:
+ <ul>
+ <li>Updated {@link android.support.v4.view.AccessibilityDelegateCompat} methods
+ to return empty lists instead of null.</li>
+ <li>Added new APIs needed by the v4 samples.</li>
+ </ul>
+ </li>
+
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Support Package, revision 5 (December 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Support for Accessiblity APIs:
+ <ul>
+ <li>Added {@link android.support.v4.view.AccessibilityDelegateCompat}
+ to support {@link android.view.View.AccessibilityDelegate}.</li>
+
+ <li>Added {@link android.support.v4.view.accessibility.AccessibilityEventCompat}
+ to support {@link android.view.accessibility.AccessibilityEvent}.</li>
+
+ <li>Added {@link android.support.v4.view.accessibility.AccessibilityManagerCompat}
+ to support {@link android.view.accessibility.AccessibilityManager}.</li>
+
+ <li>Added {@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat}
+ to support {@link android.view.accessibility.AccessibilityNodeInfo}.</li>
+
+ <li>Added {@link android.support.v4.view.accessibility.AccessibilityRecordCompat}
+ to support {@link android.view.accessibility.AccessibilityRecord}.</li>
+
+ <li>Added {@link
+ android.support.v4.accessibilityservice.AccessibilityServiceInfoCompat}
+ to support {@link android.accessibilityservice.AccessibilityServiceInfo}.</li>
+
+ <li>Added {@link android.support.v4.view.ViewGroupCompat}
+ to support accessibility features in {@link android.view.ViewGroup}.
+ </li>
+
+ <li>Modified {@link android.support.v4.view.ViewCompat}
+ to support accessibility features in {@link android.view.View}.</li>
+ </ul>
+ </li>
+
+ <li>Changes to ViewPager:
+ <ul>
+ <li>Added support for margins between pages.
+ An optional {@link android.graphics.drawable.Drawable} can be provided
+ to fill the margins.</li>
+ <li>Added support for {@link android.widget.EdgeEffect}.</li>
+ <li>Added support for keyboard navigation</li>
+ <li>Added support to control how many pages are kept to either side
+ of the current page.</li>
+ <li>Improved touch physics.</li>
+ <li>Bug fixes for user interface behavior.</li>
+ </ul>
+ </li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Support Package, revision 4 (October 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Added <code>EdgeEffectCompat</code> to
+ support {@link android.widget.EdgeEffect}.</li>
+
+ <li>Added <code>LocalBroadcastManager</code> to allow applications to easily
+ register for and receive intents within a single application without
+ broadcasting them globally.</li>
+
+ <li>Added support in <code>ViewCompat</code> to check for and set overscroll
+ modes for {@link android.view.View}s on Android 2.3 and later.</li>
+ <li>Changes to Fragment APIs:
+ <ul>
+ <li>Added new APIs to control the visibility of new menus.</li>
+ <li>Added custom animation APIs.</li>
+ <li>Added APIs in <code>FragmentActivity</code> to retain custom,
+ non-configuration instance data.</li>
+ <li>Various bug fixes.</li>
+ </ul>
+ </li>
+
+ <li>Fixed a {@link android.content.Loader} bug that caused issues in
+ canceling {@link android.os.AsyncTask}s when running on Froyo and older
+ versions of the platform. The support
+ code now uses its own version of {@link android.os.AsyncTask} to keep the same
+ behavior on all platform versions.</li>
+
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+
+
+</div>
+
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Compatibility Package, revision 3 (July 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 support library:</dt>
+ <dd>
+ <ul>
+ <li>Adds support for {@link android.app.Fragment.SavedState}</li>
+ <li>Adds {@code MotionEventCompat} to support newer {@link
+android.view.MotionEvent} APIs</li>
+ <li>Adds {@code VelocityTrackerCompat} to support a newer {@link
+android.view.VelocityTracker} APIs</li>
+ <li>Adds {@code ViewConfigurationCompat} to support a newer {@link
+android.view.ViewConfiguration} APIs</li>
+ <li>All new APIs (available only in the support library) that allow you to create UIs
+with horizontal paging, allowing users to swipe left and right between content views. Classes to
+support this include:
+ <ul>
+ <li>{@code ViewPager}: A {@link android.view.ViewGroup} that manages the
+layout for the child views, which the user can swipe between.</li>
+ <li>{@code PagerAdapter}: An adapter that populates the {@code ViewPager} with the
+views that represent each page.</li>
+ <li>{@code FragmentPagerAdapter}: An extension of {@code PagerAdapter} for flipping
+between fragments.</li>
+ <li>{@code FragmentStatePagerAdapter}: An extension of {@code PagerAdapter} for
+flipping between fragments that uses the library's support for {@link
+android.app.Fragment.SavedState}.</li>
+ </ul>
+ </li>
+ </ul>
+ </dd>
+ <dt>New v13 support library:</dt>
+ <dd>
+ <ul>
+ <li>Includes the {@code FragmentPagerAdapter} and {@code FragmentStatePagerAdapter}
+to support the horizontal paging.
+ <p>These are exactly the same as the APIs added to the v4 support library, but rely on
+other platform components in Android 3.2. Use this library instead of v4 if you're developing for
+Android 3.2 and higher (all other APIs in the v4 library are already available with API level
+13).</p>
+ </li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+</div>
+
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Compatibility Package, revision 2 (May 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <dl>
+ <dt>Changes for v4 library:</dt>
+ <dd>
+ <ul>
+ <li>Support for fragment animations</li>
+ <li>Fix {@code android.support.v4.app.Fragment#onActivityResult Fragment.onActivityResult()}
+ bug</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+
+</div>
+
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" />
+ Compatibility Package, revision 1 (March 2011)
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em">
+ <p>Initial release with the v4 library.</p>
+ </div>
+
+</div>
+
+
+
+<h2 id="Downloading">Downloading the Support Package</h2>
+
+<p>The Support Package is provided as a downloadable package from the Android SDK
+Manager. To install:</p>
+
+<ol>
+ <li>Launch the Android SDK Manager.
+ <p>From Eclipse, you can select <strong>Window</strong>
+> <strong>Android SDK Manager</strong>. Or, launch {@code SDK Manager.exe} from
+the {@code <sdk>/} directory (on Windows only) or {@code android} from the {@code
+<sdk>/tools/} directory.</p></li>
+ <li>Expand the Android Repository, check <strong>Android Support package</strong>
+and click <strong>Install selected</strong>.</li>
+ <li>Proceed to install the package.</li>
+</ol>
+
+<p>When done, all files (including source code, samples, and the {@code .jar} files) are saved
+into the <code><sdk>/extras/android/support/</code> directory. This directory contains
+each of the different support libraries, such as the library for API level 4 and up and the library
+for API level 13 and up, each named with the respective version (such as {@code v4/}).</p>
+
+
+<h2 id="SettingUp">Setting Up a Project to Use a Library</h2>
+
+<p>To add one of the libraries to your Android project:</p>
+<ol>
+ <li>In your Android project, create a directory named {@code libs} at the root of your
+project (next to {@code src/}, {@code res/}, etc.)</li>
+ <li>Locate the JAR file for the library you want to use and copy it into the {@code
+libs/} directory.
+ <p>For example, the library that supports API level 4 and up is located at {@code
+<sdk>/extras/android/support/v4/android-support-v4.jar}.</p>
+ </li>
+ <li>Add the JAR to your project build path.
+ <p>In Eclipse, right-click the JAR file in the Package Explorer, select <strong>Build
+Path</strong> > <strong>Add to Build Path</strong>.</p>
+ </li>
+</ol>
+
+<p>Your application is now ready to use the library APIs. All the
+provided APIs are available in the {@code android.support} package (for
+example, {@code android.support.v4}).</p>
+
+<p class="note"><strong>Tip:</strong> To see the library APIs in action, take a look at the sample
+apps in {@code <sdk>/extras/android/support/<version>/samples/}.</p>
+
+<p class="warning"><strong>Warning:</strong> Be certain that you not confuse the standard
+{@code android} packages with those in {@code android.support} library. Some code completion tools
+might
+get this wrong, especially if you're building against recent versions of the platform. To be safe,
+keep your build target set to the same version as you have defined for your <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code android:minSdkVersion}</a>
+and double check the import statements for classes that also exist in the support library, such as
+{@code SimpleCursorAdapter}.</p>
+
+
+<h2 id="Using">Using the v4 Library APIs</h2>
+
+<p>The support library for v4 provides access to several classes introduced with Android 3.0 and
+beyond, plus some updated version of existing classes, and even some APIs that currently don't
+exist in the Android platform. Some of the most useful and notable classes that have
+counterparts in the v4 support library are:</p>
+
+<ul>
+ <li>{@link android.app.Fragment}</li>
+ <li>{@link android.app.FragmentManager}</li>
+ <li>{@link android.app.FragmentTransaction}</li>
+ <li>{@link android.app.ListFragment}</li>
+ <li>{@link android.app.DialogFragment}</li>
+ <li>{@link android.app.LoaderManager}</li>
+ <li>{@link android.content.Loader}</li>
+ <li>{@link android.content.AsyncTaskLoader}</li>
+ <li>{@link android.content.CursorLoader}</li>
+</ul>
+
+<p>For each of the classes above (and others not listed), the APIs work almost exactly the same
+as the counterparts in the latest Android platform. Thus, you can usually refer to
+the online documentation for information about the supported APIs. There are some
+differences, however. Most notably:</p>
+
+<ul>
+ <li>When creating an activity to use fragments, you must declare your activity to extend the
+{@link android.support.v4.app.FragmentActivity} class (instead of the traditional
+{@link android.app.Activity} class).</li>
+ <li>To manage your fragments and loaders, you must use the methods
+ {@link android.support.v4.app.FragmentActivity#getSupportFragmentManager
+ FragmentActivity.getSupportFragmentManager()} and
+ {@link android.support.v4.app.FragmentActivity#getSupportLoaderManager
+ FragmentActivity.getSupportLoaderManager()} (instead of the
+ {@link android.app.Activity#getFragmentManager()} and
+ {@link android.app.Activity#getLoaderManager()} methods).</li>
+ <li>The {@link android.app.ActionBar} is <strong>not supported</strong> by the library.
+However, when creating your <a href="{@docRoot}guide/topics/ui/menus.html#options-menu">Options
+Menu</a>, you can declare which items should be added to the Action Bar when it's available (on
+Android 3.0 or later). You can do so with the
+{@link android.support.v4.view.MenuCompat#setShowAsAction MenuCompat.setShowAsAction()} method, for
+example:
+<pre>
+public boolean onCreateOptionsMenu(Menu menu) {
+ MenuInflater inflater = getMenuInflater();
+ inflater.inflate(R.menu.options, menu);
+ MenuCompat.setShowAsAction(menu.findItem(R.id.action_search), 1);
+ return true;
+}
+</pre>
+<p>Also see the <a href="{@docRoot}resources/samples/ActionBarCompat/index.html">Action Bar
+Compatibility</a> sample for a demonstration of how to use {@link android.app.ActionBar} on Android
+3.0+ and also support action bar functionality on older versions.</p>
+</li>
+</ul>
+
+<div class="note"><p><strong>Tip:</strong> To enable the Holographic theme on devices
+running Android 3.0 or higher, declare in your manifest file that your application targets
+API level 11, for example:</p>
+<pre>
+<uses-sdk android:minSdkVersion="4" android:targetSdkVersion="11" />
+</pre>
+<p>This way, your application automatically receives the Holographic theme and the Action Bar for
+each activity when running on Android 3.0 and higher.</p>
+</div>
+
+<p>For more information about how you can optimize your application for the latest
+Android-powered devices, read <a href="{@docRoot}guide/practices/optimizing-for-3.0.html">Optimizing
+Apps for Android 3.0</a>.</p>
+
+
+<h2 id="Docs">Reference Docs</h2>
+
+<p>The reference documentation for the Support Packages is included as part of the Android
+online developer documentation:</p>
+
+<ul>
+ <li><a href="{@docRoot}reference/android/support/v4/app/package-summary.html">Support Package
+ API 4 Reference</a></li>
+ <li><a href="{@docRoot}reference/android/support/v13/app/package-summary.html">Support Package
+ API 13 Reference</a></li>
+</ul>
+
+
+<h2 id="Samples">Samples</h2>
+
+<p>If you want to see some code that uses the support libraries, samples are included with the
+Support Package, inside each support library directory, for example; {@code
+<sdk>/extras/android/support/v4/samples/}. You can also view these samples as part of the
+Android online developer documentation:</p>
+
+<ul>
+ <li><a href="{@docRoot}resources/samples/Support4Demos/index.html">Support API 4 Demos</a></li>
+ <li><a href="{@docRoot}resources/samples/Support13Demos/index.html">Support API 13 Demos</a></li>
+</ul>
+
+<p>Additionally, the <a href="http://code.google.com/p/iosched/">Google I/O App</a> is a complete
+application that uses the v4 support library to provide a single APK for both handsets and tablets
+and also demonstrates some of Android's best practices in Android UI design.</p>
diff --git a/docs/html/tools/help/MonkeyDevice.jd b/docs/html/tools/help/MonkeyDevice.jd
new file mode 100644
index 0000000..e7612e6
--- /dev/null
+++ b/docs/html/tools/help/MonkeyDevice.jd
@@ -0,0 +1,1355 @@
+page.title=MonkeyDevice
+parent.title=monkeyrunner
+parent.link=index.html
+@jd:body
+<style>
+ h4.jd-details-title {background-color: #DEE8F1;}
+</style>
+<p>
+ A monkeyrunner class that represents a device or emulator accessible by the workstation running
+<code><a href="{@docRoot}tools/help/monkeyrunner_concepts.html">monkeyrunner</a></code>.
+</p>
+<p>
+ This class is used to control an Android device or emulator. The methods send UI events,
+ retrieve information, install and remove applications, and run applications.
+</p>
+<p>
+ You normally do not have to create an instance of <code>MonkeyDevice</code>. Instead, you
+ use
+<code><a href="{@docRoot}tools/help/MonkeyRunner.html#waitForConnection">
+MonkeyRunner.waitForConnection()</a></code> to create a new object from a connection to a device or
+emulator. For example, instead of
+using:</p>
+<pre>
+newdevice = MonkeyDevice()
+</pre>
+<p>
+ you would use:
+</p>
+<pre>
+newdevice = MonkeyRunner.waitForConnection()
+</pre>
+<h2>Summary</h2>
+ <table id="constants" class="jd-sumtable" style="background-color: white;">
+ <tr>
+ <th colspan="12" style="background-color: #E2E2E2">Constants</th>
+ </tr>
+ <tr class="api" style="background-color: white;">
+ <td class="jd-typecol"><em>string</em></td>
+ <td class="jd-linkcol"><a href="#ACTION_DOWN">DOWN</a></td>
+ <td class="jd-descrcol" width="100%">
+ Use this with the <code>type</code> argument of
+ <code><a href="#press">press()</a></code> or <code><a href="#touch">touch()</a>
+ </code>
+ to send a DOWN event.
+ </td>
+ </tr>
+ <tr class="api" style="background-color: white;">
+ <td class="jd-typecol"><em>string</em></td>
+ <td class="jd-linkcol"><a href="#ACTION_UP">UP</a></td>
+ <td class="jd-descrcol" width="100%">
+ Use this with the <code>type</code> argument of
+ <code><a href="#press">press()</a></code> or <code><a href="#touch">touch()</a>
+ </code>
+ to send an UP event.
+ </td>
+ </tr>
+ <tr class="api" style="background-color: white;">
+ <td class="jd-typecol"><em>string</em></td>
+ <td class="jd-linkcol"><a href="#ACTION_DOWN_AND_UP">DOWN_AND_UP</a></td>
+ <td class="jd-descrcol" width="100%">
+ Use this with the <code>type</code> argument of
+ <code><a href="#press">press()</a></code> or <code><a href="#touch">touch()</a>
+ </code>
+ to send a DOWN event immediately followed by an UP event.
+ </td>
+ </tr>
+ </table>
+<table id="pubmethods" class="jd-sumtable">
+ <tr>
+ <th colspan="12" style="background-color: #E2E2E2">Methods</th>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#broadcastIntent">broadcastIntent</a>
+ </span>
+ (<em>string</em> uri,
+ <em>string</em> action,
+ <em>string</em> data,
+ <em>string</em> mimetype,
+ <em>iterable</em> categories
+ <em>dictionary</em> extras,
+ <em>component</em> component,
+ <em>iterable</em> flags)
+ </nobr>
+ <div class="jd-descrdiv">
+ Broadcasts an Intent to this device, as if the Intent were coming from an
+ application.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#drag">drag</a>
+ </span>
+ (<em>tuple</em> start,
+ <em>tuple</em> end,
+ <em>float</em> duration,
+ <em>integer</em> steps)
+ </nobr>
+ <div class="jd-descrdiv">
+ Simulates a drag gesture (touch, hold, and move) on this device's screen.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>object</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#getProperty">getProperty</a>
+ </span>
+ (<em>string</em> key)
+ </nobr>
+ <div class="jd-descrdiv">
+ Given the name of a system environment variable, returns its value for this device.
+ The available variable names are listed in the <a href="#getProperty">
+ detailed description</a> of this method.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>object</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#getSystemProperty">getSystemProperty</a>
+ </span>
+ (<em>string</em> key)
+ </nobr>
+ <div class="jd-descrdiv">
+. The API equivalent of <code>adb shell getprop <key>. This is provided for use
+ by platform developers.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#installPackage">installPackage</a>
+ </span>
+ (<em>string</em> path)
+ </nobr>
+ <div class="jd-descrdiv">
+ Installs the Android application or test package contained in packageFile onto this
+ device. If the application or test package is already installed, it is replaced.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>dictionary</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#instrument">instrument</a>
+ </span>
+ (<em>string</em> className,
+ <em>dictionary</em> args)
+ </nobr>
+ <div class="jd-descrdiv">
+ Runs the specified component under Android instrumentation, and returns the results
+ in a dictionary whose exact format is dictated by the component being run. The
+ component must already be present on this device.
+ </div>
+ </td>
+ </tr>
+ <tr class="api">
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#press">press</a>
+ </span>
+ (<em>string</em> name,
+ <em>dictionary</em> type)
+ </nobr>
+ <div class="jd-descrdiv">
+ Sends the key event specified by type to the key specified by
+ keycode.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#reboot">reboot</a>
+ </span>
+ (<em>string</em> into)
+ </nobr>
+ <div class="jd-descrdiv">
+ Reboots this device into the bootloader specified by bootloadType.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#removePackage">removePackage</a>
+ </span>
+ (<em>string</em> package)
+ </nobr>
+ <div class="jd-descrdiv">
+ Deletes the specified package from this device, including its data and cache.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>object</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#shell">shell</a>
+ </span>
+ (<em>string</em> cmd)
+ </nobr>
+ <div class="jd-descrdiv">
+ Executes an <code>adb</code> shell command and returns the result, if any.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#startActivity">startActivity</a>
+ </span>
+ (<em>string</em> uri,
+ <em>string</em> action,
+ <em>string</em> data,
+ <em>string</em> mimetype,
+ <em>iterable</em> categories
+ <em>dictionary</em> extras,
+ <em>component</em> component,
+ <em>flags</em>)
+ </nobr>
+ <div class="jd-descrdiv">
+ Starts an Activity on this device by sending an Intent constructed from the
+ supplied arguments.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">
+ MonkeyImage
+ </a>
+ </code>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#takeSnapshot">takeSnapshot</a>()
+ </span>
+ </nobr>
+ <div class="jd-descrdiv">
+ Captures the entire screen buffer of this device, yielding a
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">
+ MonkeyImage
+ </a>
+ </code> object containing a screen capture of the current display.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#touch">touch</a>
+ </span>
+ (<em>integer</em> x,
+ <em>integer</em> y,
+ <em>integer</em> type)
+ </nobr>
+ <div class="jd-descrdiv">
+ Sends a touch event specified by type to the screen location specified
+ by x and y.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#touch">type</a>
+ </span>
+ (<em>string</em> message)
+ </nobr>
+ <div class="jd-descrdiv">
+ Sends the characters contained in message to this device, as if they
+ had been typed on the device's keyboard. This is equivalent to calling
+ <code><a href="#press">press()</a></code> for each keycode in <code>message</code>
+ using the key event type <code><a href="#ACTION_DOWN_AND_UP"></a>DOWN_AND_UP</code>.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#touch">wake</a>
+ </span>
+ ()
+ </nobr>
+ <div class="jd-descrdiv">
+ Wakes the screen of this device.
+ </div>
+ </td>
+ </tr>
+</table>
+<!-- ========= ENUM CONSTANTS DETAIL ======== -->
+<h2>Constants</h2>
+<A NAME="ACTION_DOWN"></a>
+<div class="jd-details api">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ DOWN
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ <code><a href="#press">press()</a></code> or
+ <code><a href="#press">touch()</a></code> value.
+ Specifies that a DOWN event type should be sent to the device, corresponding to
+ pressing down on a key or touching the screen.
+ </p>
+ </div>
+ </div>
+</div>
+<A NAME="ACTION_UP"></A>
+<div class="jd-details api">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ UP
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ <code><a href="#press">press()</a></code> or
+ <code><a href="#press">touch()</a></code> value.
+ Specifies that an UP event type should be sent to the device, corresponding to
+ releasing a key or lifting up from the screen.
+ </p>
+ </div>
+ </div>
+</div>
+<A NAME="ACTION_DOWN_AND_UP"></A>
+
+<div class="jd-details api">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ DOWN_AND_UP
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ <code><a href="#press">press()</a></code>,
+ <code><a href="#press">touch()</a></code> or
+ <code><a href="#type">type()</a></code> value.
+ Specifies that a DOWN event type followed by an UP event type should be sent to the
+ device, corresponding to typing a key or clicking the screen.
+ </p>
+ </div>
+ </div>
+</div>
+<!-- ========= METHOD DETAIL ======== -->
+<!-- Public methods -->
+<h2>Public Methods</h2>
+<A NAME="broadcastIntent"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">broadcastIntent</span>
+ <span class="normal">
+ (
+ <em>string</em> uri,
+ <em>string</em> action,
+ <em>string</em> data,
+ <em>string</em> mimetype,
+ <em>iterable</em> categories
+ <em>dictionary</em> extras,
+ <em>component</em> component,
+ <em>iterable</em> flags)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Broadcasts an Intent to this device, as if the Intent were coming from an
+ application. See {@link android.content.Intent Intent} for more information about the
+ arguments.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>uri</th>
+ <td>
+ The URI for the Intent.
+ (see {@link android.content.Intent#setData(android.net.Uri) Intent.setData()}).
+ </td>
+ </tr>
+ <tr>
+ <th>action</th>
+ <td>
+ The action for this Intent
+ (see {@link android.content.Intent#setAction(java.lang.String) Intent.setAction()}).
+ </td>
+ </tr>
+ <tr>
+ <th>data</th>
+ <td>
+ The data URI for this Intent
+ (see {@link android.content.Intent#setData(android.net.Uri) Intent.setData()}).
+ </td>
+ </tr>
+ <tr>
+ <th>mimetype</th>
+ <td>
+ The MIME type for the Intent
+ (see {@link android.content.Intent#setType(java.lang.String) Intent.setType()}).
+ </td>
+ </tr>
+ <tr>
+ <th>categories</th>
+ <td>
+ An iterable data structure containing strings that define categories for this
+ Intent
+ (see
+ {@link android.content.Intent#addCategory(java.lang.String) Intent.addCategory()}).
+ </td>
+ </tr>
+ <tr>
+ <th>extras</th>
+ <td>
+ A dictionary of extra data for this Intent
+ (see {@link android.content.Intent#putExtra(java.lang.String,java.lang.String)
+ Intent.putExtra()}
+ for an example).
+ <p>
+ The key for each dictionary item should be a <em>string</em>. The item's value
+ can be any simple or structured data type.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <th>component</th>
+ <td>
+ The component for this Intent (see {@link android.content.ComponentName}).
+ Using this argument will direct the Intent to a specific class within a specific
+ Android package.
+ </td>
+ </tr>
+ <tr>
+ <th>flags</th>
+ <td>
+ An iterable data structure containing flags that control how the Intent is handled
+ (see {@link android.content.Intent#setFlags(int) Intent.setFlags()}).
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="drag"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">drag</span>
+ <span class="normal">
+ (
+ <em>tuple</em> start,
+ <em>tuple</em> end,
+ <em>float</em> duration,
+ <em>integer</em> steps)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Simulates a drag gesture (touch, hold, and move) on this device's screen.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>start</th>
+ <td>
+ The starting point of the drag gesture, in the form of a <em>tuple</em>
+ (x,y) where x and y are <em>integers</em>.
+ </td>
+ </tr>
+ <tr>
+ <th>end</th>
+ <td>
+ The end point of the drag gesture, in the form of a <em>tuple</em> (x,y)
+ where x and y are <em>integers</em>.
+ </td>
+ </tr>
+ <tr>
+ <th>duration</th>
+ <td>The duration of the drag gesture in seconds. The default is 1.0 seconds.</td>
+ </tr>
+ <tr>
+ <th>steps</th>
+ <td>The number of steps to take when interpolating points. The default is 10.</td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="getProperty"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>object</em>
+ </span>
+ <span class="sympad">getProperty</span>
+ <span class="normal">
+ (<em>string</em> key)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Given the name of a system environment variable, returns its value for this device.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>key</th>
+ <td>
+ The name of the system environment variable. The available variable names are listed in
+ <a href="#table1">Table 1. Property variable names</a> at the end of this topic.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ The value of the variable. The data format varies according to the variable requested.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="getSystemProperty"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>object</em>
+ </span>
+ <span class="sympad">getSystemProperty</span>
+ <span class="normal">
+ (<em>string</em> key)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Synonym for <code><a href="#getProperty">getProperty()</a></code>.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>key</th>
+ <td>
+ The name of the system environment variable. The available variable names are listed in
+ <a href="#table1">Table 1. Property Variable Names</a>.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ The value of the variable. The data format varies according to the variable requested.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="installPackage"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">installPackage</span>
+ <span class="normal">
+ (<em>string</em> path)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Installs the Android application or test package contained in packageFile
+ onto this device. If the application or test package is already installed, it is
+ replaced.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>path</th>
+ <td>
+ The fully-qualified path and filename of the <code>.apk</code> file to install.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="instrument"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>dictionary</em>
+ </span>
+ <span class="sympad">instrument</span>
+ <span class="normal">
+ (
+ <em>string</em> className,
+ <em>dictionary</em> args)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Runs the specified component with Android instrumentation, and returns the results
+ in a dictionary whose exact format is dictated by the component being run. The
+ component must already be present on this device.
+ </p>
+ <p>
+ Use this method to start a test case that uses one of Android's test case classes.
+ See <a href="{@docRoot}tools/testing/testing_android.html">Testing
+ Fundamentals</a> to learn more about unit testing with the Android testing
+ framework.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>className</th>
+ <td>
+ The name of an Android component that is already installed on this device, in the
+ standard form packagename/classname, where packagename is the
+ Android package name of a <code>.apk</code> file on this device, and
+ classname is the class name of an Android component (Activity,
+ ContentProvider, Service, or BroadcastReceiver) in that file. Both
+ packagename and classname must be fully qualified. See
+ {@link android.content.ComponentName} for more details.
+ </td>
+ </tr>
+ <tr>
+ <th>args</th>
+ <td>
+ A dictionary containing flags and their values. These are passed to the component as it
+ is started. If the flag does not take a value, set its dictionary value to an empty
+ string.
+ </td>
+ </tr>
+ </table>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ <p>
+ A dictionary containing the component's output. The contents of the dictionary
+ are defined by the component itself.
+ </p>
+ <p>
+ If you use {@link android.test.InstrumentationTestRunner} as the class name in
+ the componentName argument, then the result dictionary contains
+ the single key "stream". The value of "stream" is a <em>string</em> containing
+ the test output, as if <code>InstrumentationTestRunner</code> was run from the
+ command line. The format of this output is described in
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing in Other IDEs</a>.
+ </p>
+ </li>
+ </ul>
+ </div>
+ </div>
+ </div>
+</div>
+<A NAME="press"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">press</span>
+ <span class="normal">
+ (<em>string</em> name,
+ <em>integer</em> type)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Sends the key event specified by <code>type</code> to the key specified by
+ <code>keycode</code>.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>name</th>
+ <td>
+ The name of the keycode to send. See {@link android.view.KeyEvent} for a list of
+ keycode names. Use the keycode name, not its integer value.
+ </td>
+ </tr>
+ <tr>
+ <th>type</th>
+ <td>
+ The type of key event to send. The allowed values are <code><a href="#ACTION_DOWN">
+ DOWN</a></code>, <code><a href="#ACTION_UP">UP</a></code>, and
+ <code><a href="#ACTION_DOWN_AND_UP">DOWN_AND_UP</a></code>.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="reboot"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">reboot</span>
+ <span class="normal">
+ (<em>string</em> bootloadType)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Reboots this device into the bootloader specified by <code>bootloadType</code>.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>into</th>
+ <td>
+ The type of bootloader to reboot into. The allowed values are
+ "bootloader", "recovery", or "None".
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="removePackage"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">removePackage</span>
+ <span class="normal">
+ (<em>string</em> package)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Deletes the specified package from this device, including its data and cache.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>package</th>
+ <td>
+ The Android package name of an <code>.apk</code> file on this device.
+ </td>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="shell"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>object</em>
+ </span>
+ <span class="sympad">shell</span>
+ <span class="normal">
+ (<em>string</em> cmd)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Executes an <code>adb</code> shell command and returns the result, if any.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>cmd</th>
+ <td>
+ The command to execute in the <code>adb</code> shell. The form of these commands is
+ described in the topic <a href="{@docRoot}tools/help/adb.html">Android
+ Debug Bridge</a>.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ The results of the command, if any. The format of the results is determined by the
+ command.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="startActivity"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">startActivity</span>
+ <span class="normal">
+ (
+ <em>string</em> uri,
+ <em>string</em> action,
+ <em>string</em> data,
+ <em>string</em> mimetype,
+ <em>iterable</em> categories
+ <em>dictionary</em> extras,
+ <em>component</em> component,
+ <em>iterable</em> flags)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Starts an Activity on this device by sending an Intent constructed from the
+ supplied arguments.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>uri</th>
+ <td>
+ The URI for the Intent.
+ (see {@link android.content.Intent#setData(android.net.Uri) Intent.setData()}).
+ </td>
+ </tr>
+ <tr>
+ <th>action</th>
+ <td>
+ The action for the Intent
+ (see {@link android.content.Intent#setAction(java.lang.String) Intent.setAction()}).
+ </td>
+ </tr>
+ <tr>
+ <th>data</th>
+ <td>
+ The data URI for the Intent
+ (see {@link android.content.Intent#setData(android.net.Uri) Intent.setData()}).
+ </td>
+ </tr>
+ <tr>
+ <th>mimetype</th>
+ <td>
+ The MIME type for the Intent
+ (see {@link android.content.Intent#setType(java.lang.String) Intent.setType()}).
+ </td>
+ </tr>
+ <tr>
+ <th>categories</th>
+ <td>
+ An iterable data structure containing strings that define categories for the
+ Intent
+ (see
+ {@link android.content.Intent#addCategory(java.lang.String) Intent.addCategory()}).
+ </td>
+ </tr>
+ <tr>
+ <th>extras</th>
+ <td>
+ A dictionary of extra data for the Intent
+ (see
+ {@link android.content.Intent#putExtra(java.lang.String,java.lang.String)
+ Intent.putExtra()}
+ for an example).
+ <p>
+ The key for each dictionary item should be a <em>string</em>. The item's value
+ can be any simple or structured data type.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <th>component</th>
+ <td>
+ The component for the Intent
+ (see {@link android.content.ComponentName}). Using this argument will direct the
+ Intent to a specific class within a specific Android package.
+ </td>
+ </tr>
+ <tr>
+ <th>flags</th>
+ <td>
+ An iterable data structure containing flags that control how the Intent is handled
+ (see {@link android.content.Intent#setFlags(int) Intent.setFlags()}).
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="takeSnapshot"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">
+ MonkeyImage
+ </a>
+ </code>
+ </span>
+ <span class="sympad">takeSnapshot</span>
+ <span class="normal">
+ ()
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Captures the entire screen buffer of this device, yielding a
+ screen capture of the current display.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ A <a href="{@docRoot}tools/help/MonkeyImage.html">
+ MonkeyImage</a> object containing the image of the current display.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="touch"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">touch</span>
+ <span class="normal">
+ (
+ <em>integer</em> x,
+ <em>integer</em> y,
+ <em>string</em> type)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Sends a touch event specified by type to the screen location specified
+ by x and y.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>x</th>
+ <td>
+ The horizontal position of the touch in actual device pixels, starting from the left of
+ the screen in its current orientation.
+ </td>
+ </tr>
+ <tr>
+ <th>y</th>
+ <td>
+ The vertical position of the touch in actual device pixels, starting from the top of
+ the screen in its current orientation.
+ </td>
+ </tr>
+ <tr>
+ <th>type</th>
+ <td>
+ The type of key event to send. The allowed values are <code><a href="#ACTION_DOWN">
+ DOWN</a></code>, <code><a href="#ACTION_UP">UP</a></code>, and
+ <code><a href="#ACTION_DOWN_AND_UP">DOWN_AND_UP</a></code>.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="type"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">type</span>
+ <span class="normal">
+ (<em>string</em> message)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Sends the characters contained in message to this device, as if they
+ had been typed on the device's keyboard. This is equivalent to calling
+ <code><a href="#press">press()</a></code> for each keycode in <code>message</code>
+ using the key event type <code><a href="#ACTION_DOWN_AND_UP">DOWN_AND_UP</a></code>.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>message</th>
+ <td>
+ A string containing the characters to send.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="wake"></A>
+<div class="jd-details api">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">wake</span>
+ <span class="normal">
+ ()
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Wakes the screen of this device.
+ </p>
+ </div>
+ </div>
+</div>
+<hr></hr>
+<h2>Appendix</h2>
+ <p class="table-caption" id="table1">
+ <strong>Table 1.</strong>Property variable names used with
+ <span class="sympad"><a href="#getProperty">getProperty()</a></span> and
+ <span class="sympad"><a href="#getSystemProperty">getSystemProperty()</a></span>.
+ </p>
+ <table>
+ <tr>
+ <th>
+ Property Group
+ </th>
+ <th>
+ Property
+ </th>
+ <th>
+ Description
+ </th>
+ <th>
+ Notes
+ </th>
+ </tr>
+ <tr>
+ <td rowspan="17"><code>build</code></td>
+ <td><code>board</code></td>
+ <td>Code name for the device's system board</td>
+ <td rowspan="17">
+ See {@link android.os.Build}
+ </td>
+ </tr>
+ <tr>
+ <td><code>brand</code></td>
+ <td>The carrier or provider for which the OS is customized.</td>
+ </tr>
+ <tr>
+ <td><code>device</code></td>
+ <td>The device design name.</td>
+ </tr>
+ <tr>
+ <td><code>fingerprint</code></td>
+ <td>A unique identifier for the currently-running build.</td>
+ </tr>
+ <tr>
+ <td><code>host</code></td>
+ <td></td>
+ </tr>
+ <tr>
+ <td><code>ID</code></td>
+ <td>A changelist number or label.</td>
+ </tr>
+ <tr>
+ <td><code>model</code></td>
+ <td>The end-user-visible name for the device.</td>
+ </tr>
+ <tr>
+ <td><code>product</code></td>
+ <td>The overall product name.</td>
+ </tr>
+ <tr>
+ <td><code>tags</code></td>
+ <td>Comma-separated tags that describe the build, such as "unsigned" and "debug".</td>
+ </tr>
+ <tr>
+ <td><code>type</code></td>
+ <td>The build type, such as "user" or "eng".</td>
+ </tr>
+ <tr>
+ <td><code>user</code></td>
+ <td></td>
+ </tr>
+ <tr>
+ <td><code>CPU_ABI</code></td>
+ <td>
+ The name of the native code instruction set, in the form CPU type plus
+ ABI convention.
+ </td>
+ </tr>
+ <tr>
+ <td><code>manufacturer</code></td>
+ <td>The product/hardware manufacturer.</td>
+ </tr>
+ <tr>
+ <td><code>version.incremental</code></td>
+ <td>
+ The internal code used by the source control system to represent this version
+ of the software.
+ </td>
+ </tr>
+ <tr>
+ <td><code>version.release</code></td>
+ <td>The user-visible name of this version of the software.</td>
+ </tr>
+ <tr>
+ <td><code>version.sdk</code></td>
+ <td>The user-visible SDK version associated with this version of the OS.</td>
+ </tr>
+ <tr>
+ <td><code>version.codename</code></td>
+ <td>
+ The current development codename, or "REL" if this version of the software has been
+ released.
+ </td>
+ </tr>
+ <tr>
+ <td rowspan="3"><code>display</code></td>
+ <td><code>width</code></td>
+ <td>The device's display width in pixels.</td>
+ <td rowspan="3">
+ See
+ {@link android.util.DisplayMetrics} for details.
+ </td>
+ </tr>
+ <tr>
+ <td><code>height</code></td>
+ <td>The device's display height in pixels.</td>
+ </tr>
+ <tr>
+ <td><code>density</code></td>
+ <td>
+ The logical density of the display. This is a factor that scales
+ DIP (Density-Independent Pixel) units to the device's resolution. DIP is adjusted so
+ that 1 DIP is equivalent to one pixel on a 160 pixel-per-inch display. For example,
+ on a 160-dpi screen, density = 1.0, while on a 120-dpi screen, density = .75.
+ <p>
+ The value does not exactly follow the real screen size, but is adjusted to
+ conform to large changes in the display DPI. See
+ {@link android.util.DisplayMetrics#density} for more details.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td rowspan="6"><code>am.current</code></td>
+ <td><code>package</code></td>
+ <td>The Android package name of the currently running package.</td>
+ <td rowspan="6">
+ The <code>am.current</code> keys return information about the currently-running
+ Activity.
+ </td>
+ </tr>
+ <tr>
+ <td><code>action</code></td>
+ <td>
+ The current activity's action. This has the same format as the <code>name</code>
+ attribute of the <code>action</code> element in a package manifest.
+ </td>
+ </tr>
+ <tr>
+ <td><code>comp.class</code></td>
+ <td>
+ The class name of the component that started the current Activity. See
+ <code><a href="#comppackage">comp.package</a></code> for more details.</td>
+ </tr>
+ <tr>
+ <td><a name="comppackage"><code>comp.package</code></a></td>
+ <td>
+ The package name of the component that started the current Activity. A component
+ is specified by a package name and the name of class that the package contains.
+ </td>
+ </tr>
+ <tr>
+ <td><code>data</code></td>
+ <td>The data (if any) contained in the Intent that started the current Activity.</td>
+ </tr>
+ <tr>
+ <td><code>categories</code></td>
+ <td>The categories specified by the Intent that started the current Activity.</td>
+ </tr>
+ <tr>
+ <td rowspan="3"><code>clock</code></td>
+ <td><code>realtime</code></td>
+ <td>
+ The number of milliseconds since the device rebooted, including deep-sleep
+ time.
+ </td>
+ <td rowspan="3">
+ See {@link android.os.SystemClock} for more information.
+ </td>
+ </tr>
+ <tr>
+ <td><code>uptime</code></td>
+ <td>
+ The number of milliseconds since the device rebooted, <em>not</em> including
+ deep-sleep time
+ </td>
+ </tr>
+ <tr>
+ <td><code>millis</code></td>
+ <td>current time since the UNIX epoch, in milliseconds.</td>
+ </tr>
+ </table>
diff --git a/docs/html/tools/help/MonkeyImage.jd b/docs/html/tools/help/MonkeyImage.jd
new file mode 100644
index 0000000..79f4948
--- /dev/null
+++ b/docs/html/tools/help/MonkeyImage.jd
@@ -0,0 +1,437 @@
+page.title=MonkeyImage
+parent.title=monkeyrunner
+parent.link=index.html
+@jd:body
+<style>
+ h4.jd-details-title {background-color: #DEE8F1;}
+</style>
+
+<p>
+ A monkeyrunner class to hold an image of the device or emulator's screen. The image is
+ copied from the screen buffer during a screenshot. This object's methods allow you to
+ convert the image into various storage formats, write the image to a file, copy parts of
+ the image, and compare this object to other <code>MonkeyImage</code> objects.
+</p>
+<p>
+ You do not need to create new instances of <code>MonkeyImage</code>. Instead, use
+<code><a href="{@docRoot}tools/help/MonkeyDevice.html#takeSnapshot">
+MonkeyDevice.takeSnapshot()</a></code> to create a new instance from a screenshot. For example, use:
+</p>
+<pre>
+newimage = MonkeyDevice.takeSnapshot()
+</pre>
+<h2>Summary</h2>
+<table id="pubmethods" class="jd-sumtable">
+ <tr>
+ <th colspan="12" style="background-color: #E2E2E2">Methods</th>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>string</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#convertToBytes">convertToBytes</a>
+ </span>
+ (<em>string</em> format)
+ </nobr>
+ <div class="jd-descrdiv">
+ Converts the current image to a particular format and returns it as a
+ <em>string</em> that you can then access as an <em>iterable</em> of binary bytes.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>tuple</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#getRawPixel">getRawPixel</a>
+ </span>
+ (<em>integer</em> x,
+ <em>integer</em> y)
+ </nobr>
+ <div class="jd-descrdiv">
+ Returns the single pixel at the image location (x,y), as an
+ a <em>tuple</em> of <em>integer</em>, in the form (a,r,g,b).
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>integer</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#getRawPixelInt">getRawPixelInt</a>
+ </span>
+ (<em>integer</em> x,
+ <em>integer</em> y)
+ </nobr>
+ <div class="jd-descrdiv">
+ Returns the single pixel at the image location (x,y), as
+ a 32-bit <em>integer</em>.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a>
+ </code>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#getSubImage">getSubImage</a>
+ </span>
+ (<em>tuple</em> rect)
+ </nobr>
+ <div class="jd-descrdiv">
+ Creates a new <code>MonkeyImage</code> object from a rectangular selection of the
+ current image.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>boolean</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#sameAs">sameAs</a>
+ </span>
+ (<code><a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a></code>
+ other,
+ <em>float</em> percent)
+ </nobr>
+ <div class="jd-descrdiv">
+ Compares this <code>MonkeyImage</code> object to another and returns the result of
+ the comparison. The <code>percent</code> argument specifies the percentage
+ difference that is allowed for the two images to be "equal".
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>void</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#writeToFile">writeToFile</a>
+ </span>
+ (<em>string</em> path,
+ <em>string</em> format)
+ </nobr>
+ <div class="jd-descrdiv">
+ Writes the current image to the file specified by <code>filename</code>, in the
+ format specified by <code>format</code>.
+ </div>
+ </td>
+ </tr>
+</table>
+<!-- ========= METHOD DETAIL ======== -->
+<!-- Public methods -->
+<h2>Public Methods</h2>
+<A NAME="convertToBytes"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ <span class="sympad">convertToBytes</span>
+ <span class="normal">
+ (
+ <em>string</em> format)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Converts the current image to a particular format and returns it as a <em>string</em>
+ that you can then access as an <em>iterable</em> of binary bytes.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>format</th>
+ <td>
+ The desired output format. All of the common raster output formats are supported.
+ The default value is "png" (Portable Network Graphics).
+ </td>
+ </tr>
+ </table>
+ </div>
+</div>
+</div>
+<A NAME="getRawPixel"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>tuple</em>
+ </span>
+ <span class="sympad">getRawPixel</span>
+ <span class="normal">
+ (<em>integer</em> x,
+ <em>integer</em> y)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Returns the single pixel at the image location (x,y), as an
+ a <em>tuple</em> of <em>integer</em>, in the form (a,r,g,b).
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>x</th>
+ <td>
+ The horizontal position of the pixel, starting with 0 at the left of the screen in the
+ orientation it had when the screenshot was taken.
+ </td>
+ </tr>
+ <tr>
+ <th>y</th>
+ <td>
+ The vertical position of the pixel, starting with 0 at the top of the screen in the
+ orientation it had when the screenshot was taken.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ A tuple of integers representing the pixel, in the form (a,r,g,b) where
+ a is the alpha channel value, and r, g, and b are the red, green, and blue values,
+ respectively.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="getRawPixelInt"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>tuple</em>
+ </span>
+ <span class="sympad">getRawPixelInt</span>
+ <span class="normal">
+ (<em>integer</em> x,
+ <em>integer</em> y)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Returns the single pixel at the image location (x,y), as an
+ an <em>integer</em>. Use this method to economize on memory.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>x</th>
+ <td>
+ The horizontal position of the pixel, starting with 0 at the left of the screen in the
+ orientation it had when the screenshot was taken.
+ </td>
+ </tr>
+ <tr>
+ <th>y</th>
+ <td>
+ The vertical position of the pixel, starting with 0 at the top of the screen in the
+ orientation it had when the screenshot was taken.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ The a,r,g, and b values of the pixel as 8-bit values combined into a 32-bit
+ integer, with a as the leftmost 8 bits, r the next rightmost, and so forth.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="getSubImage"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a>
+ </code>
+ </span>
+ <span class="sympad">getSubImage</span>
+ <span class="normal">
+ (<em>tuple</em> rect)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Creates a new <code>MonkeyImage</code> object from a rectangular selection of the
+ current image.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>rect</th>
+ <td>
+ A tuple (x, y, w, h) specifying the selection. x and y specify the 0-based pixel
+ position of the upper left-hand corner of the selection. w specifies the width of the
+ region, and h specifies its height, both in units of pixels.
+ <p>
+ The image's orientation is the same as the screen orientation at the time the
+ screenshot was made.
+ </p>
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ A new <code>MonkeyImage</code> object containing the selection.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="sameAs"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>boolean</em>
+ </span>
+ <span class="sympad">sameAs</span>
+ <span class="normal">
+ (
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a>
+ </code> otherImage,
+ <em>float</em> percent
+ )
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Compares this <code>MonkeyImage</code> object to another and returns the result of
+ the comparison. The <code>percent</code> argument specifies the percentage
+ difference that is allowed for the two images to be "equal".
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>other</th>
+ <td>
+ Another <code>MonkeyImage</code> object to compare to this one.
+ </td>
+ </tr>
+ <tr>
+ <th>
+ percent
+ </th>
+ <td>
+ A float in the range 0.0 to 1.0, inclusive, indicating
+ the percentage of pixels that need to be the same for the method to return
+ <code>true</code>. The default is 1.0, indicating that all the pixels
+ must match.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ Boolean <code>true</code> if the images match, or boolean <code>false</code> otherwise.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="writeToFile"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">writeToFile</span>
+ <span class="normal">
+ (<em>string</em> filename,
+ <em>string</em> format)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Writes the current image to the file specified by <code>filename</code>, in the
+ format specified by <code>format</code>.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>path</th>
+ <td>
+ The fully-qualified filename and extension of the output file.
+ </td>
+ </tr>
+ <tr>
+ <th>
+ format
+ </th>
+ <td>
+ The output format to use for the file. If no format is provided, then the
+ method tries to guess the format from the filename's extension. If no
+ extension is provided and no format is specified, then the default format of
+ "png" (Portable Network Graphics) is used.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
diff --git a/docs/html/tools/help/MonkeyRunner.jd b/docs/html/tools/help/MonkeyRunner.jd
new file mode 100644
index 0000000..a924d2d
--- /dev/null
+++ b/docs/html/tools/help/MonkeyRunner.jd
@@ -0,0 +1,448 @@
+page.title=MonkeyRunner
+parent.title=monkeyrunner
+parent.link=index.html
+@jd:body
+
+<style>
+ h4.jd-details-title {background-color: #DEE8F1;}
+</style>
+<p>
+ A monkeyrunner class that contains static utility methods.
+</p>
+<h2>Summary</h2>
+<table id="pubmethods" class="jd-sumtable">
+ <tr>
+ <th colspan="12" style="background-color: #E2E2E2">Methods</th>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#alert">alert</a>
+ </span>
+ (<em>string</em> message,
+ <em>string</em> title,
+ <em>string</em> okTitle)
+ </nobr>
+ <div class="jd-descrdiv">
+ Displays an alert dialog to the process running the current
+ program.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>integer</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#choice">choice</a>
+ </span>
+ (<em>string</em> message,
+ <em>iterable</em> choices,
+ <em>string</em> title)
+ </nobr>
+ <div class="jd-descrdiv">
+ Displays a dialog with a list of choices to the process running the current program.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#help">help</a>
+ </span>
+ (<em>string</em> format)
+ </nobr>
+ <div class="jd-descrdiv">
+ Displays the monkeyrunner API reference in a style similar to that of Python's
+ <code>pydoc</code> tool, using the specified format.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <em>string</em>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#input">input</a>
+ </span>
+ (<em>string</em> message,
+ <em>string</em> initialValue,
+ <em>string</em> title,
+ <em>string</em> okTitle,
+ <em>string</em> cancelTitle)
+ </nobr>
+ <div class="jd-descrdiv">
+ Displays a dialog that accepts input.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ void
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#sleep">sleep</a>
+ </span>
+ (<em>float</em> seconds)
+ </nobr>
+ <div class="jd-descrdiv">
+ Pauses the current program for the specified number of seconds.
+ </div>
+ </td>
+ </tr>
+ <tr class="api" >
+ <td class="jd-typecol">
+ <nobr>
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyDevice.html">MonkeyDevice</a>
+ </code>
+ </nobr>
+ </td>
+ <td class="jd-linkcol" width="100%">
+ <nobr>
+ <span class="sympad">
+ <a href="#waitForConnection">waitForConnection</a>
+ </span>
+ (<em>float</em> timeout,
+ <em>string</em> deviceId)
+ </nobr>
+ <div class="jd-descrdiv">
+ Tries to make a connection between the <code>monkeyrunner</code> backend and the
+ specified device or emulator.
+ </div>
+ </td>
+ </tr>
+</table>
+<!-- ========= METHOD DETAIL ======== -->
+<!-- Public methods -->
+<h2>Public Methods</h2>
+<A NAME="alert"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ <span class="sympad">alert</span>
+ <span class="normal">
+ (
+ <em>string</em> message,
+ <em>string</em> title,
+ <em>string</em> okTitle)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Displays an alert dialog to the process running the current
+ program. The dialog is modal, so the program pauses until the user clicks the dialog's
+ button.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>message</th>
+ <td>
+ The message to display in the dialog.
+ </td>
+ </tr>
+ <tr>
+ <th>title</th>
+ <td>
+ The dialog's title. The default value is "Alert".
+ </td>
+ </tr>
+ <tr>
+ <th>okTitle</th>
+ <td>
+ The text displayed in the dialog button. The default value is "OK".
+ </td>
+ </tr>
+ </table>
+ </div>
+</div>
+</div>
+<A NAME="choice"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>integer</em>
+ </span>
+ <span class="sympad">choice</span>
+ <span class="normal">
+ (<em>string</em> message,
+ <em>iterable</em> choices,
+ <em>string</em> title)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Displays a dialog with a list of choices to the process running the current program. The
+ dialog is modal, so the program pauses until the user clicks one of the dialog's
+ buttons.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>message</th>
+ <td>
+ The prompt message displayed in the dialog.
+ </td>
+ </tr>
+ <tr>
+ <th>choices</th>
+ <td>
+ A Python iterable containing one or more objects that are displayed as strings. The
+ recommended form is an array of strings.
+ </td>
+ </tr>
+ <tr>
+ <th>
+ title
+ </th>
+ <td>
+ The dialog's title. The default is "Input".
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ If the user makes a selection and clicks the "OK" button, the method returns
+ the 0-based index of the selection within the iterable.
+ If the user clicks the "Cancel" button, the method returns -1.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="help"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">help</span>
+ <span class="normal">
+ (<em>string</em> format)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Displays the monkeyrunner API reference in a style similar to that of Python's
+ <code>pydoc</code> tool, using the specified format.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>format</th>
+ <td>
+ The markup format to use in the output. The possible values are "text" for plain text
+ or "html" for HTML.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="input"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <em>string</em>
+ </span>
+ <span class="sympad">input</span>
+ <span class="normal">
+ (<em>string</em> message
+ <em>string</em> initialValue,
+ <em>string</em> title,
+ <em>string</em> okTitle,
+ <em>string</em> cancelTitle)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Displays a dialog that accepts input and returns it to the program. The dialog is
+ modal, so the program pauses until the user clicks one of the dialog's buttons.
+ </p>
+ <p>
+ The dialog contains two buttons, one of which displays the okTitle value
+ and the other the cancelTitle value. If the user clicks the okTitle button,
+ the current value of the input box is returned. If the user clicks the cancelTitle
+ button, an empty string is returned.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>message</th>
+ <td>
+ The prompt message displayed in the dialog.
+ </td>
+ </tr>
+ <tr>
+ <th>initialValue</th>
+ <td>
+ The initial value to display in the dialog. The default is an empty string.
+ </td>
+ </tr>
+ <tr>
+ <th>title</th>
+ <td>
+ The dialog's title. The default is "Input".
+ </td>
+ </tr>
+ <tr>
+ <th>okTitle</th>
+ <td>
+ The text displayed in the okTitle button. The default is "OK".
+ </td>
+ </tr>
+ <tr>
+ <th>cancelTitle</th>
+ <td>
+ The text displayed in the cancelTitle button. The default is "Cancel".
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ If the user clicks the okTitle button, then the method returns the current value of
+ the dialog's input box. If the user clicks the cancelTitle button, the method returns
+ an empty string.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
+<A NAME="sleep"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ void
+ </span>
+ <span class="sympad">sleep</span>
+ <span class="normal">
+ (
+ <em>float</em> seconds
+ )
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Pauses the current program for the specified number of seconds.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>seconds</th>
+ <td>
+ The number of seconds to pause.
+ </td>
+ </tr>
+ </table>
+ </div>
+ </div>
+</div>
+<A NAME="waitForConnection"></A>
+<div class="jd-details api ">
+ <h4 class="jd-details-title">
+ <span class="normal">
+ <code>
+ <a href="{@docRoot}tools/help/MonkeyDevice.html">MonkeyDevice</a>
+ </code>
+ </span>
+ <span class="sympad">waitForConnection</span>
+ <span class="normal">
+ (<em>float</em> timeout,
+ <em>string</em> deviceId)
+ </span>
+ </h4>
+ <div class="jd-details-descr">
+
+ <div class="jd-tagdata jd-tagdescr">
+ <p>
+ Tries to make a connection between the <code>monkeyrunner</code> backend and the
+ specified device or emulator.
+ </p>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Arguments</h5>
+ <table class="jd-tagtable">
+ <tr>
+ <th>timeout</th>
+ <td>
+ The number of seconds to wait for a connection. The default is to wait forever.
+ </td>
+ </tr>
+ <tr>
+ <th>
+ deviceId
+ </th>
+ <td>
+ A regular expression that specifies the serial number of the device or emulator. See
+ the topic
+ <a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a>
+ for a description of device and emulator serial numbers.
+ </td>
+ </tr>
+ </table>
+ </div>
+ <div class="jd-tagdata">
+ <h5 class="jd-tagtitle">Returns</h5>
+ <ul class="nolist">
+ <li>
+ A <code><a href="{@docRoot}tools/help/MonkeyDevice.html">MonkeyDevice</a></code>
+ instance for the device or emulator. Use this object to control and communicate with the
+ device or emulator.
+ </li>
+ </ul>
+ </div>
+ </div>
+</div>
diff --git a/docs/html/tools/help/aapt.html b/docs/html/tools/help/aapt.html
new file mode 100644
index 0000000..ebd375d
--- /dev/null
+++ b/docs/html/tools/help/aapt.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/building/index.html#detailed-build">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/building/index.html#detailed-build">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/help/adb.jd b/docs/html/tools/help/adb.jd
new file mode 100644
index 0000000..ddebed60
--- /dev/null
+++ b/docs/html/tools/help/adb.jd
@@ -0,0 +1,669 @@
+page.title=Android Debug Bridge
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>ADB quickview</h2>
+ <ul>
+<li>Manage the state of an emulator or device</li>
+<li>Run shell commands on a device</li>
+<li>Manage port forwarding on an emulator or device</li>
+<li>Copy files to/from an emulator or device</li>
+ </ul>
+
+ <h2>In this document</h2>
+ <ol>
+<li><a href="#issuingcommands">Issuing ADB Commands</a></li>
+<li><a href="#devicestatus">Querying for Emulator/Device Instances</a></li>
+<li><a href="#directingcommands">Directing Commands to a Specific Emulator/Device Instance</a></li>
+<li><a href="#move">Installing an Application</a></li>
+<li><a href="#forwardports">Forwarding Ports</a></li>
+<li><a href="#copyfiles">Copying Files to or from an Emulator/Device Instance</a></li>
+<li><a href="#commandsummary">Listing of adb Commands </a></li>
+<li><a href="#shellcommands">Issuing Shell Commands</a></li>
+<li><a href="#logcat">Enabling logcat Logging</a></li>
+<li><a href="#stopping">Stopping the adb Server</a></li>
+ </ol>
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="emulator.html">Emulator</a></li>
+ </ol>
+
+</div>
+</div>
+
+<p>Android Debug Bridge (adb) is a versatile command line tool that lets you communicate with an
+emulator instance or connected Android-powered device. It is a client-server program that includes
+three components: </p>
+
+<ul>
+ <li>A client, which runs on your development machine. You can invoke a client from a shell by issuing an adb command. Other Android tools such as the ADT plugin and DDMS also create adb clients. </li>
+ <li>A server, which runs as a background process on your development machine. The server manages communication between the client and the adb daemon running on an emulator or device. </li>
+ <li>A daemon, which runs as a background process on each emulator or device instance. </li>
+</ul>
+
+<p>You can find the {@code adb} tool in {@code <sdk>/platform-tools/}.</p>
+
+<p>When you start an adb client, the client first checks whether there is an adb server process already running. If there isn't, it starts the server process. When the server starts, it binds to local TCP port 5037 and listens for commands sent from adb clients—all adb clients use port 5037 to communicate with the adb server. </p>
+
+<p>The server then sets up connections to all running emulator/device instances. It locates emulator/device instances by scanning odd-numbered ports in the range 5555 to 5585, the range used by emulators/devices. Where the server finds an adb daemon, it sets up a connection to that port. Note that each emulator/device instance acquires a pair of sequential ports — an even-numbered port for console connections and an odd-numbered port for adb connections. For example: </p>
+
+<p style="margin-left:2em">
+Emulator 1, console: 5554<br/>
+Emulator 1, adb: 5555<br>
+Emulator 2, console: 5556<br>
+Emulator 2, adb: 5557 ...
+</p>
+
+<p>As shown, the emulator instance connected to adb on port 5555 is the same as the instance whose console listens on port 5554. </p>
+
+<p>Once the server has set up connections to all emulator instances, you can use adb commands to control and access those instances. Because the server manages connections to emulator/device instances and handles commands from multiple adb clients, you can control any emulator/device instance from any client (or from a script).</p>
+
+<p>The sections below describe the commands that you can use to access adb capabilities and manage the state of an emulator/device. Note that if you are developing Android applications in Eclipse and have installed the ADT plugin, you do not need to access adb from the command line. The ADT plugin provides a transparent integration of adb into the Eclipse IDE. However, you can still use adb directly as necessary, such as for debugging.</p>
+
+<a name="issuingcommands"></a>
+
+<h2>Issuing adb Commands</h2>
+
+<p>You can issue adb commands from a command line on your development machine or from a script. The usage is: </p>
+
+ <pre>adb [-d|-e|-s <serialNumber>] <command> </pre>
+
+<p>When you issue a command, the program invokes an adb client. The client is not specifically associated with any emulator instance, so if multiple emulators/devices are running, you need to use the <code>-d</code> option to specify the target instance to which the command should be directed. For more information about using this option, see <a href="#directingcommands">Directing Commands to a Specific Emulator/Device Instance</a>. </p>
+
+<a name="devicestatus"></a>
+
+<h2>Querying for Emulator/Device Instances</h2>
+
+<p>Before issuing adb commands, it is helpful to know what emulator/device instances are connected to the adb server. You can generate a list of attached emulators/devices using the <code>devices</code> command: </p>
+
+ <pre>adb devices</pre>
+
+<p>In response, adb prints this status information for each instance:</p>
+
+<ul>
+ <li>Serial number — A string created by adb to uniquely identify an emulator/device instance by its
+ console port number. The format of the serial number is <code><type>-<consolePort></code>.
+ Here's an example serial number: <code>emulator-5554</code></li>
+ <li>State — The connection state of the instance. Three states are supported:
+ <ul>
+ <li><code>offline</code> — the instance is not connected to adb or is not responding.</li>
+ <li><code>device</code> — the instance is now connected to the adb server. Note that this state does not
+ imply that the Android system is fully booted and operational, since the instance connects to adb
+ while the system is still booting. However, after boot-up, this is the normal operational state of
+ an emulator/device instance.</li>
+ </ul>
+ </li>
+</ul>
+
+<p>The output for each instance is formatted like this: </p>
+
+ <pre>[serialNumber] [state]</pre>
+
+<p>Here's an example showing the <code>devices</code> command and its output:</p>
+
+ <pre>$ adb devices
+List of devices attached
+emulator-5554 device
+emulator-5556 device
+emulator-5558 device</pre>
+
+<p>If there is no emulator/device running, adb returns <code>no device</code>.</p>
+
+
+<a name="directingcommands"></a>
+
+<h2>Directing Commands to a Specific Emulator/Device Instance</h2>
+
+<p>If multiple emulator/device instances are running, you need to specify a target instance when issuing adb commands. To so so, use the <code>-s</code> option in the commands. The usage for the <code>-s</code> option is:</p>
+
+ <pre>adb -s <serialNumber> <command> </pre>
+
+<p>As shown, you specify the target instance for a command using its adb-assigned serial number. You can use the <code>devices</code> command to obtain the serial numbers of running emulator/device instances. </p>
+
+<p>Here is an example: </p>
+
+ <pre>adb -s emulator-5556 install helloWorld.apk</pre>
+
+<p>Note that, if you issue a command without specifying a target emulator/device instance using <code>-s</code>, adb generates an error.
+
+<a name="move"></a>
+
+<h2>Installing an Application</h2>
+<p>You can use adb to copy an application from your development computer and install it on an emulator/device instance. To do so, use the <code>install</code> command. With the command, you must specify the path to the .apk file that you want to install:</p>
+
+<pre>adb install <path_to_apk></pre>
+
+<p>For more information about how to create an .apk file that you can install on an emulator/device
+instance, see <a href="{@docRoot}tools/building/index.html">Building and Running</a></p>
+
+<p>Note that, if you are using the Eclipse IDE and have the ADT plugin installed, you do not need to use adb (or aapt) directly to install your application on the emulator/device. Instead, the ADT plugin handles the packaging and installation of the application for you. </p>
+
+
+<a name="forwardports"></a>
+
+<h2>Forwarding Ports</h2>
+
+ <p>You can use the <code>forward</code> command to set up arbitrary port forwarding — forwarding of requests on a specific host port to a different port on an emulator/device instance. Here's how you would set up forwarding of host port 6100 to emulator/device port 7100:</p>
+<pre>adb forward tcp:6100 tcp:7100</pre>
+ <p>You can also use adb to set up forwarding to named abstract UNIX domain sockets, as illustrated here:</p>
+<pre>adb forward tcp:6100 local:logd </pre>
+
+<a name="copyfiles"></a>
+
+<h2>Copying Files to or from an Emulator/Device Instance</h2>
+
+<p>You can use the adb commands <code>pull</code> and <code>push</code> to copy files to and from an emulator/device instance's data file. Unlike the <code>install</code> command, which only copies an .apk file to a specific location, the <code>pull</code> and <code>push</code> commands let you copy arbitrary directories and files to any location in an emulator/device instance. </p>
+
+<p>To copy a file or directory (recursively) <em>from</em> the emulator or device, use</p>
+<pre>adb pull <remote> <local></pre>
+
+<p>To copy a file or directory (recursively) <em>to</em> the emulator or device, use</p>
+ <pre>adb push <local> <remote></pre>
+
+<p>In the commands, <code><local></code> and <code><remote></code> refer to the paths to the target files/directory on your development machine (local) and on the emulator/device instance (remote).</p>
+
+<p>Here's an example: </p>
+<pre>adb push foo.txt /sdcard/foo.txt</pre>
+
+<a name="commandsummary"></a>
+
+<h2>Listing of adb Commands</h2>
+
+<p>The table below lists all of the supported adb commands and explains their meaning and usage. </p>
+
+
+<table>
+<tr>
+ <th>Category</th>
+ <th>Command</th>
+ <th>Description</th>
+ <th>Comments</th>
+</tr>
+
+<tr>
+<td rowspan="3">Options</td>
+<td><code>-d</code></td>
+<td>Direct an adb command to the only attached USB device.</td>
+<td>Returns an error if more than one USB device is attached.</td>
+</tr>
+
+<tr>
+<td><code>-e</code></td>
+<td>Direct an adb command to the only running emulator instance.</td>
+<td>Returns an error if more than one emulator instance is running. </td>
+</tr>
+
+<tr>
+<td><code>-s <serialNumber></code></td>
+<td>Direct an adb command a specific emulator/device instance, referred to by its adb-assigned serial number (such as "emulator-5556").</td>
+<td>If not specified, adb generates an error.</td>
+</tr>
+
+<tr>
+<td rowspan="3">General</td>
+<td><code>devices</code></td>
+<td>Prints a list of all attached emulator/device instances.</td>
+<td>See <a href="#devicestatus">Querying for Emulator/Device Instances</a> for more information.</td>
+</tr>
+
+<tr>
+<td><code>help</code></td>
+<td>Prints a list of supported adb commands.</td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>version</code></td>
+<td>Prints the adb version number. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td rowspan="3">Debug</td>
+<td ><code>logcat [<option>] [<filter-specs>]</code></td>
+<td>Prints log data to the screen. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>bugreport</code></td>
+<td>Prints <code>dumpsys</code>, <code>dumpstate</code>, and <code>logcat</code> data to the screen, for the purposes of bug reporting. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>jdwp</code></td>
+<td>Prints a list of available JDWP processes on a given device. </td>
+<td>You can use the <code>forward jdwp:<pid></code> port-forwarding specification to connect to a specific JDWP process. For example: <br>
+ <code>adb forward tcp:8000 jdwp:472</code><br>
+ <code>jdb -attach localhost:8000</code></p>
+ </td>
+</tr>
+
+<tr>
+<td rowspan=3">Data</td>
+<td><code>install <path-to-apk></code></td>
+<td>Pushes an Android application (specified as a full path to an .apk file) to the data file of an emulator/device. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>pull <remote> <local></code></td>
+<td>Copies a specified file from an emulator/device instance to your development computer. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>push <local> <remote></code></td>
+<td>Copies a specified file from your development computer to an emulator/device instance. </td>
+<td> </td>
+</tr>
+
+<tr>
+<td rowspan="2">Ports and Networking</td>
+<td><code>forward <local> <remote></code></td>
+<td>Forwards socket connections from a specified local port to a specified remote port on the emulator/device instance. </td>
+<td>Port specifications can use these schemes:
+<ul><li><code>tcp:<portnum></code></li>
+<li><code>local:<UNIX domain socket name></code></li>
+<li><code>dev:<character device name></code></li>
+<li><code>jdwp:<pid></code></li></ul>
+</td>
+</tr>
+
+<tr>
+<td><code>ppp <tty> [parm]...</code></td>
+<td>Run PPP over USB.
+<ul>
+<li><code><tty></code> — the tty for PPP stream. For example <code>dev:/dev/omap_csmi_ttyl</code>. </li>
+<li><code>[parm]... </code> — zero or more PPP/PPPD options, such as <code>defaultroute</code>, <code>local</code>, <code>notty</code>, etc.</li></ul>
+
+<p>Note that you should not automatically start a PPP connection. </p></td>
+<td></td>
+</tr>
+
+<tr>
+<td rowspan="3">Scripting</td>
+<td><code>get-serialno</code></td>
+<td>Prints the adb instance serial number string.</td>
+<td rowspan="2">See <a href="#devicestatus">Querying for Emulator/Device Instances</a> for more information. </td>
+</tr>
+
+<tr>
+<td><code>get-state</code></td>
+<td>Prints the adb state of an emulator/device instance.</td>
+</td>
+</tr>
+
+<tr>
+<td><code>wait-for-device</code></td>
+<td>Blocks execution until the device is online — that is, until the instance state is <code>device</code>.</td>
+<td>You can prepend this command to other adb commands, in which case adb will wait until the emulator/device instance is connected before issuing the other commands. Here's an example:
+<pre>adb wait-for-device shell getprop</pre>
+
+Note that this command does <em>not</em> cause adb to wait until the entire system is fully booted. For that reason, you should not prepend it to other commands that require a fully booted system. As an example, the <code>install</code> requires the Android package manager, which is available only after the system is fully booted. A command such as
+
+<pre>adb wait-for-device install <app>.apk</pre>
+
+would issue the <code>install</code> command as soon as the emulator or device instance connected to the adb server, but before the Android system was fully booted, so it would result in an error. </td>
+</tr>
+
+
+
+<tr>
+<td rowspan="2">Server</td>
+<td><code>start-server</code></td>
+<td>Checks whether the adb server process is running and starts it, if not.</td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>kill-server</code></td>
+<td>Terminates the adb server process.</td>
+<td> </td>
+</tr>
+
+
+
+<tr>
+<td rowspan="2">Shell</td>
+<td><code>shell</code></td>
+<td>Starts a remote shell in the target emulator/device instance.</td>
+<td rowspan="2">See <a href="#shellcommands">Issuing Shell Commands</a> for more information. </td>
+</tr>
+
+<tr>
+<td><code>shell [<shellCommand>]</code></td>
+<td>Issues a shell command in the target emulator/device instance and then exits the remote shell.</td>
+</tr>
+
+</table>
+
+
+<a name="shellcommands"></a>
+
+<h2>Issuing Shell Commands</h2>
+
+<p>Adb provides an ash shell that you can use to run a variety of commands on an emulator
+or device. The command binaries are stored in the file system of the emulator or device,
+in this location: </p>
+
+<pre>/system/bin/...</pre>
+
+<p>You can use the <code>shell</code> command to issue commands, with or without entering the adb remote shell on the emulator/device. </p>
+
+<p>To issue a single command without entering a remote shell, use the <code>shell</code> command like this: </p>
+
+ <pre>adb [-d|-e|-s {<serialNumber>}] shell <shellCommand></pre>
+
+<p>To drop into a remote shell on a emulator/device instance, use the <code>shell</code> command like this:</p>
+
+ <pre>adb [-d|-e|-s {<serialNumber>}] shell</pre>
+
+<p>When you are ready to exit the remote shell, use <code>CTRL+D</code> or <code>exit</code> to end the shell session. </p>
+
+<p>The sections below provide more information about shell commands that you can use.</p>
+
+<a name="sqlite" id="sqlite"></a>
+
+<h3>Examining sqlite3 Databases from a Remote Shell</h3>
+
+<p>From an adb remote shell, you can use the
+<a href="http://www.sqlite.org/sqlite.html">sqlite3</a> command-line program to
+manage SQLite databases created by Android applications. The
+<code>sqlite3</code> tool includes many useful commands, such as
+<code>.dump</code> to print out the contents of a table and
+<code>.schema</code> to print the SQL CREATE statement for an existing table.
+The tool also gives you the ability to execute SQLite commands on the fly.</p>
+
+<p>To use <code>sqlite3</code>, enter a remote shell on the emulator instance, as described above, then invoke the tool using the <code>sqlite3</code> command. Optionally, when invoking <code>sqlite3</code> you can specify the full path to the database you want to explore. Emulator/device instances store SQLite3 databases in the folder <code><span chatdir="1"><span chatindex="259474B4B070F261">/data/data/<em><package_name></em>/databases</span></span>/</code>. </p>
+
+<p>Here's an example: </p>
+
+<pre>$ adb -s emulator-5554 shell
+# sqlite3 /data/data/com.example.google.rss.rssexample/databases/rssitems.db
+SQLite version 3.3.12
+Enter ".help" for instructions
+<em>.... enter commands, then quit...</em>
+sqlite> .exit </pre>
+
+<p>Once you've invoked <code>sqlite3</code>, you can issue <code>sqlite3</code> commands in the shell. To exit and return to the adb remote shell, use <code>exit</code> or <code>CTRL+D</code>.
+
+
+<a name="monkey"></a>
+
+<h3>UI/Application Exerciser Monkey</h3>
+
+<p>The Monkey is a program that runs on your emulator or device and generates pseudo-random
+streams of user events such as clicks, touches, or gestures, as well as a number of system-level
+events. You can use the Monkey to stress-test applications that you are developing,
+in a random yet repeatable manner.</p>
+
+<p>The simplest way to use the monkey is with the following command, which will launch your
+application and send 500 pseudo-random events to it.</p>
+
+<pre>$ adb shell monkey -v -p your.package.name 500</pre>
+
+<p>For more information about command options for Monkey, see the complete
+<a href="{@docRoot}tools/help/monkey.html" title="monkey">UI/Application Exerciser Monkey</a> documentation page.</p>
+
+
+<a name="othershellcommands"></a>
+
+<h3>Other Shell Commands</h3>
+
+<p>The table below lists several of the adb shell commands available. For a complete list of commands and programs, start an emulator instance and use the <code>adb -help</code> command. </p>
+
+<pre>adb shell ls /system/bin</pre>
+
+<p>Help is available for most of the commands. </p>
+
+<table>
+<tr>
+ <th>Shell Command</th>
+ <th>Description</th>
+ <th>Comments</th>
+</tr>
+
+<tr>
+<td><code>dumpsys</code></td>
+<td>Dumps system data to the screen.</td>
+<td rowspan=4">The <a href="{@docRoot}tools/debugging/ddms.html">Dalvik Debug Monitor Server</a>
+(DDMS) tool offers integrated debug environment that you may find easier to use.</td>
+</tr>
+
+<tr>
+<td><code>dumpstate</code></td>
+<td>Dumps state to a file.</td>
+</tr>
+
+<tr>
+<td><code>logcat [<option>]... [<filter-spec>]...</code></td>
+<td>Enables radio logging and prints output to the screen. </td>
+</tr>
+
+<tr>
+<td><code>dmesg</code></td>
+<td>Prints kernel debugging messages to the screen. </td>
+</tr>
+
+<tr>
+<td><code>start</code></td>
+<td>Starts (restarts) an emulator/device instance.</td>
+<td> </td>
+</tr>
+
+<tr>
+<td><code>stop</code></td>
+<td>Stops execution of an emulator/device instance.</td>
+<td> </td>
+</tr>
+
+</table>
+
+<a name="logcat"></a>
+
+<h2>Enabling logcat Logging</h2>
+
+<p>The Android logging system provides a mechanism for collecting and viewing system debug output. Logs from various applications and portions of the system are collected in a series of circular buffers, which then can be viewed and filtered by the <code>logcat</code> command.</p>
+
+<a name="usinglogcat"></a>
+
+<h3>Using logcat Commands</h3>
+
+<p>You can use the <code>logcat</code> command to view and follow the contents of the system's log buffers. The general usage is:</p>
+
+<pre>[adb] logcat [<option>] ... [<filter-spec>] ...</pre>
+
+<p>The sections below explain filter specifications and the command options. See <a href="#logcatoptions">Listing of logcat Command Options</a> for a summary of options. </p>
+
+<p>You can use the <code>logcat</code> command from your development computer or from a remote adb shell in an emulator/device instance. To view log output in your development computer, you use</p>
+
+<pre>$ adb logcat</pre>
+
+<p>and from a remote adb shell you use</p>
+
+<pre># logcat</pre>
+
+<a name="filteringoutput"></a>
+
+<h3>Filtering Log Output</h3>
+
+<p>Every Android log message has a <em>tag</em> and a <em>priority</em> associated with it. </p>
+
+<ul>
+<li>The tag of a log message is a short string indicating the system component from which the message originates (for example, "View" for the view system). </li>
+
+<li>The priority is one of the following character values, ordered from lowest to highest priority:</li>
+
+<ul>
+ <li><code>V</code> — Verbose (lowest priority)</li>
+ <li><code>D</code> — Debug</li>
+ <li><code>I</code> — Info (default priority)</li>
+ <li><code>W</code> — Warning</li>
+ <li><code>E</code> — Error</li>
+ <li><code>F</code> — Fatal</li>
+ <li><code>S</code> — Silent (highest priority, on which nothing is ever printed)</li>
+</ul>
+</ul>
+
+<p>You can obtain a list of tags used in the system, together with priorities, by running <code>logcat</code> and observing the first two columns
+of each message, given as <code><priority>/<tag></code>. </p>
+
+<p>Here's an example of logcat output that shows that the message relates to priority level "I" and tag "ActivityManager":</p>
+
+<pre>I/ActivityManager( 585): Starting activity: Intent { action=android.intent.action...}</pre>
+
+<p>To reduce the log output to a manageable level, you can restrict log output using <em>filter expressions</em>. Filter expressions let you indicate to the system the tags-priority combinations that you are interested in — the system suppresses other messages for the specified tags. </p>
+
+<p>A filter expression follows this format <code>tag:priority ...</code>, where <code>tag</code> indicates the tag of interest and <code>priority</code> indicates the <em>minimum</em> level of priority to report for that tag. Messages for that tag at or above the specified priority are written to the log. You can supply any number of <code>tag:priority</code> specifications in a single filter expression. The series of specifications is whitespace-delimited. The default output is to show all log messages with the Info priority (*:I).</p>
+
+<p>Here's an example of a filter expression that suppresses all log messages except those with the tag "ActivityManager", at priority "Info" or above, and all log messages with tag "MyApp", with priority "Debug" or above:</p>
+
+<pre>adb logcat ActivityManager:I MyApp:D *:S</pre>
+
+<p>The final element in the above expression, <code>*:S</code>, sets the priority level for all tags to "silent", thus ensuring only log messages with "View" and "MyApp" are displayed. Using <code>*:S</code> is an excellent way to ensure that log output is restricted to the filters that you have explicitly specified — it lets your filters serve as a "whitelist" for log output.</p>
+
+<p>The following filter expression displays all log messages with priority level "warning" and higher, on all tags:</p>
+
+<pre>adb logcat *:W</pre>
+
+<p>If you're running <code>logcat</code> from your development computer (versus running it on a remote adb shell), you can also set a default filter expression by exporting a value for the environment variable <code>ANDROID_LOG_TAGS</code>:</p>
+
+<pre>export ANDROID_LOG_TAGS="ActivityManager:I MyApp:D *:S"</pre>
+
+<p>Note that <code>ANDROID_LOG_TAGS</code> filter is not exported to the emulator/device instance, if you are running <code>logcat</code> from a remote shell or using <code>adb shell logcat</code>.</p>
+
+
+<a name="outputformat"></a>
+
+<h3>Controlling Log Output Format</h3>
+
+<p>Log messages contain a number of metadata fields, in addition to the tag and priority. You can modify the output format for messages so that they display a specific metadata field. To do so, you use the <code>-v</code> option and specify one of the supported output formats listed below. </p>
+
+<ul>
+ <li><code>brief</code> — Display priority/tag and the PID of process issuing the message (the default format).</li>
+ <li><code>process</code> — Display PID only.</li>
+ <li><code>tag</code> — Display the priority/tag only. </li>
+ <li><code>raw</code> — Display the raw log message, with no other metadata fields.</li>
+ <li><code>time</code> — Display the date, invocation time, priority/tag, and PID of the process issuing the message.</li>
+ <li><code>threadtime</code> — Display the date, invocation time, priority, tag, and the PID and TID of the thread issuing the message.</li>
+ <li><code>long</code> — Display all metadata fields and separate messages with a blank lines.</li>
+</ul>
+
+<p>When starting <code>logcat</code>, you can specify the output format you want by using the <code>-v</code> option:</p>
+
+<pre>[adb] logcat [-v <format>]</pre>
+
+<p>Here's an example that shows how to generate messages in <code>thread</code> output format: </p>
+
+<pre>adb logcat -v thread</pre>
+
+<p>Note that you can only specify one output format with the <code>-v</code> option. </p>
+
+<a name="alternativebuffers"></a>
+
+<h3>Viewing Alternative Log Buffers </h3>
+
+<p>The Android logging system keeps multiple circular buffers for log messages, and not all of the log messages are sent to the default circular buffer. To see additional log messages, you can start <code>logcat</code> with the <code>-b</code> option, to request viewing of an alternate circular buffer. You can view any of these alternate buffers: </p>
+
+<ul>
+<li><code>radio</code> — View the buffer that contains radio/telephony related messages.</li>
+<li><code>events</code> — View the buffer containing events-related messages.</li>
+<li><code>main</code> — View the main log buffer (default)</li>
+</ul>
+
+<p>The usage of the <code>-b</code> option is:</p>
+
+<pre>[adb] logcat [-b <buffer>]</pre>
+
+<p>Here's an example of how to view a log buffer containing radio and telephony messages: </p>
+
+<pre>adb logcat -b radio</b></pre>
+
+<a name="stdout"></a>
+
+<h3>Viewing stdout and stderr</h3>
+
+<p>By default, the Android system sends <code>stdout</code> and <code>stderr</code> (<code>System.out</code> and <code>System.err</code>) output to <code>/dev/null</code>. In
+processes that run the Dalvik VM, you can have the system write a copy of the output to the log file. In this case, the system writes the messages to the log using the log tags <code>stdout</code> and <code>stderr</code>, both with priority <code>I</code>. </p>
+
+<p>To route the output in this way, you stop a running emulator/device instance and then use the shell command <code>setprop</code> to enable the redirection of output. Here's how you do it: </p>
+
+<pre>$ adb shell stop
+$ adb shell setprop log.redirect-stdio true
+$ adb shell start</pre>
+
+<p>The system retains this setting until you terminate the emulator/device instance. To use the setting as a default on the emulator/device instance, you can add an entry to <code>/data/local.prop</code>
+on the device.</p>
+
+<a name="logcatoptions"></a>
+
+<h3>Listing of logcat Command Options</h3>
+
+<table>
+<tr>
+ <th>Option</th>
+ <th>Description</th>
+</tr>
+
+<tr>
+<td><code>-b <buffer></code></td>
+<td>Loads an alternate log buffer for viewing, such as <code>event</code> or <code>radio</code>. The <code>main</code> buffer is used by default. See <a href="#alternativebuffers">Viewing Alternative Log Buffers</a>.</td>
+</tr>
+
+<tr>
+<td><code>-c</code></td>
+<td>Clears (flushes) the entire log and exits. </td>
+</tr>
+
+<tr>
+<td><code>-d</code></td>
+<td>Dumps the log to the screen and exits.</td>
+</tr>
+
+<tr>
+<td><code>-f <filename></code></td>
+<td>Writes log message output to <code><filename></code>. The default is <code>stdout</code>.</td>
+</tr>
+
+<tr>
+<td><code>-g</code></td>
+<td>Prints the size of the specified log buffer and exits. </td>
+</tr>
+
+<tr>
+<td><code>-n <count></code></td>
+<td>Sets the maximum number of rotated logs to <code><count></code>. The default value is 4. Requires the <code>-r</code> option. </td>
+</tr>
+
+<tr>
+<td><code>-r <kbytes></code></td>
+<td>Rotates the log file every <code><kbytes></code> of output. The default value is 16. Requires the <code>-f</code> option. </td>
+</tr>
+
+<tr>
+<td><code>-s</code></td>
+<td>Sets the default filter spec to silent. </td>
+</tr>
+
+<tr>
+<td><code>-v <format></code></td>
+<td>Sets the output format for log messages. The default is <code>brief</code> format. For a list of supported formats, see <a href="#outputformat">Controlling Log Output Format</a>.</td>
+</tr>
+
+</table>
+
+<a name="stopping"></a>
+
+<h2>Stopping the adb Server</h2>
+
+<p>In some cases, you might need to terminate the adb server process and then restart it. For example, if adb does not respond to a command, you can terminate the server and restart it and that may resolve the problem. </p>
+
+<p>To stop the adb server, use the <code>kill-server</code>. You can then restart the server by issuing any adb command. </p>
+
+
diff --git a/docs/html/tools/help/adt.jd b/docs/html/tools/help/adt.jd
new file mode 100644
index 0000000..cd5bc67
--- /dev/null
+++ b/docs/html/tools/help/adt.jd
@@ -0,0 +1,527 @@
+page.title=Android Developer Tools
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#tools">SDK Tools Integration</a></li>
+
+ <li><a href="#editors">Code Editors</a>
+ <ol>
+ <li><a href="#resource-linking">Resource linking enhancements</a></li>
+ </ol>
+ </li>
+
+ <li><a href="#graphical-editor">Graphical Layout Editor</a>
+ <ol>
+ <li><a href="#canvas">Canvas and outline view</a></li>
+ <li><a href="#palette">Palette</a></li>
+ <li><a href="#config-chooser">Configuration chooser</a></li>
+ </ol>
+ </li>
+
+ <li><a href="#refactoring">Layout Factoring Support</a></li>
+
+ </ol>
+
+ <h2>Related videos</h2>
+
+ <ol>
+ <li><a href="{@docRoot}videos/index.html#v=Oq05KqjXTvs">Android Developer Tools
+ Google I/O Session</a>
+ </li>
+ </ol>
+
+ <h2>See also</h2>
+
+ <ol>
+ <li><a href="http://tools.android.com/recent">Android Tools change blog</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>ADT (Android Developer Tools) is a plugin for Eclipse that provides a suite of
+ tools that are integrated with the Eclipse IDE. It offers you access to many features that help
+ you develop Android applications quickly. ADT
+ provides GUI access to many of the command line SDK tools as well as a UI design tool for rapid
+ prototyping, designing, and building of your application's user interface.</p>
+
+ <p>Because ADT is a plugin for Eclipse, you get the functionality of a well-established IDE,
+ along with Android-specific features that are bundled with ADT. The following
+ describes important features of Eclipse and ADT:</p>
+
+ <dl>
+ <dt><strong>Integrated Android project creation, building, packaging, installation, and
+ debugging</strong></dt>
+
+ <dd>ADT integrates many development workflow tasks into Eclipse, making it easy for you to
+ rapidly develop and test your Android applications.</dd>
+
+ <dt><strong>SDK Tools integration</strong></dt>
+
+ <dd>Many of the <a href="#tools">SDK tools</a> are integrated into Eclipse's menus,
+ perspectives, or as a part of background processes ran by ADT.</dd>
+
+ <dt><strong>Java programming language and XML editors</strong></dt>
+
+ <dd>The Java programming language editor contains common IDE features such as compile time
+ syntax checking, auto-completion, and integrated documentation for the Android framework APIs.
+ ADT also provides custom XML editors that let you
+ edit Android-specific XML files in a form-based UI. A graphical layout editor lets you design
+ user interfaces with a drag and drop interface.</dd>
+
+ <dt><strong>Integrated documentation for Android framework APIs</strong></dt>
+ <dd>You can access documentation by hovering over classes, methods, or variables.</dd>
+ </dl>
+
+ <p>You can find the most up-to-date and more detailed information about changes and new features
+on the <a href="http://tools.android.com/recent">Recent Changes</a> page at the Android Tools
+Project site.</p>
+
+ <h2 id="tools">SDK Tools Integration</h2>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Need help designing icons?</h2>
+ <p>The <a href="http://android-ui-utils.googlecode.com/hg/asset-studio/dist/index.html">Android
+ Asset Studio</a> is a web-based tool that lets you generate icons from existing images,
+ clipart, or text. It also generates the icons with different DPIs for different screen sizes and
+ types.</p>
+
+ </div>
+ </div>
+
+ <p>Many of the tools that you can start or run from the command line are integrated into ADT.
+ They include:</p>
+
+ <ul>
+ <li><a href="{@docRoot}tools/debugging/debugging-tracing.html">Traceview</a>:
+ Allows you to profile your program's execution
+ (<strong>Window > Open Perspective > Traceview</strong>). </li>
+
+ <li><a href="{@docRoot}tools/help/android.html">android</a>: Provides access to
+ the Android SDK Manager and AVD Manager. Other <code>android</code> features such as creating or
+ updating projects (application and library) are integrated throughout the Eclipse IDE. </li>
+
+ <li><a href="{@docRoot}tools/debugging/debugging-ui.html#HierarchyViewer">Hierarchy
+ Viewer</a>: Allows you to visualize your application's view hierarchy to find inefficiencies
+ (<strong>Window > Open Perspective > Hierarchy Viewer</strong>).</li>
+
+ <li><a href="{@docRoot}tools/debugging/debugging-ui.html#pixelperfect">Pixel
+ Perfect</a>: Allows you to closely examine your UI to help with designing and building.
+ (<strong>Window > Open Perspective > Pixel Perfect</strong>).</li>
+
+ <li><a href="{@docRoot}tools/debugging/ddms.html">DDMS</a>: Provides
+ debugging features including: screen capturing, thread and heap information, and logcat
+ (<strong>Window > Open Perspective > DDMS</strong>).</li>
+
+ <li><a href="{@docRoot}tools/help/adb.html">adb</a>: Provides access to
+ a device from your development system. Some features of
+ <code>adb</code> are integrated into ADT such as project installation (Eclipse run menu),
+ file transfer, device enumeration, and logcat (DDMS). You must access the more advanced
+ features of <code>adb</code>, such as shell commands, from the command line.</li>
+
+ <li><a href="{@docRoot}tools/help/proguard.html">ProGuard</a>: Allows code obfuscation,
+ shrinking, and optimization. ADT integrates ProGuard as part of the build, if you <a href=
+ "{@docRoot}tools/help/proguard.html#enabling">enable it</a>.</li>
+ </ul>
+
+<h2 id="editors">Code Editors</h2>
+
+ <p>In addition to Eclipse's standard editor features, ADT provides custom XML editors to help
+ you create and edit Android manifests, resources, menus, and layouts in a form-based or graphical
+ mode. Double-clicking on an XML file in Eclipse's package explorer opens the
+ appropriate XML editor.
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Google I/O Session Video</h2>
+ <p>View the segment on the <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=30m50s">XML editors</a> for more
+ information.</p>
+ </div>
+ </div>
+
+ <p class="note"><strong>Note:</strong> You can edit Android-specific XML files (such as a layout
+or manifest) in both a graphical mode and also an XML markup mode. You can switch between
+these modes with the pair of tabs at the bottom of each custom XML editor.</p>
+
+ <p>In addition, some special file types that don't have custom editors, such as drawables, animations,
+ and color files offer editing enhancements such as XML tag completion.</p>
+
+<p>ADT provides the following custom, form-based XML editors:</p>
+
+ <dl>
+
+ <dt><strong>Graphical Layout Editor</strong></dt>
+
+ <dd>Edit and design your XML layout files with a drag and drop interface. The layout editor
+ renders your interface as well, offering you a preview as you design your layouts. This editor
+ is invoked when you open an XML file with a view declared (usually declared in
+ <code>res/layout</code>. For more information, see <a href="#graphical-editor">Graphical Layout
+ Editor</a>.</dd>
+
+ <dt><strong>Android Manifest Editor</strong></dt>
+
+ <dd>Edit Android manifests with a simple graphical interface. This editor is invoked
+ when you open an <code>AndroidManifest.xml</code> file.</dd>
+
+ <dt><strong>Menu Editor</strong></dt>
+
+ <dd>Edit menu groups and items with a simple graphical interface. This editor is
+ invoked when you open an XML file with a <code><menu></code> declared (usually located in
+ the <code>res/menu</code> folder).</dd>
+
+ <dt><strong>Resources Editor</strong></dt>
+
+ <dd>Edit resources with a simple graphical interface. This editor is invoked when
+ you open an XML file with a <code><resources></code> tag declared.</dd>
+
+ <dt><strong>XML Resources Editor</strong></dt>
+
+ <dd>Edit XML resources with a simple graphical interface. This editor is invoked
+ when you open an XML file.</dd>
+ </dl>
+
+
+ <h3 id="resource-linking">Resource linking enhancements</h3>
+ <p>In addition to the normal code editing features of Eclipse, ADT provides enhancements to the Android
+ development experience that allow you to quickly jump to declarations of various types of resources such
+ as strings or layout files. You can access these enhancements by holding down the control key and
+ clicking on the following items:
+
+ <ul>
+
+ <li>A resource identifier, such as <code>R.id.button1</code>, jumps
+ to the XML definition of the view.</li>
+
+ <li>A declaration in the <code>R.java</code> file, such as <code>public
+ static final int Button01=0x7f050000"</code>, jumps to the corresponding XML definition.</li>
+
+ <li>An activity or service definition in your manifest, such as
+ <code><activity android:name=".TestActivity"></code>, jumps to the corresponding Java class. You can
+ jump from an activity definition (or service definition) into the corresponding Java class.</li>
+
+ <li>You can jump to any value definition (e.g. <code>@string:foo</code>), regardless of
+which XML file
+ "foo" is defined in.</li>
+
+ <li>Any file-based declaration, such as <code>@layout/bar</code>, opens the file.</li>
+
+ <li>Non-XML resources, such as <code>@drawable/icon</code>, launches
+ Eclipse's default application for the given file type, which in this case is an
+ image.</li>
+
+ <li><code>@android</code> namespace resources opens the resources found in
+ the SDK install area.</li>
+
+ <li>Custom views in XML layouts, such as <code><foo.bar.MyView></foo.bar.MyView></code>,
+ or <code><view class="foo.bar.MyView"></code>) jump to the corresponding custom view classes.</li>
+
+ <li>An XML attribute such as <code>@android:string/ok</code> or <code>android.R.string.id</code> in Java code
+ opens the file that declares the strings. The XML tab opens when doing this, not
+ the form-based editor.</li>
+
+ </ul>
+
+ <h2 id="graphical-editor">Graphical Layout Editor</h2>
+
+ <p>ADT provides many features to allow you to design and build your application's user interface.
+ Many of these features are in the graphical layout editor, which you can access by opening one of
+ your application's XML layout files in Eclipse.
+ </p>
+
+ <p>The graphical layout editor is the main screen that you use to visually design and build your
+ UI. It is split up into the following parts:</p>
+
+ <dl>
+ <dt><strong>Canvas</strong></dt>
+
+ <dd>In the middle of the editor is the canvas. It provides the rendered view of your
+ layout and supports dragging and dropping of UI widgets
+ directly from the palette. You can select the platform version used to render the items in
+ the canvas. Each platform version has its own look and feel, which might be the similar to or
+ radically different from another platform version. The canvas renders the appropriate look
+ and feel for the currently selected platform version.
+ This platform version does not need to be the same as the version that your
+ application targets.
+
+ <p>The canvas also provides
+ context-sensitive actions in the layout actions bar, such as adjusting layout margins and
+orientation.
+ The layout actions bar displays available actions depending on the selected UI element in the
+ canvas.</p>
+ </dd>
+
+ <dt><strong>Outline</strong></dt>
+
+ <dd>On the right side of the editor is the outline view. It displays a hierarchical
+ view of your layout where you can do things such as reorder of views. The outline
+ view exposes similar functionality as the canvas but displays your layout in an ordered
+ list instead of a rendered preview.</dd>
+
+ <dt><strong>Palette</strong></dt>
+
+ <dd>On the left side of the editor is the palette. It provides a set of widgets that
+ you can drag onto the canvas. The palette shows rendered previews of the
+ widgets for easy lookup of desired UI widgets.</dd>
+
+ <dt><strong>Configuration Chooser</strong></dt>
+
+ <dd>At the top of the editor is the configuration chooser.
+ It provides options to change a layout's rendering mode or screen type.</dd>
+ </dl>
+
+ <img src="{@docRoot}images/layout_editor.png" alt="graphical layout editor screenshot"
+ height="500" id="layout-editor" name="layout-editor">
+
+ <p class="img-caption"><strong>Figure 1.</strong> Graphical layout editor</p>
+
+ <h3 id="canvas">Canvas and outline view</h3>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Google I/O Session Video</h2>
+
+ <p>View the segment on the <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=7m16s">canvas and outline view</a> and the
+ <a href="http://www.youtube.com/watch?v=Oq05KqjXTvs#t=11m43s">layout actions bar</a>
+ for more information.
+ </p>
+ </div>
+ </div>
+
+ <p>The canvas is the area where you can drag and drop UI widgets from the palette to design your
+ layout. The canvas offers a rendered preview of your layout depending on factors such as the
+ selected platform version, screen orientation, and currently selected theme that you specify in
+ the <a href="#configuration-chooser">configuration chooser</a>. You can also drag and drop
+ items into the outline view, which displays your layout in a hierarchical list. The outline view
+ exposes much of the same functionality as the canvas but offers another method of organization
+ that is beneficial for ordering and quickly selecting items. When you right-click a specific item
+ in the canvas or outline view, you can access a context-sensitive menu that lets you modify the
+ following attributes of the layout or view:</p>
+
+ <dl>
+ <dt><strong>View and layout properties</strong></dt>
+
+ <dd>
+ When you right-click a view or layout in the canvas or outline view, it brings up a
+ context-sensitive menu that lets you set things such as:
+
+ <ul>
+ <li>ID of the view or layout</li>
+
+ <li>Text of the view</li>
+
+ <li>Layout width</li>
+
+ <li>Layout height</li>
+
+ <li>Properties such as alpha or clickable</li>
+ </ul>
+ </dd>
+
+ <dt><strong>Animation preview and creation</strong></dt>
+
+ <dd>
+ If your layout or view is animated, you can preview the animation directly in the canvas
+ (when you select Android 3.0 or later as the platform version in the configuration chooser).
+ Right-click an item in the canvas and select <strong>Play Animation</strong>. If
+ animation is not associated with item, an option is available in the menu to create one.
+
+ <p>View the segment on the <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=28m30s">animation features</a> for more
+ information.</p>
+ </dd>
+
+ <dt><strong>Extract as Include</strong></dt>
+
+ <dd>You can extract parts of a current layout into its own layout file,
+ which you can then include in any layout with a single line of XML. See <a href=
+ "#extract-as-include">Layout Refactoring Support</a> for more information.</dd>
+ </dl>
+
+ <h4>Other canvas features</h4>
+
+ <p>The canvas has additional features not available in the outline view:</p>
+
+ <ul>
+
+ <li>Edit views with the layout actions bar: The context-sensitive layout actions bar allows you to
+ edit how a view is laid out in your UI. The available actions depend on the currently
+ selected view and its parent layout. Some common actions include
+ toggling the fill mode of the view and specifying margins. For instance, if you select a
+ {@link android.widget.Button}
+ in a {@link android.widget.LinearLayout}, you see actions related to the {@link
+android.widget.LinearLayout}, such as a toggle to switch
+ between horizontal and vertical layout, and a toggle to control whether its children are
+ aligned along their text baseline. You will also see toolbar actions to control the individual
+ layout attributes of the child, such as whether the child should stretch out to match its
+ parent's width and height, a dropdown action to set the child's layout gravity, a button to open
+ a margin editor, and a layout weight editor.</li>
+
+ <li>Edit a nested layout in its current context: If you are editing a layout
+ that includes another layout, you can edit the included layout in the layout that included
+ it.</li>
+
+ <li>Preview drag and drop location: When you drag and drop a UI widget onto the canvas, ruler
+ markers appear showing you the approximate location of the UI widget depending on the
+ type of layout, such as {@link android.widget.RelativeLayout} or {@link
+ android.widget.LinearLayout}.</li>
+
+ <li>Preview animations: You can preview view and layout animations when you select Android 2.1
+ or later for the platform version in the configuration bar.</li>
+
+ <li>Render layouts in real-time: Layouts are rendered as accurately as possible according to
+ the platform version, including the appropriate system and action bars.</li>
+
+ <li>Support for fragments: Fragments can be rendered in the same screen as the layout that
+ includes the fragments.</li>
+
+ </ul>
+
+ <img src="{@docRoot}images/canvas.png" alt="screenshot of the canvas" height="553">
+
+ <p class="img-caption"><strong>Figure 2.</strong> Canvas portion of the layout editor showing
+ a rendered preview of an application</p>
+
+ <img src=
+ "{@docRoot}images/layout_outline.png" alt="screenshot of the outline view" height="185">
+
+ <p class="img-caption"><strong>Figure 3.</strong> Outline view showing current layout's structure</p>
+
+ <h3 id="palette">Palette</h3>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Google I/O Session Video</h2>
+
+ <p>View the segment on the <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=7m53s">palette</a> for more information.</p>
+ </div>
+ </div>
+
+ <p>The palette contains the UI widgets that you can drag and drop onto the canvas and add to your
+ layout. The pallete categorizes the widgets and shows rendered previews
+ for easier lookup. The main features of the palette include:</p>
+
+ <ul>
+ <li>Different modes of rendered previews include: icons only, icons and text, tiny previews,
+ small previews, and previews (rendered in real size). Previews are only available for layouts
+ rendered with the latest revisions of Android 2.1 (API Level 7) or later.</li>
+
+ <li>Custom views in your project or library projects are added under custom views
+ category.</li>
+
+ <li>Arrange UI widgets alphabetically or by category.</li>
+ </ul>
+ <img src="{@docRoot}images/palette.png" alt="palette screenshot" height="566">
+
+ <p class="img-caption"><strong>Figure 4.</strong> Palette showing available UI widgets</p>
+
+ <h3 id="config-chooser">Configuration chooser</h3>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Google I/O Session Video</h2>
+
+ <p>View the segment on the <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=12m51s">configuration chooser</a> for more
+ information.</p>
+ </div>
+ </div>
+
+
+ <p>The configuration chooser allows you to create and configure different configurations of
+ a layout for different situations, such as one for landscape and one for portrait mode. You can
+ set the following options for each configuration of a layout:
+ </p>
+ <ul>
+ <li>Screen type combo box: Predefined screen settings for common device configurations. You
+ can also create your own by selecting <strong>Custom...</strong>.</li>
+
+ <li>Screen orientation combo box: Portrait or Landscape screen orientation.</li>
+
+ <li>Theme combo box: Predefined themes or a custom theme that you have created.</li>
+
+ <li>Platform combo box: Platform version used to render the canvas and palette as well as
+ displaying appropriate themes.</li>
+
+ <li>Custom layout combo boxes: The locale, dock, and time of day combo boxes let you select
+ different versions of the same layout depending on the device's current state. You can
+ create a new version of a layout with the <strong>Create</strong> button.</li>
+ </ul>
+
+ <img src="{@docRoot}images/layout_bar.png" alt=
+ "configuration chooser screenshot" height="50" id="configuration-chooser" name="configuration chooser">
+
+ <p class="img-caption"><strong>Figure 5.</strong> Configuration chooser</p>
+
+ <h2 id="refactoring">Layout Refactoring Support</h2>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Google I/O Session Video</h2>
+
+ <p>View the segment on <a href=
+ "http://www.youtube.com/watch?v=Oq05KqjXTvs#t=18m00s">refactoring features</a> for a rundown
+of the more important refactoring features.</p>
+
+ </div>
+ </div>
+
+ <p>In both the graphical and XML layout editor, there are many features that help you quickly
+ refactor your layouts. The following list describes the major refactoring support:</p>
+
+ <dl>
+
+ <dt><strong>Change layout</strong></dt>
+ <dd>This lets you change the layout on the fly and re-renders the canvas for you.
+ You can apply this refactoring to any layout and the layout is converted to the new type if
+ possible. In many cases, the opening and closing tags of the layout's XML element are changed
+ along with things such as ID attributes and their references. However, for some supported
+ types, ADT attempts to preserve the layout, such as changing a {@link
+ android.widget.LinearLayout} to a {@link android.widget.RelativeLayout}.</dd>
+
+ <dt><strong>Change widget</strong></dt>
+ <dd>This lets you select one or more widgets and converts them to a new widget type. In
+ addition to changing the element name, it also removes any
+ attributes that are not supported by the new widget type and adds in any mandatory attributes
+ required by the new widget type. If the current ID of a widget includes the
+ current widget type in its ID (such as a <code><Button></code> widget named
+ <code>"button1"</code>), then the ID is changed to match the new widget type and all
+ references are updated.</dd>
+
+ <dt id="extract-as-include"><strong>Extract as include</strong></dt>
+ <dd>This lets you extract views inside of an existing layout into their own separate layout
+ file. An <code>include</code> tag that points to the newly created layout file is inserted
+ into the existing layout file. Right-click the view or layout and select <strong>Extract as
+ Include...</strong>.</dd>
+
+ <dt><strong>Extract string</strong></dt>
+ <dd>Extract strings from either XML or Java files into their own separate resource file.</dd>
+
+ <dt><strong>Extract style</strong></dt>
+ <dd>Extract style-related attributes from a layout and define them in a new
+ <code>styles.xml</code> file. You can select multiple views and this refactoring extracts all
+ of the same styles into one style and assigns that style to all the views that use it.</dd>
+
+ <dt><strong>Wrap-in container</strong></dt>
+ <dd>This lets you select one or more sibling elements and wrap them in a new container. This
+ can be applied to the root element as well, in which case the namespace declaration attributes
+ will be transferred to the new root. This refactoring also transfers <code>layout_</code>
+ attribute references to the new root, For example, suppose you have a {@link android.widget.RelativeLayout}.
+ If other widgets have layout constraints pointing to your widget, wrapping the widget causes
+ these constraints to point to the parent instead.</dd>
+
+ <dt><strong>Quick Assistant</strong></dt>
+ <dd>Provides refactoring suggestions depending on the current context. Press
+ <strong>Ctrl-1</strong> (or <strong>Cmd-1</strong> on
+ Mac) in an editor, and Eclipse provides a list of possible refactorings depending on the
+ context. The Quick Assistant provides fast access to all of the above refactorings, where applicable.
+ For example, if you are editing an XML value and decide you want to extract it out
+ as a string, place the text cursor in the string and press Ctrl-1 to see the refactoring context
+ menu.</dd>
+ </dl>
diff --git a/docs/html/tools/help/android.jd b/docs/html/tools/help/android.jd
new file mode 100644
index 0000000..282c791
--- /dev/null
+++ b/docs/html/tools/help/android.jd
@@ -0,0 +1,393 @@
+page.title=android
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>{@code android} is an important development tool that lets you:</p>
+
+ <ul>
+ <li>Create, delete, and view Android Virtual Devices (AVDs). See <a href=
+ "{@docRoot}tools/devices/managing-avds-cmdline.html">Managing AVDs from the Command
+Line</a>.</li>
+
+ <li>Create and update Android projects. See <a href=
+ "{@docRoot}tools/projects/projects-cmdline.html">Managing Projects from
+ the Command Line</a>.</li>
+
+ <li>Update your Android SDK with new platforms, add-ons, and documentation. See <a href=
+ "{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</li>
+ </ul>If you are using Eclipse, the <code>android</code> tool's features are integrated
+ into ADT, so you should not need to use this tool directly.
+
+ <p class="note"><strong>Note:</strong> The documentation of options below is not exhaustive
+and may be out of date. For the most current list of options, execute <code>android
+--help</code>.</p>
+
+
+
+
+ <h2>Syntax</h2>
+ <pre>android [global options] action [action options]</pre>
+
+ <h3>Global Options</h3>
+
+ <dl>
+ <dt><code>-s</code></dt>
+
+ <dd>Silent mode: only errors are printed out</dd>
+
+ <dt><code>-h</code></dt>
+
+ <dd>Usage help</dd>
+
+ <dt><code>-v</code></dt>
+
+ <dd>Verbose mode: errors, warnings and informational messages are printed.</dd>
+ </dl>
+
+ <h3>AVD actions and options</h3>
+
+ <table>
+ <tr>
+ <th width="15%">Action</th>
+
+ <th width="20%">Option</th>
+
+ <th width="30%">Description</th>
+
+ <th>Comments</th>
+ </tr>
+
+ <tr>
+ <td><code>avd</code></td>
+
+ <td>None</td>
+
+ <td>Launch the AVD Manager</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>sdk</code></td>
+
+ <td>None</td>
+
+ <td>Launch the Android SDK Manager</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td rowspan="6"><code>create avd</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name for the AVD.</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-t <targetID></code></td>
+
+ <td>Target ID of the system image to use with the new AVD. To obtain a list of available
+ targets, use <code>android list targets</code></td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-c <path>|<size>[K|M]</code></td>
+
+ <td>The path to the SD card image to use with this AVD or the size of a new SD card image to
+ create for this AVD. For example, <code>-c path/to/sdcard</code> or <code>-c
+ 1000M</code>.</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-f</code></td>
+
+ <td>Force creation of the AVD</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Path to the location at which to create the directory for this AVD's files.</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-s <name>|<width>-<height></code></td>
+
+ <td>The skin to use for this AVD, identified by name or dimensions. The <code>android</code>
+ tool scans for a matching skin by name or dimension in the <code>skins/</code> directory of
+ the target referenced in the <code>-t <targetID></code> argument. For example, <code>-s
+ HVGA-L</code></td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>delete avd</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name of the AVD to delete</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td rowspan="3"><code>move avd</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name of the AVD to move</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Path to the location at which to create the directory for this AVD's files.</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-r <new-name></code></td>
+
+ <td>New name of the AVD if you want to rename it</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>update avd</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name of the AVD to move</td>
+
+ <td>Required</td>
+ </tr>
+ </table>
+
+ <h3>Project actions and options</h3>
+
+ <table>
+ <tr>
+ <th width="15%">Action</th>
+
+ <th width="20%">Option</th>
+
+ <th width="30%">Description</th>
+
+ <th>Comments</th>
+ </tr>
+
+ <tr>
+ <td rowspan="5"><code>create project</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name for the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-t <targetID></code></td>
+
+ <td>Target ID of the system image to use with the new AVD. To obtain a list of available
+ targets, use <code>android list targets</code></td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-k <path>|<size>[K|M]</code></td>
+
+ <td>Package namespace</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-a</code></td>
+
+ <td>Name for the default Activity class</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Location of your project directory</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td rowspan="5"><code>update project</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name of the project to update</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Location path of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-l <library path></code></td>
+
+ <td>Location path of an Android Library to add, relative to the main project</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-s <subprojects></code></td>
+
+ <td>Update any projects in subfolders such as test projects</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-t <targetID></code></td>
+
+ <td>Target id to set for the project</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td rowspan="3"><code>create-test-project</code></td>
+
+ <td><code>-n <name></code></td>
+
+ <td>The name of the project</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Location path of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-m <main></code></td>
+
+ <td>The name of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td rowspan="2"><code>update-test-project</code></td>
+
+ <td><code>-p <path></code></td>
+
+ <td>Location path of the project to test, relative to the new project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-m <main></code></td>
+
+ <td>The main class of the project to test</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td rowspan="4"><code>create-lib-project</code></td>
+
+ <td><code>-k <packageName></code></td>
+
+ <td>(Required) Package name of the library project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-p <path></code></td>
+
+ <td>Location path of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-t <targetID></code></td>
+
+ <td>Target ID of the library project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-n <name></code></td>
+
+ <td>The name of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td rowspan="3"><code>update-lib-project</code></td>
+
+ <td><code>-p <path></code></td>
+
+ <td>Location path of the project</td>
+
+ <td>Required</td>
+ </tr>
+
+ <tr>
+ <td><code>-l <libraryPath></code></td>
+
+ <td>Location path of an Android Library to add, relative to the main project</td>
+
+ <td></td>
+ </tr>
+
+ <tr>
+ <td><code>-t <name></code></td>
+
+ <td>Target ID of the library project</td>
+
+ <td></td>
+ </tr>
+ </table>
+
+ <h3>Update actions</h3>
+ <dl>
+ <dt><code>update adb</code></dt>
+ <dd>Updates adb to support the USB devices declared in the SDK add-ons.</dd>
+
+ <dt><code>update sdk</code></dt>
+ <dd>Updates the SDK by suggesting new platforms to install if available.</dd>
diff --git a/docs/html/tools/help/bmgr.jd b/docs/html/tools/help/bmgr.jd
new file mode 100644
index 0000000..2248fa6
--- /dev/null
+++ b/docs/html/tools/help/bmgr.jd
@@ -0,0 +1,193 @@
+page.title=bmgr
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<!-- quickview box content here -->
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>bmgr quickview</h2>
+<p><code>bmgr</code> lets you control the backup/restore system on an Android device.
+
+ <h2>In this document</h2>
+ <ol>
+<li><a href="#backup">Forcing a Backup Operation</a></li>
+<li><a href="#restore">Forcing a Restore Operation</a></li>
+<li><a href="#other">Other Commands</a></li>
+ </ol>
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}guide/topics/data/backup.html">Data Backup</a></li>
+ </ol>
+
+</div>
+</div>
+
+<!-- normal page content here -->
+
+<p><code>bmgr</code> is a shell tool you can use to interact with the Backup Manager
+on Android devices supporting API Level 8 or greater. It provides commands to induce backup
+and restore operations so that you don't need to repeatedly wipe data or take similar
+intrusive steps in order to test your application's backup agent. These commands are
+accessed via the <a href="{@docRoot}tools/help/adb.html">adb</a> shell.
+
+<p>For information about adding support for backup in your application, read <a
+href="{@docRoot}guide/topics/data/backup.html">Data Backup</a>, which includes a guide to testing
+your application using {@code bmgr}.</p>
+
+
+<h2 id="backup">Forcing a Backup Operation</h2>
+
+<p>Normally, your application must notify the Backup Manager when its data has changed, via {@link
+android.app.backup.BackupManager#dataChanged()}. The Backup Manager will then invoke your
+backup agent's {@link
+android.app.backup.BackupAgent#onBackup(ParcelFileDescriptor,BackupDataOutput,ParcelFileDescriptor)
+onBackup()} implementation at some time in the future. However, instead of calling {@link
+android.app.backup.BackupManager#dataChanged()}, you can invoke a backup request from the command
+line by running the <code>bmgr backup</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr backup <em><package></em></pre>
+
+<p><code><em><package></em></code> is the formal package name of the application you wish to
+schedule for
+backup. When you execute this backup command, your application's backup agent will be invoked to
+perform a backup operation at some time in the future (via your {@link
+android.app.backup.BackupAgent#onBackup(ParcelFileDescriptor,BackupDataOutput,ParcelFileDescriptor)
+onBackup()} method), though there is no guarantee when it will occur. However, you can force all
+pending backup operations to run immediately by using the <code>bmgr run</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr run</pre>
+
+<p>This causes a backup pass to execute immediately, invoking the backup agents of all applications
+that had previously called {@link android.app.backup.BackupManager#dataChanged()} since the
+last backup operation, plus any applications which had been manually scheduled for
+backup via <code>bmgr backup</code>.
+
+
+
+<h2 id="restore">Forcing a Restore Operation</h2>
+
+<p>Unlike backup operations, which are batched together and run on an occasional basis, restore
+operations execute immediately. The Backup Manager currently provides two kinds of restore
+operations. The first kind restores an entire device with the data that has been backed up. This
+is typically performed only when a device is first provisioned (to replicate settings and other
+saved state from the user's previous device) and is an operation that only the system can
+perform. The second kind of restore operation restores
+a single application to its "active" data set; that is, the application will abandon its current
+data and revert to the last-known-good data that is held in the current backup image. You can
+invoke this second restore operation with the {@link
+android.app.backup.BackupManager#requestRestore(RestoreObserver) requestRestore()} method. The
+Backup Manager will then invoke your backup agent's {@link
+android.app.backup.BackupAgent#onRestore(BackupDataInput,int,ParcelFileDescriptor)
+onRestore()} implementation.
+
+<p>While testing your application, you can immediately invoke the restore operation (bypassing the
+{@link android.app.backup.BackupManager#requestRestore(RestoreObserver) requestRestore()} method)
+for your application by using the <code>bmgr restore</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr restore <em><package></em></pre>
+
+<p><code><em><package></em></code> is the formal Java-style package name of the application
+participating in the backup/restore mechanism, which you would like to restore. The Backup
+Manager will immediately instantiate the application's backup agent and invoke it for restore. This
+will happen even if your application is not currently running.
+
+
+
+
+
+<h2 id="other">Other Commands</h2>
+
+<h3>Wiping data</h3>
+
+<p>The data for a single application can be erased from the active data set on demand. This is
+very useful while you're developing a backup agent, in case bugs lead you to write corrupt data
+or saved state information. You can wipe an application's data with the <code>bmgr wipe</code>
+command:
+
+ <pre class="no-pretty-print">adb shell bmgr wipe <em><package></em></pre>
+
+<p><code><em><package></em></code> is the formal package name of the application whose data
+you wish to
+erase. The next backup operation that the application's agent processes will look as
+though the application had never backed anything up before.
+
+
+<h3>Enabling and disabling backup</h3>
+
+<p>You can see whether the Backup Manager is operational at all with the <code>bmgr
+enabled</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr enabled</pre>
+
+<p>This might be useful if your application's backup agent is never being invoked for backup, to
+verify whether the operating system thinks it should be performing such operations at all.</p>
+
+<p>You can also directly disable or enable the Backup Manager with this command:
+
+ <pre class="no-pretty-print">adb shell bmgr enable <em><boolean></em></pre>
+
+<p><code><em><boolean></em></code> is either <code>true</code> or <code>false</code>.
+This is equivalent to disabling or enabling backup in the device's main Settings UI.</p>
+
+<p class="warning"><strong>Warning!</strong> When backup is disabled, the current backup transport
+will explicitly wipe
+the entire active data set from its backend storage. This is so that when a user says
+they do <em>not</em> want their data backed up, the Backup Manager respects that wish. No further
+data will be saved from the device, and no restore operations will be possible, unless the Backup
+Manager is re-enabled (either through Settings or through the above <code>bmgr</code> command).
+
+
+
+
+<!-- The following is not useful to applications, but may be some useful information some day...
+
+
+<h2 id="transports">Applying a Backup Transport</h2>
+
+<p>A "backup transport" is the code module responsible for moving backup and restore data
+to and from some storage location. A device can have multipe transports installed, though only
+one is active at any given time. Transports are identified by name. You can see what
+transports are available on your device or emulator by running the
+<code>bmgr list transports</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr list transports</pre>
+
+<p>The output of this command is a list of the transports available on the device. The currently
+active transport is flagged with a <code>*</code> character. Transport names may look like
+component names (for example, <code>android/com.android.internal.backup.LocalTransport</code>),
+but they need not be, and the strings are never used as direct class references. The use of
+a component-like naming scheme is simply for purposes of preventing name collisions.
+
+<p>You can change which transport is currently active from the command line as well:
+
+ <pre class="no-pretty-print">adb shell bmgr transport <em><name></em></pre>
+
+<p><code><em><name></em></code> is one of the names as printed by the <code>bmgr list
+transports</code>
+command. From this point forward, backup and restore operations will be directed through the
+newly-selected transport. Backup state tracking is managed separately for each transport, so
+switching back and forth between them will not corrupt the saved state.
+
+
+
+
+<h2 id="restoresets">Viewing Restore Sets</h2>
+
+<p>All of the application data that a device has written to its backup transport is tracked
+as a group that is collectively called a "restore set," because each data set is
+most often manipulated during a restore operation. When a device is provisioned for the first
+time, a new restore set is established. You can get a listing of all the restore sets available to
+the current transport by running the <code>bmgr list sets</code> command:
+
+ <pre class="no-pretty-print">adb shell bmgr list sets</pre>
+
+<p>The output is a listing of available restore sets, one per line. The first item on each line is
+a token (a hexadecimal value that identifies the restore set to the transport). Following
+the token is a string that briefly identifies the restore set.
+Only the token is used within the backup and restore mechanism.
+
+
+-->
diff --git a/docs/html/tools/help/ddms.html b/docs/html/tools/help/ddms.html
new file mode 100644
index 0000000..d885d56
--- /dev/null
+++ b/docs/html/tools/help/ddms.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/debugging/ddms.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/debugging/ddms.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/help/dmtracedump.jd b/docs/html/tools/help/dmtracedump.jd
new file mode 100644
index 0000000..bdc820d
--- /dev/null
+++ b/docs/html/tools/help/dmtracedump.jd
@@ -0,0 +1,66 @@
+page.title=dmtracedump
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+
+ <p><code>dmtracedump</code> is a tool that gives you an alternate way of generating
+ graphical call-stack diagrams from trace log files (instead of using Traceview).</p>
+
+ <p>This document is a reference to the available command line options. For more information on generating trace
+ logs, see <a href="{@docRoot}tools/debugging/debugging-tracing.html">Profiling with
+ Traceview and dmtracedump</a>.</p>
+
+ <p>The usage for <code>dmtracedump</code> is:</p>
+ <pre>
+dmtracedump [-ho] [-s sortable] [-d trace-base-name] [-g outfile] <trace-base-name>
+</pre>
+
+ <p>The tool then loads trace log data from <code><trace-base-name>.data</code> and
+ <trace-base-name>.key. The table below lists the options for dmtracedump.</p>
+
+ <table>
+ <tr>
+ <th>Option</th>
+
+ <th>Description</th>
+ </tr>
+
+ <tr>
+ <td><nobr><code>-d <em><trace-base-name></em></code></nobr></td>
+
+ <td>Diff with this trace name</td>
+ </tr>
+
+ <tr>
+ <td><code>-g <em><outfile></em></code></td>
+
+ <td>Generate output to <outfile></td>
+ </tr>
+
+ <tr>
+ <td><code>-h</code></td>
+
+ <td>Turn on HTML output</td>
+ </tr>
+
+ <tr>
+ <td><code>-o</code></td>
+
+ <td>Dump the trace file instead of profiling</td>
+ </tr>
+
+ <tr>
+ <td><code>-d <em><trace-base-name></em></code></td>
+
+ <td>URL base to the location of the sortable javascript file</td>
+ </tr>
+
+ <tr>
+ <td><code>-t <percent></code></td>
+
+ <td>Minimum threshold for including child nodes in the graph (child's inclusive time as a
+ percentage of parent inclusive time). If this option is not used, the default threshold is
+ 20%.</td>
+ </tr>
+ </table>
\ No newline at end of file
diff --git a/docs/html/tools/help/draw9patch.jd b/docs/html/tools/help/draw9patch.jd
new file mode 100644
index 0000000..7cf0e4b
--- /dev/null
+++ b/docs/html/tools/help/draw9patch.jd
@@ -0,0 +1,59 @@
+page.title=Draw 9-patch
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>The Draw 9-patch tool allows you to easily create a
+ {@link android.graphics.NinePatch} graphic using a WYSIWYG editor.</p>
+<p>For an introduction to Nine-patch graphics and how they work, please read
+the section about Nine-patch in the
+<a href="{@docRoot}guide/topics/graphics/2d-graphics.html#nine-patch">2D Graphics</a>
+document.</p>
+
+<img src="{@docRoot}images/draw9patch-norm.png" style="float:right" alt="" height="300" width="341"
+/>
+
+<p>Here's a quick guide to create a Nine-patch graphic using the Draw 9-patch tool.
+You'll need the PNG image with which you'd like to create a NinePatch.</p>
+
+<ol>
+ <li>From a terminal, launch the <code>draw9patch</code> application from your SDK
+ <code>/tools</code> directory.
+ </li>
+ <li>Drag your PNG image into the Draw 9-patch window
+ (or <strong>File</strong> > <strong>Open 9-patch...</strong> to locate the file).
+ Your workspace will now open.
+ <p>The left pane is your drawing area, in which you can edit the lines for the
+ stretchable patches and content area. The right
+ pane is the preview area, where you can preview your graphic when stretched.</p>
+ </li>
+ <li>Click within the 1-pixel perimeter to draw the lines that define the stretchable
+ patches and (optional) content area. Right-click (or hold Shift and click, on Mac) to erase
+ previously drawn lines.
+ </li>
+ <li>When done, select <strong>File</strong> > <strong>Save 9-patch...</strong>
+ <p>Your image will be saved with the <code>.9.png</code> file name.</p>
+ </li>
+</ol>
+ <p class="note"><strong>Note:</strong> A normal PNG file (<code>*.png</code>) will be
+ loaded with an empty one-pixel border added around the image, in which you can draw
+ the stretchable patches and content area.
+ A previously saved 9-patch file (<code>*.9.png</code>) will be loaded as-is,
+ with no drawing area added, because it already exists.</p>
+
+<img src="{@docRoot}images/draw9patch-bad.png" style="float:right;clear:both" alt="" height="300" width="341"
+/>
+
+<p>Optional controls include:</p>
+<ul>
+ <li><strong>Zoom</strong>: Adjust the zoom level of the graphic in the drawing area.</li>
+ <li><strong>Patch scale</strong>: Adjust the scale of the images in the preview area.</li>
+ <li><strong>Show lock</strong>: Visualize the non-drawable area of the graphic on mouse-over.</li>
+ <li><strong>Show patches</strong>: Preview the stretchable patches in the drawing area (pink is a
+ stretchable patch).</li>
+ <li><strong>Show content</strong>: Highlight the content area in the preview images
+ (purple is the area in which content is allowed).</li>
+ <li><strong>Show bad patches</strong>: Adds a red border around patch areas that may
+ produce artifacts in the graphic when stretched. Visual coherence of your stretched
+ image will be maintained if you eliminate all bad patches.</li>
+<ul>
diff --git a/docs/html/tools/help/emulator.jd b/docs/html/tools/help/emulator.jd
new file mode 100644
index 0000000..fa101e1
--- /dev/null
+++ b/docs/html/tools/help/emulator.jd
@@ -0,0 +1,581 @@
+page.title=Android Emulator
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#KeyMapping">Keyboard Commands</a></li>
+ <li><a href="#startup-options">Command Line Parameters</a></li>
+ </ol>
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/devices/emulator.html">Using the Android Emulator</a></li>
+ <li><a href="{@docRoot}tools/devices/index.html">Managing Virtual Devices</a></li>
+ </ol>
+
+</div>
+</div>
+
+
+<p>The Android SDK includes a mobile device emulator — a virtual mobile device
+that runs on your computer. The emulator lets you develop and test
+Android applications without using a physical device.</p>
+
+<p>This document is a reference to the available command line options and the keyboard mapping to
+device keys.
+For a complete guide to using the Android Emulator, see
+<a href="{@docRoot}tools/devices/emulator.html">Using the Android Emulator</a>.
+
+
+<h2 id="KeyMapping">Keyboard Commands</h2>
+
+<p>Table 1 summarizes the mappings between the emulator keys and the keys of your keyboard.</p>
+
+<p class="table-caption"><strong>Table 1.</strong> Emulator keyboard mapping</p>
+<table border="0" style="clear:left;">
+ <tr>
+ <th>Emulated Device Key </th>
+ <th>Keyboard Key </th>
+ </tr>
+ <tr>
+ <td>Home</td>
+ <td>HOME</td>
+ </tr>
+ <tr>
+ <td>Menu (left softkey)</td>
+ <td>F2 <em>or</em> Page-up button</td>
+ </tr>
+ <tr>
+ <td>Star (right softkey)</td>
+ <td>Shift-F2 <em>or </em>Page Down</td>
+ </tr>
+ <tr>
+ <td>Back</td>
+ <td>ESC</td>
+ </tr>
+ <tr>
+ <td>Call/dial button </td>
+ <td>F3</td>
+ </tr>
+ <tr>
+ <td>Hangup/end call button</td>
+ <td>F4</td>
+ </tr>
+ <tr>
+ <td>Search</td>
+ <td>F5 </td>
+ </tr>
+ <tr>
+ <td>Power button</td>
+ <td>F7 </td>
+ </tr>
+ <tr>
+ <td>Audio volume up button</td>
+ <td>KEYPAD_PLUS, Ctrl-F5</td>
+ </tr>
+
+ <tr>
+ <td>Audio volume down button</td>
+ <td>KEYPAD_MINUS, Ctrl-F6</td>
+ </tr>
+ <tr>
+ <td>Camera button</td>
+ <td>Ctrl-KEYPAD_5, Ctrl-F3</td>
+ </tr>
+ <tr>
+ <td>Switch to previous layout orientation (for example, portrait, landscape)</td>
+ <td>KEYPAD_7, Ctrl-F11</td>
+ </tr>
+ <tr>
+ <td>Switch to next layout orientation (for example, portrait, landscape)</td>
+ <td>KEYPAD_9, Ctrl-F12</td>
+ </tr>
+ <tr>
+ <td>Toggle cell networking on/off</td>
+ <td>F8</td>
+ </tr>
+ <tr>
+ <td>Toggle code profiling</td>
+ <td>F9 (only with <code>-trace</code> startup option)</td>
+ </tr>
+ <tr>
+ <td>Toggle fullscreen mode</td>
+ <td>Alt-Enter</td>
+ </tr>
+ <tr>
+ <td>Toggle trackball mode</td>
+ <td>F6</td>
+ </tr>
+ <tr>
+ <td>Enter trackball mode temporarily (while key is pressed)</td>
+ <td>Delete</td>
+ </tr>
+ <tr>
+ <td>DPad left/up/right/down</td>
+ <td>KEYPAD_4/8/6/2</td>
+ </tr>
+ <tr>
+ <td>DPad center click</td>
+ <td>KEYPAD_5</td>
+ </tr>
+ <tr>
+ <td>Onion alpha increase/decrease</td>
+ <td>KEYPAD_MULTIPLY(*) / KEYPAD_DIVIDE(/)</td>
+ </tr>
+</table>
+
+
+<h2 id="startup-options">Command Line Parameters</h2>
+
+<p>The emulator supports a variety of options that you can specify
+when launching the emulator, to control its appearance or behavior.
+Here's the command-line syntax of the options available to the {@code emulator} program:</p>
+
+<pre>emulator -avd <avd_name> [-<option> [<value>]] ... [-<qemu args>]</pre>
+
+<p class="table-caption"><strong>Table 2.</strong> Emulator command line parameters</p>
+<table>
+<tr>
+ <th width="10%" >Category</th>
+ <th width="20%" >Option</th>
+ <th width="30%" >Description</th>
+ <th width="40%" >Comments</th>
+</tr>
+
+<tr>
+ <td>AVD</td>
+ <td><code>-avd <avd_name></code> or <br>
+ <code>@<avd_name></code></td>
+ <td><strong>Required</strong>. Specifies the AVD to load for this emulator
+ instance.</td>
+ <td>You must create an AVD configuration before launching the emulator. For
+ information, see <a href="{@docRoot}tools/devices/managing-avds.html">Managing
+ AVDs with AVD Manager</a>.</td>
+<tr>
+ <td rowspan="7">Disk Images</td>
+ <td><code>-cache <filepath></code></td>
+ <td>Use <filepath> as the working cache partition image. </td>
+ <td>An absolute or relative path to the current working directory.
+ If no cache file is specified, the emulator's default behavior is to use a temporary file instead.
+ <p>For more information on disk images, use <code>-help-disk-images</code>.</p>
+</td></tr>
+<tr>
+ <td><code>-data <filepath></code></td>
+ <td>Use {@code <filepath>} as the working user-data disk image. </td>
+ <td>Optionally, you can specify a path relative to the current working directory.
+ If <code>-data</code> is not used, the emulator looks for a file named {@code userdata-qemu.img}
+ in the storage area of the AVD being used (see <code>-avd</code>).
+</td></tr>
+<!--
+<tr>
+ <td><code>-datadir <dir></code></td>
+ <td>Search for the user-data disk image specified in <code>-data</code> in <dir></td>
+ <td><code><dir></code> is a path relative to the current working directory.
+
+<p>If you do not specify <code>-datadir</code>, the emulator looks for the user-data image
+in the storage area of the AVD being used (see <code>-avd</code>)</p><p>For more information
+on disk images, use <code>-help-disk-images</code>.</p>
+</td></tr>
+-->
+<!--
+<tr>
+ <td><code>-image <filepath></code></td>
+ <td>Use <filepath> as the system image.</td>
+ <td>Optionally, you can specify a path relative to the current working directory.
+ Default is <system>/system.img.</td>
+</tr>
+-->
+<tr>
+ <td><code>-initdata <filepath></code></td>
+ <td>When resetting the user-data image (through <code>-wipe-data</code>), copy the contents
+ of this file to the new user-data disk image. By default, the emulator copies the <code><system>/userdata.img</code>.</td>
+ <td>Optionally, you can specify a path relative to the current working directory. See also <code>-wipe-data</code>.
+ <p>For more information on disk images, use <code>-help-disk-images</code>.</p></td>
+</tr>
+<tr>
+ <td><code>-nocache</code></td>
+ <td>Start the emulator without a cache partition.</td>
+ <td>See also <code>-cache <file></code>.</td>
+</tr>
+<tr>
+ <td><code>-ramdisk <filepath></code></td>
+ <td>Use <filepath> as the ramdisk image.</td>
+ <td>Default value is <code><system>/ramdisk.img</code>.
+ <p>Optionally, you can specify a path relative to the current working directory.
+ For more information on disk images, use <code>-help-disk-images</code>.</p>
+</td>
+</tr>
+<tr>
+ <td><code>-sdcard <filepath></code></td>
+ <td>Use <file> as the SD card image.</td>
+ <td>Default value is <code><system>/sdcard.img</code>.
+ <p>Optionally, you can specify a path relative to the current working directory. For more information on disk images, use <code>-help-disk-images</code>.</p>
+</td>
+</tr>
+<!--
+<tr>
+ <td><code>-system <dirpath></code></td>
+ <td>Search for system, ramdisk and user data images in <dir>.</td>
+ <td><code><dir></code> is a directory path relative to the current
+ working directory.</td>
+</tr>
+-->
+<tr>
+ <td><code>-wipe-data</code></td>
+ <td>Reset the current user-data disk image (that is, the file specified by <code>-datadir</code> and
+ <code>-data</code>, or the default file). The emulator deletes all data from the user data image file,
+ then copies the contents of the file at <code>-inidata</code> data to the image file before starting.
+ </td>
+ <td>See also <code>-initdata</code>.
+ <p>For more information on disk images, use <code>-help-disk-images</code>.</p>
+</td>
+</tr>
+<tr>
+ <td rowspan="9">Debug</td>
+ <td><code>-debug <tags></code></td>
+ <td>Enable/disable debug messages for the specified debug tags.</td>
+ <td><code><tags></code> is a space/comma/column-separated list of debug component names.
+ Use <code>-help-debug-tags</code> to print a list of debug component names that you can use. </td>
+</tr>
+<tr>
+ <td><code>-debug-<tag></code></td>
+ <td>Enable/disable debug messages for the specified debug tag.</td>
+ <td rowspan="2">Use <code>-help-debug-tags</code> to print a list of debug component names that you can use in <code><tag></code>. </td>
+</tr>
+<tr>
+ <td><code>-debug-no-<tag></code></td>
+ <td>Disable debug messages for the specified debug tag.</td>
+</tr>
+<tr>
+ <td><code>-logcat <logtags></code></td>
+ <td>Enable logcat output with given tags.</td>
+ <td>If the environment variable ANDROID_LOG_TAGS is defined and not
+ empty, its value will be used to enable logcat output by default.</td>
+</tr>
+<tr>
+ <td><code>-shell</code></td>
+ <td>Create a root shell console on the current terminal.</td>
+ <td>You can use this command even if the adb daemon in the emulated system is broken.
+ Pressing Ctrl-c from the shell stops the emulator instead of the shell.</td>
+</tr>
+<tr>
+ <td><code>-shell-serial <device></code></td>
+ <td>Enable the root shell (as in <code>-shell</code> and specify the QEMU character
+ device to use for communication with the shell.</td>
+ <td><device> must be a QEMU device type. See the documentation for '-serial <em>dev</em>' at
+ <a href="http://wiki.qemu.org/download/qemu-doc.html">http://wiki.qemu.org/download/qemu-doc.html</a>
+ for a list of device types.
+
+<p>Here are some examples: </p>
+<ul>
+ <li><code>-shell-serial stdio</code> is identical to <code>-shell</code></li>
+ <li><code>-shell-serial tcp::4444,server,nowait</code> lets you communicate with the shell over TCP port 4444</li>
+ <li><code>-shell-serial fdpair:3:6</code> lets a parent process communicate with the shell using fds 3 (in) and 6 (out)</li>
+ <li><code>-shell-serial fdpair:0:1</code> uses the normal stdin and stdout fds, except that QEMU won't tty-cook the data.</li>
+ </ul>
+</td>
+</tr>
+<tr>
+ <td><code>-show-kernel <name></code></td>
+ <td>Display kernel messages.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-trace <name></code></td>
+ <td>Enable code profiling (press F9 to start), written to a specified file.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-verbose</code></td>
+ <td>Enable verbose output.</td>
+ <td>Equivalent to <code>-debug-init</code>.
+<p>You can define the default verbose output options used by emulator instances in the Android environment variable
+ANDROID_VERBOSE. Define the options you want to use in a comma-delimited list, specifying only the stem of each option:
+<code>-debug-<tags>.</code> </p>
+<p>Here's an example showing ANDROID_VERBOSE defined with the <code>-debug-init</code> and <code>-debug-modem</code> options:
+<p><code>ANDROID_VERBOSE=init,modem</code></p>
+<p>For more information about debug tags, use <code><-help-debug-tags></code>.</p>
+</td>
+</tr>
+<tr>
+ <td rowspan="6">Media</td>
+ <td><code>-audio <backend></code></td>
+ <td>Use the specified audio backend.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-audio-in <backend></code></td>
+ <td>Use the specified audio-input backend.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-audio-out <backend></code></td>
+ <td>Use the specified audio-output backend.</td>
+ <td> </td>
+</tr>
+<!--<tr>
+ <td><code>-mic <device or file></code></td>
+ <td>Use device or WAV file for audio input.</td>
+ <td> </td>
+</tr>
+-->
+<tr>
+ <td><code>-noaudio</code></td>
+ <td>Disable audio support in the current emulator instance.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-radio <device></code></td>
+ <td>Redirect radio modem interface to a host character device.</td>
+ <td> </td></tr>
+<tr>
+ <td><code>-useaudio</code></td>
+ <td>Enable audio support in the current emulator instance.</td>
+ <td>Enabled by default. </td>
+</tr>
+
+<tr>
+ <td rowspan="7">Network</td>
+ <td><code>-dns-server <servers></code></td>
+ <td>Use the specified DNS server(s). </td>
+ <td>The value of <code><servers></code> must be a comma-separated list of up to 4 DNS server names or
+ IP addresses.</td>
+</tr>
+<tr>
+ <td><code>-http-proxy <proxy></code></td>
+ <td>Make all TCP connections through a specified HTTP/HTTPS proxy</td>
+ <td>The value of <code><proxy></code> can be one of the following:<br>
+ <code>http://<server>:<port></code><br>
+ <code>http://<username>:<password>@<server>:<port></code>
+ <p>The <code>http://</code> prefix can be omitted. If the <code>-http-proxy <proxy></code> command is not supplied,
+ the emulator looks up the <code>http_proxy</code> environment variable and automatically uses any value matching
+ the <code><proxy></code> format described above.</p></td>
+</tr>
+<tr>
+ <td><code>-netdelay <delay></code></td>
+ <td>Set network latency emulation to <delay>.</td>
+ <td>Default value is <code>none</code>. See the table in
+ <a href="{@docRoot}tools/devices/emulator.html#netdelay">Network Delay Emulation</a>
+ for supported <code><delay></code> values. </td>
+</tr>
+<tr>
+ <td><code>-netfast</code></td>
+ <td>Shortcut for <code>-netspeed full -netdelay none</code></td>
+ <td> </td></tr>
+<tr>
+ <td><code>-netspeed <speed></code></td>
+ <td>Set network speed emulation to <speed>.</td>
+ <td>Default value is <code>full</code>. See the table in
+ <a href="{@docRoot}tools/devices/emulator.html#netspeed">Network Speed Emulation</a> for
+ supported <code><speed></code> values. </td>
+</tr>
+<tr>
+ <td><code>-port <port></code></td>
+ <td>Set the console port number for this emulator instance to <code><port></code>.</td>
+ <td>The console port number must be an even integer between 5554 and 5584, inclusive. <code><port></code>+1
+ must also be free and will be reserved for ADB.</td>
+</tr>
+<tr>
+ <td><code>-report-console <socket></code></td>
+ <td>Report the assigned console port for this emulator instance to a remote third party
+ before starting the emulation. </td>
+ <td><code><socket></code> must use one of these formats:
+
+<p><code>tcp:<port>[,server][,max=<seconds>]</code></br>
+<code>unix:<port>[,server][,max=<seconds>]</code></p>
+
+<p>Use <code>-help-report-console</code></p> to view more information about this topic. </td>
+</tr>
+<tr>
+ <td rowspan="10">System</td>
+ <td><code>-cpu-delay <delay></code></td>
+ <td>Slow down emulated CPU speed by <delay> </td>
+ <td>Supported values for <delay> are integers between 0 and 1000.
+
+<p>Note that the <delay> does not correlate to clock speed or other absolute metrics
+— it simply represents an abstract, relative delay factor applied non-deterministically
+in the emulator. Effective performance does not always
+scale in direct relationship with <delay> values.</p>
+</td>
+</tr>
+<tr>
+ <td><code>-gps <device></code></td>
+ <td>Redirect NMEA GPS to character device.</td>
+ <td>Use this command to emulate an NMEA-compatible GPS unit connected to
+ an external character device or socket. The format of <code><device></code> must be QEMU-specific
+ serial device specification. See the documentation for 'serial -dev' at
+ <a href="http://wiki.qemu.org/download/qemu-doc.html">http://wiki.qemu.org/download/qemu-doc.html</a>.
+</td>
+</tr>
+<tr>
+ <td><code>-nojni</code></td>
+ <td>Disable JNI checks in the Dalvik runtime.</td><td> </td></tr>
+<tr>
+ <td><code>-qemu</code></td>
+ <td>Pass arguments to the qemu emulator software.</td>
+ <td><p class="caution"><strong>Important:</strong> When using this option, make sure it is the
+ <em>last option</em> specified, since all options after it are interpretted as qemu-specific
+ options.</p></td></tr>
+<tr>
+ <td><code>-qemu -enable-kvm</code></td>
+ <td>Enable KVM acceleration of the emulator virtual machine.</td>
+ <td>This option is only effective when your system is set up to use
+ <a href="{@docRoot}tools/devices/emulator.html#vm-linux">KVM-based VM acceleration</a>.
+ You can optionally specify a memory size ({@code -m <size>}) for the VM, which should match
+ your emulator's memory size:</p>
+ {@code -qemu -m 512 -enable-kvm}<br>
+ {@code -qemu -m 1024 -enable-kvm}
+ </td></tr>
+<tr>
+ <td><code>-qemu -h</code></td>
+ <td>Display qemu help.</td>
+ <td></td></tr>
+<tr>
+ <td><code>-gpu on</code></td>
+ <td>Turn on graphics acceleration for the emulator.</td>
+ <td>This option is only available for emulators using a system image with API Level 15, revision 3
+ and higher. For more information, see
+ <a href="{@docRoot}tools/devices/emulator.html#accel-graphics">Using the Android
+ Emulator</a>.</td></tr>
+<tr>
+ <td><code>-radio <device></code></td>
+ <td>Redirect radio mode to the specified character device.</td>
+ <td>The format of <code><device></code> must be QEMU-specific
+ serial device specification. See the documentation for 'serial -dev' at
+<a href="http://wiki.qemu.org/download/qemu-doc.html">http://wiki.qemu.org/download/qemu-doc.html</a>.
+</td>
+</tr>
+<tr>
+ <td><code>-timezone <timezone></code></td>
+ <td>Set the timezone for the emulated device to <timezone>, instead of the host's timezone.</td>
+ <td><code><timezone></code> must be specified in zoneinfo format. For example:
+<p>"America/Los_Angeles"<br>
+"Europe/Paris"</p>
+</td>
+</tr>
+<tr>
+ <td><code>-version</code></td>
+ <td>Display the emulator's version number.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td rowspan="12">UI</td>
+ <td><code>-dpi-device <dpi></code></td>
+ <td>Scale the resolution of the emulator to match the screen size
+ of a physical device.</td>
+ <td>The default value is 165. See also <code>-scale</code>.</td>
+</tr>
+<tr>
+ <td><code>-no-boot-anim</code></td>
+ <td>Disable the boot animation during emulator startup.</td>
+ <td>Disabling the boot animation can speed the startup time for the emulator.</td>
+</tr>
+<tr>
+ <td><code>-no-window</code></td>
+ <td>Disable the emulator's graphical window display.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-scale <scale></code></td>
+ <td>Scale the emulator window. </td>
+ <td><code><scale></code> is a number between 0.1 and 3 that represents the desired scaling factor. You can
+ also specify scale as a DPI value if you add the suffix "dpi" to the scale value. A value of "auto"
+ tells the emulator to select the best window size.</td>
+</tr>
+<tr>
+ <td><code>-raw-keys</code></td>
+ <td>Disable Unicode keyboard reverse-mapping.</td>
+ <td> </td></tr>
+<tr>
+ <td><code>-noskin</code></td>
+ <td>Don't use any emulator skin.</td>
+ <td> </td></tr>
+<tr>
+ <td><code>-keyset <file></code></td>
+ <td>Use the specified keyset file instead of the default.</td>
+ <td>The keyset file defines the list of key bindings between the emulator and the host keyboard.
+ For more information, use <code>-help-keyset</code> to print information about this topic.
+</td>
+</tr>
+<tr>
+ <td><code>-onion <image></code></td>
+ <td>Use overlay image over screen.</td>
+ <td>No support for JPEG. Only PNG is supported.</td></tr>
+<tr>
+ <td><code>-onion-alpha <percent></code></td>
+ <td>Specify onion skin translucency value (as percent).
+ <td>Default is 50.</td>
+</tr>
+<tr>
+ <td><code>-onion-rotation <position></code></td>
+ <td>Specify onion skin rotation.
+ <td><code><position></code> must be one of the values 0, 1, 2, 3.</td>
+</tr>
+<tr>
+ <td><code>-skin <skinID></code></td>
+ <td>This emulator option is deprecated. </td>
+ <td>Please set skin options using AVDs, rather than by using this emulator
+option. Using this option may yield unexpected and in some cases misleading
+results, since the density with which to render the skin may not be defined.
+AVDs let you associate each skin with a default density and override the default
+as needed. For more information, see <a
+href="{@docRoot}tools/devices/managing-avds.html">Managing Virtual Devices
+with AVD Manager</a>.
+</td>
+</tr>
+<tr>
+ <td><code>-skindir <dir></code></td>
+ <td>This emulator option is deprecated. </td>
+ <td>See comments for <code>-skin</code>, above.</td>
+</tr>
+<tr>
+ <td rowspan="9">Help</td>
+ <td><code>-help</code></td>
+ <td>Print a list of all emulator options.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-all</code></td>
+ <td>Print help for all startup options.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-<option></code></td>
+ <td>Print help for a specific startup option.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-debug-tags</code></td>
+ <td>Print a list of all tags for <code>-debug <tags></code>.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-disk-images</code></td>
+ <td>Print help for using emulator disk images.</td>
+ <td> </td>
+ </tr>
+<tr>
+ <td><code>-help-environment</code></td>
+ <td>Print help for emulator environment variables.</td>
+ <td> </td>s
+</tr><tr>
+ <td><code>-help-keys</code></td>
+ <td>Print the current mapping of keys.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-keyset-file</code></td>
+ <td>Print help for defining a custom key mappings file.</td>
+ <td> </td>
+</tr>
+<tr>
+ <td><code>-help-virtual-device</code></td>
+ <td>Print help for Android Virtual Device usage.</td>
+ <td> </td>
+</tr>
+</table>
diff --git a/docs/html/tools/help/etc1tool.jd b/docs/html/tools/help/etc1tool.jd
new file mode 100644
index 0000000..a7f76f5
--- /dev/null
+++ b/docs/html/tools/help/etc1tool.jd
@@ -0,0 +1,68 @@
+page.title=etc1tool
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+
+ <p><code>etc1tool</code> is a command line utility that lets you encode PNG
+ images to the ETC1 compression standard and decode ETC1 compressed images back to PNG.</p>
+
+ <p>The usage for <code>etc1tool</code> is:</p>
+<pre>etc1tool infile [--help | --encode | --encodeNoHeader | --decode] [--showDifference
+diff-file] [-o outfile]</pre>
+
+ <table>
+ <tr>
+ <th>Option</th>
+
+ <th>Description</th>
+ </tr>
+
+ <tr>
+ <td><code>infile</code></td>
+
+ <td>The input file to compress</td>
+ </tr>
+
+ <tr>
+ <td><code>--help</code></td>
+
+ <td>Print usage information</td>
+ </tr>
+
+ <tr>
+ <td><code>--encode</code></td>
+
+ <td>Create an ETC1 file from a PNG file.
+ This is the default mode for the tool if nothing is specified.</td>
+ </tr>
+
+ <tr>
+ <td><code>--encodeNoHeader</code></td>
+
+ <td>Create a raw ETC1 data file (without a header) from a PNG file.</td>
+ </tr>
+
+ <tr>
+ <td><code>--decode</code></td>
+
+ <td>Create a PNG file from an ETC1 file</td>
+ </tr>
+
+ <tr>
+ <td><code>--showDifference <em>diff-file</em></code></td>
+
+ <td>Write the difference between the original and encoded image to
+ <code><em>diff-file</em></code> (only valid when encoding).</td>
+ </tr>
+
+ <tr>
+ <td><code>-o <em>outfile</em></code></td>
+
+ <td>Specify the name of the output file.
+ If <code><em>outfile</em></code> is not specified, the output file is constructed
+ from the input filename with the appropriate suffix (<code>.pkm</code> or <code>.png</code>).
+ </td>
+ </tr>
+
+ </table>
\ No newline at end of file
diff --git a/docs/html/tools/help/hierarchy-viewer.jd b/docs/html/tools/help/hierarchy-viewer.jd
new file mode 100644
index 0000000..4a346e0
--- /dev/null
+++ b/docs/html/tools/help/hierarchy-viewer.jd
@@ -0,0 +1,18 @@
+page.title=Hierarchy Viewer
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>Hierarchy Viewer allows you to debug and optimize your user
+interface. It provides a visual representation of the layout's View hierarchy
+(the Layout View) and a magnified inspector of the display (the Pixel Perfect View).
+</p>
+
+<p>To start Hierarchy Viewer, enter the following command from the SDK <code>tools/</code> directory:</p>
+ <pre>hierarchyviewer</pre>
+</ol>
+
+<p>For more information on how to use Hierarchy Viewer, see
+<a href="{@docRoot}tools/debugging/debugging-ui.html">Debugging and Profiling UIs</a>
+</p>
+
diff --git a/docs/html/tools/help/hprof-conv.jd b/docs/html/tools/help/hprof-conv.jd
new file mode 100644
index 0000000..f96def2
--- /dev/null
+++ b/docs/html/tools/help/hprof-conv.jd
@@ -0,0 +1,16 @@
+page.title=HPROF Converter
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>
+The <code>hprof-conv</code> tool converts the HPROF file that is
+generated by the Android SDK tools to a standard format so you
+can view the file in a profiling tool of your choice. </p>
+
+<pre> hprof-conv <infile> <outfile></pre>
+
+<p>
+You can use "-" for <code><infile></code> or <code><outfile></code>
+to specify stdin or stdout.
+</p>
diff --git a/docs/html/tools/help/index.jd b/docs/html/tools/help/index.jd
new file mode 100644
index 0000000..aa95de2
--- /dev/null
+++ b/docs/html/tools/help/index.jd
@@ -0,0 +1,84 @@
+page.title=Tools
+@jd:body
+
+
+<p>The Android SDK includes a variety of tools that help you develop mobile
+applications for the Android platform. The tools are classified into two groups: SDK tools
+and platform tools. SDK tools are platform independent and are required no matter which
+Android platform you are developing on. Platform tools are customized to support the features of the
+latest Android platform.</p>
+
+<h2 id="tools-sdk">SDK Tools</h2>
+<p>The SDK tools are installed with the SDK starter package and are periodically updated.
+The SDK tools are required if you are developing Android applications. The most important SDK tools
+include the Android SDK Manager (<code>android sdk</code>), the AVD Manager (<code>android
+avd</code>) the emulator (<code>emulator</code>), and the Dalvik Debug Monitor Server
+(<code>ddms</code>). A short summary of some frequently-used SDK tools is provided below.</p>
+
+<dl>
+ <dt><a href="android.html">android</a></dt>
+ <dd>Lets you manage AVDs, projects, and the installed components of the SDK.</dd>
+ <dt><a href="{@docRoot}tools/debugging/ddms.html">Dalvik Debug Monitor
+Server (ddms)</a></dt>
+ <dd>Lets you debug Android applications.</dd>
+ <dt><a href="dmtracedump.html">dmtracedump</a></dt>
+ <dd>Generates graphical call-stack diagrams from trace log files. The tool uses the
+Graphviz Dot utility to create the graphical output, so you need to install Graphviz before
+running <code>dmtracedump</code>. For more information on using <code>dmtracedump</code>, see <a
+href="{@docRoot}tools/debugging/debugging-tracing.html#dmtracedump">Profiling
+with Traceview and dmtracedump</a></dd>
+ <dt><a href="draw9patch.html">Draw 9-patch</a></dt>
+ <dd>Allows you to easily create a {@link android.graphics.NinePatch} graphic using a
+WYSIWYG editor. It also previews stretched versions of the image, and highlights the area in which
+content is allowed.</dd>
+ <dt><a href="emulator.html">Android Emulator (emulator)</a></dt>
+ <dd>A QEMU-based device-emulation tool that you can use to design, debug, and test
+your applications in an actual Android run-time environment.</dd>
+ <dt><a href="hierarchy-viewer.html">Hierarchy Viewer (hierarchyviewer)</a></dt>
+ <dd>Lets you debug and optimize an Android application's user interface.</dd>
+ <dt><a href="hprof-conv.html">hprof-conv</a></dt>
+ <dd>Converts the HPROF file that is generated by the Android SDK tools to a standard format so
+you can view the file in a profiling tool of your choice.</dd>
+ <dt><a href="layoutopt.html">layoutopt</a></dt>
+ <dd>Lets you quickly analyze your application's layouts in order to optimize them for
+efficiency.</dd>
+ <dt><a href="mksdcard.html">mksdcard</a></dt>
+ <dd>Helps you create a disk image that you can use with the emulator, to simulate the presence
+of an external storage card (such as an SD card).</dd>
+ <dt><a href="monkey.html">Monkey</a></dt>
+ <dd>Runs on your emulator or device and generates pseudo-random streams of user events such
+as clicks, touches, or gestures, as well as a number of system-level events. You can use the Monkey
+to stress-test applications that you are developing, in a random yet repeatable manner.</dd>
+ <dt><a href="monkeyrunner_concepts.html">monkeyrunner</a></dt>
+ <dd>Provides an API for writing programs that control an Android device or emulator from
+outside of Android code.</dd>
+ <dt><a href="proguard.html">ProGuard</a></dt>
+ <dd>Shrinks, optimizes, and obfuscates your code by removing unused code and renaming
+classes, fields, and methods with semantically obscure names.</dd>
+ <dt><a href="sqlite3.html">sqlite3</a></dt>
+ <dd>Lets you access the SQLite data files created and used by Android applications.</dd>
+ <dt><a href="traceview.html">traceview</a></dt>
+ <dd>Provides a graphical viewer for execution logs saved by your application.</dd>
+ <dt><a href="zipalign.html">zipalign</a></dt>
+ <dd>Optimizes <code>.apk</code> files by ensuring that all uncompressed data starts with a
+particular alignment relative to the start of the file. This should always be used to align .apk
+files after they have been signed.</dd>
+ </dl>
+
+<h2 id="tools-platform">Platform Tools</h2>
+
+<p>The platform tools are typically updated every time you install a new SDK platform. Each update
+of the platform tools is backward compatible with older platforms. Usually, you directly use only
+one of the platform tools—the <a href="adb.html">Android Debug Bridge (<code>adb</code>)</a>.
+Android Debug Bridge is a versatile tool that lets you manage the state of an emulator instance or
+Android-powered device. You can also use it to install an Android application (.apk) file on a
+device.</p>
+
+<p>The other platform tools, such as <a href="{@docRoot}tools/aidl.html">aidl</a>,
+<code>aapt</code>, <code>dexdump</code>, and <code>dx</code>, are typically called by the Android
+build tools or Android Development Tools (ADT), so you rarely need to invoke these tools directly.
+As a general rule, you should rely on the build tools or the ADT plugin to call them as needed.</p>
+
+<p class="note"><strong>Note:</strong> The Android SDK provides additional shell tools that can
+be accessed through <code>adb</code>, such as <a href="bmgr.html">bmgr</a> and
+<a href="logcat.html">logcat</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/help/layoutopt.jd b/docs/html/tools/help/layoutopt.jd
new file mode 100644
index 0000000..1308b1e
--- /dev/null
+++ b/docs/html/tools/help/layoutopt.jd
@@ -0,0 +1,24 @@
+page.title=layoutopt
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p><code>layoutopt</code> is a command-line tool that helps you optimize the
+layouts and layout hierarchies of your applications.<p>
+
+<p>This document is a reference to the available command line options. For more information and sample
+output of the tool, see <a
+href="{@docRoot}tools/debugging/debugging-ui.html#layoutopt">Optimizing layouts with
+layoutopt</a>.</p>
+
+<h3>Usage</h3>
+
+<p>To run <code>layoutopt</code> against a given list of layout resources:</p>
+
+<pre>layoutopt <file_or_directory> ...</pre>
+
+<p>For example:</p>
+
+<pre>$ layoutopt res/layout-land</pre>
+<pre>$ layoutopt res/layout/main.xml res/layout-land/main.xml</pre>
+
diff --git a/docs/html/tools/help/logcat.jd b/docs/html/tools/help/logcat.jd
new file mode 100644
index 0000000..d504b22
--- /dev/null
+++ b/docs/html/tools/help/logcat.jd
@@ -0,0 +1,106 @@
+page.title=logcat
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+ <p>The Android logging system provides a mechanism for collecting and viewing system debug
+ output. Logs from various applications and portions of the system are collected in a series of
+ circular buffers, which then can be viewed and filtered by the <code>logcat</code> command. You can use
+ <code>logcat</code> from an ADB shell to view the log messages.</p>
+
+ <p>This document is a reference to the available command line options. For more information on <code>logcat</code>, see
+ <a href="{@docRoot}tools/debugging/debugging-log.html">Reading and Writing Logs</a>.
+For more
+ information on accessing <code>logcat</code> from DDMS, instead of the command line, see the documentation for the
+ <a href="{@docRoot}tools/debugging/ddms.html">Dalvik Debug Monitor Server</a>.
+ </p>
+
+ <h3>Syntax</h3>
+ <pre>
+[adb] logcat [<option>] ... [<filter-spec>] ...
+</pre>
+
+ <p>You can run <code>logcat</code> as an adb command or directly in a shell prompt
+ of your emulator or connected device. To view log output using adb, navigate to your SDK
+ <code>platform-tools/</code> directory and execute:</p>
+ <pre>
+$ adb logcat
+</pre>
+
+ <p>You can create a shell connection to a device and execute:</p>
+ <pre>
+$ adb shell
+# logcat
+</pre>
+
+ <h3>Options</h3>
+ <p>The following table describes the command line options of <code>logcat</code>.</p>
+
+ <table>
+ <tr>
+ <th>Option</th>
+
+ <th>Description</th>
+ </tr>
+
+ <tr>
+ <td><code>-b <buffer></code></td>
+
+ <td>Loads an alternate log buffer for viewing, such as <code>event</code> or
+ <code>radio</code>. The <code>main</code> buffer is used by default. See <a href=
+ "#alternativebuffers">Viewing Alternative Log Buffers</a>.</td>
+ </tr>
+
+ <tr>
+ <td><code>-c</code></td>
+
+ <td>Clears (flushes) the entire log and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-d</code></td>
+
+ <td>Dumps the log to the screen and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-f <filename></code></td>
+
+ <td>Writes log message output to <code><filename></code>. The default is
+ <code>stdout</code>.</td>
+ </tr>
+
+ <tr>
+ <td><code>-g</code></td>
+
+ <td>Prints the size of the specified log buffer and exits.</td>
+ </tr>
+
+ <tr>
+ <td><code>-n <count></code></td>
+
+ <td>Sets the maximum number of rotated logs to <code><count></code>. The default value
+ is 4. Requires the <code>-r</code> option.</td>
+ </tr>
+
+ <tr>
+ <td><code>-r <kbytes></code></td>
+
+ <td>Rotates the log file every <code><kbytes></code> of output. The default value is
+ 16. Requires the <code>-f</code> option.</td>
+ </tr>
+
+ <tr>
+ <td><code>-s</code></td>
+
+ <td>Sets the default filter spec to silent.</td>
+ </tr>
+
+ <tr>
+ <td><code>-v <format></code></td>
+
+ <td>Sets the output format for log messages. The default is <code>brief</code> format. For a
+ list of supported formats, see <a href="#outputformat">Controlling Log Output
+ Format</a>.</td>
+ </tr>
+ </table>
diff --git a/docs/html/tools/help/mksdcard.jd b/docs/html/tools/help/mksdcard.jd
new file mode 100644
index 0000000..38c4356
--- /dev/null
+++ b/docs/html/tools/help/mksdcard.jd
@@ -0,0 +1,55 @@
+page.title=mksdcard
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+ <p>The <code>mksdcard</code> tool lets you quickly create a FAT32 disk image that you can load in the
+ emulator, to simulate the presence of an SD card in the device. Because you can specify an SD
+ card while creating an AVD in the AVD Manager, you usually use that feature to create an SD card.
+ This tool creates an SD card that is not bundled with an AVD, so it is useful for situations
+ where you need to share a virtual SD card between multiple emulators.</p>
+
+ <h3>Usage</h3>
+ <pre>
+mksdcard -l <label> <size> <file>
+</pre>
+
+ <h3>Options</h3>
+ <p>The following table describes the command-line options of <code>mksdcard</code></p>
+ <table>
+ <tr>
+ <th>Option</th>
+
+ <th>Description</th>
+ </tr>
+
+ <tr>
+ <td><code>-l</code></td>
+
+ <td>A volume label for the disk image to create.</td>
+ </tr>
+
+ <tr>
+ <td><code>size</code></td>
+
+ <td>An integer that specifies the size (in bytes) of disk image to create. You can also
+ specify size in kilobytes or megabytes, by appending a "K" or "M" to <size>. For
+ example, <code>1048576K</code>, <code>1024M</code>.</td>
+ </tr>
+
+ <tr>
+ <td><code>file</code></td>
+
+ <td>The path/filename of the disk image to create.</td>
+ </tr>
+ </table>
+
+ <p>Once you have created the disk image file, you can load it in the emulator at startup using
+ the emulator's <code>-sdcard</code> option. For more information, see <a href=
+ "{@docRoot}tools/help/emulator.html">Android Emulator</a>.</p>
+
+ <p>The usage for the <code>-sdcard</code> option is as follows:</p>
+ <pre>emulator -sdcard <file></pre>
+
+<h3>Example</h3>
+<pre>mksdcard -l mySdCard 1024M mySdCardFile.img</pre>
\ No newline at end of file
diff --git a/docs/html/tools/help/monkey.jd b/docs/html/tools/help/monkey.jd
new file mode 100644
index 0000000..b6300a7
--- /dev/null
+++ b/docs/html/tools/help/monkey.jd
@@ -0,0 +1,242 @@
+page.title=UI/Application Exerciser Monkey
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>The Monkey is a program that runs on your
+<a href="{@docRoot}tools/help/emulator.html">emulator</a> or device and generates pseudo-random
+streams of user events such as clicks, touches, or gestures, as well as a number of system-level
+events. You can use the Monkey to stress-test applications that you are developing, in a random
+yet repeatable manner.</p>
+
+<a name="overview"></a>
+<h2>Overview</h2>
+
+<p>The Monkey is a command-line tool that that you can run on any emulator
+instance or on a device. It sends a pseudo-random stream of
+user events into the system, which acts as a stress test on the application software you are
+developing.</p>
+
+<p>The Monkey includes a number of options, but they break down into four primary
+categories:</p>
+
+<ul>
+ <li>Basic configuration options, such as setting the number of events to attempt.</li>
+ <li>Operational constraints, such as restricting the test to a single package.</li>
+ <li>Event types and frequencies.</li>
+ <li>Debugging options.</li>
+</ul>
+
+<p>When the Monkey runs, it generates events and sends them to the system. It also <i>watches</i>
+the system under test and looks for three conditions, which it treats specially:</p>
+
+<ul>
+ <li>If you have constrained the Monkey to run in one or more specific packages, it
+ watches for attempts to navigate to any other packages, and blocks them.</li>
+ <li>If your application crashes or receives any sort of unhandled exception, the Monkey
+ will stop and report the error.</li>
+ <li>If your application generates an <i>application not responding</i> error, the Monkey
+ will stop and report the error.</li>
+</ul>
+
+<p>Depending on the verbosity level you have selected, you will also see reports on the progress
+of the Monkey and the events being generated.</p>
+
+<a name="basics"></a>
+<h2>Basic Use of the Monkey</h2>
+
+<p>You can launch the Monkey using a command line on your development machine or from a script.
+Because the Monkey runs in the emulator/device environment, you must launch it from a shell in
+that environment. You can do this by prefacing <code>adb shell</code> to each command,
+or by entering the shell and entering Monkey commands directly.</p>
+<p>The basic syntax is: </p>
+
+<pre>$ adb shell monkey [options] <event-count></pre>
+
+<p>With no options specified, the Monkey will launch in a quiet (non-verbose) mode, and will send
+events to any (and all) packages installed on your target. Here is a more typical command line,
+which will launch your application and send 500 pseudo-random events to it:</p>
+
+<pre>$ adb shell monkey -p your.package.name -v 500</pre>
+
+<a name="reference"></a>
+<h2>Command Options Reference</h2>
+
+<p>The table below lists all options you can include on the Monkey command line.</p>
+
+<table>
+<tr>
+ <th>Category</th>
+ <th>Option</th>
+ <th>Description</th>
+</tr>
+
+<tr>
+<td rowspan="2">General</td>
+<td><code>--help</code></td>
+<td>Prints a simple usage guide.</td>
+</tr>
+
+<tr>
+<td><code>-v</code></td>
+<td>Each -v on the command line will increment the verbosity level.
+Level 0 (the default) provides little information beyond startup notification, test completion, and
+final results.
+Level 1 provides more details about the test as it runs, such as individual events being sent to
+your activities.
+Level 2 provides more detailed setup information such as activities selected or not selected for
+testing.</td>
+</tr>
+
+<tr>
+<td rowspan="10">Events</td>
+<td><code>-s <seed></code></td>
+<td>Seed value for pseudo-random number generator. If you re-run the Monkey with the same seed
+value, it will generate the same sequence of events.</td>
+</tr>
+
+<tr>
+<td><code>--throttle <milliseconds></code></td>
+<td>Inserts a fixed delay between events. You can use this option to slow down the Monkey.
+If not specified, there is no delay and the events are generated as rapidly as possible.</td>
+</tr>
+
+<tr>
+<td><code>--pct-touch <percent></code></td>
+<td>Adjust percentage of touch events.
+(Touch events are a down-up event in a single place on the screen.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-motion <percent></code></td>
+<td>Adjust percentage of motion events.
+(Motion events consist of a down event somewhere on the screen, a series of pseudo-random
+movements, and an up event.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-trackball <percent></code></td>
+<td>Adjust percentage of trackball events.
+(Trackball events consist of one or more random movements, sometimes followed by a click.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-nav <percent></code></td>
+<td>Adjust percentage of "basic" navigation events.
+(Navigation events consist of up/down/left/right, as input from a directional input device.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-majornav <percent></code></td>
+<td>Adjust percentage of "major" navigation events.
+(These are navigation events that will typically cause actions within your UI, such as
+the center button in a 5-way pad, the back key, or the menu key.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-syskeys <percent></code></td>
+<td>Adjust percentage of "system" key events.
+(These are keys that are generally reserved for use by the system, such as Home, Back, Start Call,
+End Call, or Volume controls.)</td>
+</tr>
+
+<tr>
+<td><code>--pct-appswitch <percent></code></td>
+<td>Adjust percentage of activity launches. At random intervals, the Monkey will issue a startActivity() call, as a way of maximizing
+coverage of all activities within your package.</td>
+</tr>
+
+<tr>
+<td><code>--pct-anyevent <percent></code></td>
+<td>Adjust percentage of other types of events. This is a catch-all for all other types of events such as keypresses, other less-used
+buttons on the device, and so forth.</td>
+</tr>
+
+<tr>
+<td rowspan="2">Constraints</td>
+<td><code>-p <allowed-package-name></code></td>
+<td>If you specify one or more packages this way, the Monkey will <i>only</i> allow the system
+to visit activities within those packages. If your application requires access to activities in
+other packages (e.g. to select a contact) you'll need to specify those packages as well.
+If you don't specify any packages, the Monkey will allow the system to launch activities
+in all packages. To specify multiple packages, use the -p option multiple times — one -p
+option per package.</td>
+</tr>
+
+<tr>
+<td><code>-c <main-category></code></td>
+<td>If you specify one or more categories this way, the Monkey will <i>only</i> allow the
+system to visit activities that are listed with one of the specified categories.
+If you don't specify any categories, the Monkey will select activities listed with the category
+Intent.CATEGORY_LAUNCHER or Intent.CATEGORY_MONKEY. To specify multiple categories, use the -c
+option multiple times — one -c option per category.</td>
+</tr>
+
+<tr>
+<td rowspan="8">Debugging</td>
+<td><code>--dbg-no-events</code></td>
+<td>When specified, the Monkey will perform the initial launch into a test activity, but
+will not generate any further events.
+For best results, combine with -v, one or more package constraints, and a non-zero throttle to keep the Monkey
+running for 30 seconds or more. This provides an environment in which you can monitor package
+transitions invoked by your application.</td>
+</tr>
+
+<tr>
+<td><code>--hprof</code></td>
+<td>If set, this option will generate profiling reports immediately before and after
+the Monkey event sequence.
+This will generate large (~5Mb) files in data/misc, so use with care. See
+<a href="{@docRoot}tools/debugging/debugging-tracing.html" title="traceview">Traceview</a> for more information
+on trace files.</td>
+</tr>
+
+<tr>
+<td><code>--ignore-crashes</code></td>
+<td>Normally, the Monkey will stop when the application crashes or experiences any type of
+unhandled exception. If you specify this option, the Monkey will continue to send events to
+the system, until the count is completed.</td>
+</tr>
+
+<tr>
+<td><code>--ignore-timeouts</code></td>
+<td>Normally, the Monkey will stop when the application experiences any type of timeout error such
+as a "Application Not Responding" dialog. If you specify this option, the Monkey will continue to
+send events to the system, until the count is completed.</td>
+</tr>
+
+<tr>
+<td><code>--ignore-security-exceptions</code></td>
+<td>Normally, the Monkey will stop when the application experiences any type of permissions error,
+for example if it attempts to launch an activity that requires certain permissions. If you specify
+this option, the Monkey will continue to send events to the system, until the count is
+completed.</td>
+</tr>
+
+<tr>
+<td><code>--kill-process-after-error</code></td>
+<td>Normally, when the Monkey stops due to an error, the application that failed will be left
+running. When this option is set, it will signal the system to stop the process in which the error
+occurred.
+Note, under a normal (successful) completion, the launched process(es) are not stopped, and
+the device is simply left in the last state after the final event.</td>
+</tr>
+
+<tr>
+<td><code>--monitor-native-crashes</code></td>
+<td>Watches for and reports crashes occurring in the Android system native code. If --kill-process-after-error is set, the system will stop.</td>
+</tr>
+
+<tr>
+<td><code>--wait-dbg</code></td>
+<td>Stops the Monkey from executing until a debugger is attached to it.</td>
+</tr>
+
+</table>
+
+<!-- TODO: add a section called "debugging" that covers ways to use it,
+need to clear data, use of the seed, etc. -->
+
+<!-- TODO: add a section that lays down a contract for Monkey output so it can be
+scripted safely. -->
+
diff --git a/docs/html/tools/help/monkeyrunner_concepts.jd b/docs/html/tools/help/monkeyrunner_concepts.jd
new file mode 100644
index 0000000..c37e64d
--- /dev/null
+++ b/docs/html/tools/help/monkeyrunner_concepts.jd
@@ -0,0 +1,319 @@
+page.title=monkeyrunner
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#SampleProgram">A Simple monkeyrunner Program</a>
+ </li>
+ <li>
+ <a href="#APIClasses">The monkeyrunner API</a>
+ </li>
+ <li>
+ <a href="#RunningMonkeyRunner">Running monkeyrunner</a>
+ </li>
+ <li>
+ <a href="#Help">monkeyrunner Built-in Help</a>
+ </li>
+ <li>
+ <a href="#Plugins">Extending monkeyrunner with Plugins</a>
+ </li>
+ </ol>
+ <h2>See Also</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ The monkeyrunner tool provides an API for writing programs that control an Android device
+ or emulator from outside of Android code. With monkeyrunner, you can write a Python program
+ that installs an Android application or test package, runs it, sends keystrokes to it,
+ takes screenshots of its user interface, and stores screenshots on the workstation. The
+ monkeyrunner tool is primarily designed to test applications and devices at the
+ functional/framework level and for running unit test suites, but you are free to use it for
+ other purposes.
+</p>
+<p>
+ The monkeyrunner tool is not related to the
+ <a href="{@docRoot}tools/help/monkey.html">UI/Application Exerciser Monkey</a>,
+ also known as the <code>monkey</code> tool. The <code>monkey</code> tool runs in an
+ <code><a href="{@docRoot}tools/help/adb.html">adb</a></code> shell directly on the
+ device or emulator and generates pseudo-random streams of user and system events. In comparison,
+ the monkeyrunner tool controls devices and emulators from a workstation by sending specific
+ commands and events from an API.
+</p>
+<p>
+ The monkeyrunner tool provides these unique features for Android testing:
+</p>
+<ul>
+ <li>
+ Multiple device control: The monkeyrunner API can apply one or more
+ test suites across multiple devices or emulators. You can physically attach all the devices
+ or start up all the emulators (or both) at once, connect to each one in turn
+ programmatically, and then run one or more tests. You can also start up an emulator
+ configuration programmatically, run one or more tests, and then shut down the emulator.
+ </li>
+ <li>
+ Functional testing: monkeyrunner can run an automated start-to-finish test of an Android
+ application. You provide input values with keystrokes or touch events, and view the results
+ as screenshots.
+ </li>
+ <li>
+ Regression testing - monkeyrunner can test application stability by running an application
+ and comparing its output screenshots to a set of screenshots that are known to be correct.
+ </li>
+ <li>
+ Extensible automation - Since monkeyrunner is an API toolkit, you can develop an entire
+ system of Python-based modules and programs for controlling Android devices. Besides using
+ the monkeyrunner API itself, you can use the standard Python
+ <code><a href="http://docs.python.org/library/os.html">os</a></code> and
+ <code><a href="http://docs.python.org/library/subprocess.html">subprocess</a></code>
+ modules to call Android tools such as
+ <a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a>.
+ <p>
+ You can also add your own classes to the monkeyrunner API. This is described
+ in more detail in the section
+ <a href="#Plugins">Extending monkeyrunner with plugins</a>.
+ </p>
+ </li>
+</ul>
+<p>
+ The monkeyrunner tool uses <a href="http://www.jython.org/">Jython</a>, a
+ implementation of Python that uses the Java programming language. Jython allows the
+ monkeyrunner API to interact easily with the Android framework. With Jython you can
+ use Python syntax to access the constants, classes, and methods of the API.
+</p>
+
+<h2 id="SampleProgram">A Simple monkeyrunner Program</h2>
+<p>
+ Here is a simple monkeyrunner program that connects to a device, creating a
+ <code><a href="{@docRoot}tools/help/MonkeyDevice.html">MonkeyDevice</a></code>
+ object. Using the <code>MonkeyDevice</code> object, the program installs an Android application
+ package, runs one of its activities, and sends key events to the activity.
+ The program then takes a screenshot of the result, creating a
+ <code><a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a></code> object.
+ From this object, the program writes out a <code>.png</code> file containing the screenshot.
+</p>
+<pre>
+# Imports the monkeyrunner modules used by this program
+from com.android.monkeyrunner import MonkeyRunner, MonkeyDevice
+
+# Connects to the current device, returning a MonkeyDevice object
+device = MonkeyRunner.waitForConnection()
+
+# Installs the Android package. Notice that this method returns a boolean, so you can test
+# to see if the installation worked.
+device.installPackage('myproject/bin/MyApplication.apk')
+
+# sets a variable with the package's internal name
+package = 'com.example.android.myapplication'
+
+# sets a variable with the name of an Activity in the package
+activity = 'com.example.android.myapplication.MainActivity'
+
+# sets the name of the component to start
+runComponent = package + '/' + activity
+
+# Runs the component
+device.startActivity(component=runComponent)
+
+# Presses the Menu button
+device.press('KEYCODE_MENU', MonkeyDevice.DOWN_AND_UP)
+
+# Takes a screenshot
+result = device.takeSnapshot()
+
+# Writes the screenshot to a file
+result.writeToFile('myproject/shot1.png','png')
+</pre>
+
+<h2 id="APIClasses">The monkeyrunner API</h2>
+<p>
+ The monkeyrunner API is contained in three modules in the package
+ <code>com.android.monkeyrunner</code>:
+</p>
+<ul>
+ <li>
+ <code><a href="{@docRoot}tools/help/MonkeyRunner.html">MonkeyRunner</a></code>:
+ A class of utility methods for monkeyrunner programs. This class provides a method for
+ connecting monkeyrunner to a device or emulator. It also provides methods for
+ creating UIs for a monkeyrunner program and for displaying the built-in help.
+ </li>
+ <li>
+ <code><a href="{@docRoot}tools/help/MonkeyDevice.html">MonkeyDevice</a></code>:
+ Represents a device or emulator. This class provides methods for installing and
+ uninstalling packages, starting an Activity, and sending keyboard or touch events to an
+ application. You also use this class to run test packages.
+ </li>
+ <li>
+ <code><a href="{@docRoot}tools/help/MonkeyImage.html">MonkeyImage</a></code>:
+ Represents a screen capture image. This class provides methods for capturing screens,
+ converting bitmap images to various formats, comparing two MonkeyImage objects, and
+ writing an image to a file.
+ </li>
+</ul>
+<p>
+ In a Python program, you access each class as a Python module. The monkeyrunner tool
+ does not import these modules automatically. To import a module, use the
+ Python <code>from</code> statement:
+</p>
+<pre>
+from com.android.monkeyrunner import <module>
+</pre>
+<p>
+ where <code><module></code> is the class name you want to import. You can import more
+ than one module in the same <code>from</code> statement by separating the module names with
+ commas.
+</p>
+<h2 id="RunningMonkeyRunner">Running monkeyrunner</h2>
+<p>
+ You can either run monkeyrunner programs from a file, or enter monkeyrunner statements in
+ an interactive session. You do both by invoking the <code>monkeyrunner</code> command
+ which is found in the <code>tools/</code> subdirectory of your SDK directory.
+ If you provide a filename as an argument, the <code>monkeyrunner</code> command
+ runs the file's contents as a Python program; otherwise, it starts an interactive session.
+</p>
+<p>
+ The syntax of the <code>monkeyrunner</code> command is
+</p>
+<pre>
+monkeyrunner -plugin <plugin_jar> <program_filename> <program_options>
+</pre>
+<p>
+Table 1 explains the flags and arguments.
+</p>
+<p class="table-caption" id="table1">
+ <strong>Table 1.</strong> <code>monkeyrunner</code> flags and arguments.</p>
+
+<table>
+ <tr>
+ <th>Argument</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td>
+ <nobr>
+ <code>-plugin <plugin_jar></code>
+ </nobr>
+ </td>
+ <td>
+ (Optional) Specifies a <code>.jar</code> file containing a plugin for monkeyrunner.
+ To learn more about monkeyrunner plugins, see
+ <a href="#Plugins">Extending monkeyrunner with plugins</a>. To specify more than one
+ file, include the argument multiple times.
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <nobr>
+ <code><program_filename></code>
+ </nobr>
+ </td>
+ <td>
+ If you provide this argument, the <code>monkeyrunner</code> command runs the contents
+ of the file as a Python program. If the argument is not provided, the command starts an
+ interactive session.
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <code><program_options></code>
+ </td>
+ <td>
+ (Optional) Flags and arguments for the program in <program_file>.
+ </td>
+ </tr>
+</table>
+<h2 id="Help">monkeyrunner Built-in Help</h2>
+<p>
+ You can generate an API reference for monkeyrunner by running:
+</p>
+<pre>
+monkeyrunner help.py <format> <outfile>
+</pre>
+<p>
+The arguments are:
+</p>
+ <ul>
+ <li>
+ <code><format></code> is either <code>text</code> for plain text output
+ or <code>html</code> for HTML output.
+ </li>
+ <li>
+ <code><outfile></code> is a path-qualified name for the output file.
+ </li>
+ </ul>
+<h2 id="Plugins">Extending monkeyrunner with Plugins</h2>
+<p>
+ You can extend the monkeyrunner API with classes you write in the Java programming language
+ and build into one or more <code>.jar</code> files. You can use this feature to extend the
+ monkeyrunner API with your own classes or to extend the existing classes. You can also use this
+ feature to initialize the monkeyrunner environment.
+</p>
+<p>
+ To provide a plugin to monkeyrunner, invoke the <code>monkeyrunner</code> command with the
+ <code>-plugin <plugin_jar></code> argument described in
+ <a href="#table1">table 1</a>.
+</p>
+<p>
+ In your plugin code, you can import and extend the the main monkeyrunner classes
+ <code>MonkeyDevice</code>, <code>MonkeyImage</code>, and <code>MonkeyRunner</code> in
+ <code>com.android.monkeyrunner</code> (see <a href="#APIClasses">The monkeyrunner API</a>).
+</p>
+<p>
+ Note that plugins do not give you access to the Android SDK. You can't import packages
+ such as <code>com.android.app</code>. This is because monkeyrunner interacts with the
+ device or emulator below the level of the framework APIs.
+</p>
+<h3>The plugin startup class</h3>
+<p>
+ The <code>.jar</code> file for a plugin can specify a class that is instantiated before
+ script processing starts. To specify this class, add the key
+ <code>MonkeyRunnerStartupRunner</code> to the <code>.jar</code> file's
+ manifest. The value should be the name of the class to run at startup. The following
+ snippet shows how you would do this within an <code>ant</code> build script:
+</p>
+<pre>
+<jar jarfile="myplugin" basedir="${build.dir}">
+<manifest>
+<attribute name="MonkeyRunnerStartupRunner" value="com.myapp.myplugin"/>
+</manifest>
+</jar>
+
+
+</pre>
+<p>
+ To get access to monkeyrunner's runtime environment, the startup class can implement
+ <code>com.google.common.base.Predicate<PythonInterpreter></code>. For example, this
+ class sets up some variables in the default namespace:
+</p>
+<pre>
+package com.android.example;
+
+import com.google.common.base.Predicate;
+import org.python.util.PythonInterpreter;
+
+public class Main implements Predicate<PythonInterpreter> {
+ @Override
+ public boolean apply(PythonInterpreter anInterpreter) {
+
+ /*
+ * Examples of creating and initializing variables in the monkeyrunner environment's
+ * namespace. During execution, the monkeyrunner program can refer to the variables "newtest"
+ * and "use_emulator"
+ *
+ */
+ anInterpreter.set("newtest", "enabled");
+ anInterpreter.set("use_emulator", 1);
+
+ return true;
+ }
+}
+</pre>
diff --git a/docs/html/tools/help/proguard.jd b/docs/html/tools/help/proguard.jd
new file mode 100644
index 0000000..1da94ba
--- /dev/null
+++ b/docs/html/tools/help/proguard.jd
@@ -0,0 +1,189 @@
+page.title=ProGuard
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#enabling">Enabling ProGuard</a></li>
+
+ <li><a href="#configuring">Configuring ProGuard</a></li>
+
+ <li>
+ <a href="#decoding">Decoding Obfuscated Stack Traces</a>
+
+ <ol>
+ <li><a href="#considerations">Debugging considerations for published
+ applications</a></li>
+ </ol>
+ </li>
+ </ol>
+
+ <h2>See also</h2>
+
+ <ol>
+ <li><a href="http://proguard.sourceforge.net/manual/introduction.html">ProGuard
+ Manual »</a></li>
+
+ <li><a href="http://proguard.sourceforge.net/manual/retrace/introduction.html">ProGuard
+ ReTrace Manual »</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The ProGuard tool shrinks, optimizes, and obfuscates your code by removing unused code and
+ renaming classes, fields, and methods with semantically obscure names. The result is a smaller
+ sized <code>.apk</code> file that is more difficult to reverse engineer. Because ProGuard makes your
+ application harder to reverse engineer, it is important that you use it
+ when your application utilizes features that are sensitive to security like when you are
+ <a href="{@docRoot}guide/google/play/licensing/index.html">Licensing Your Applications</a>.</p>
+
+ <p>ProGuard is integrated into the Android build system, so you do not have to invoke it
+ manually. ProGuard runs only when you build your application in release mode, so you do not
+ have to deal with obfuscated code when you build your application in debug mode.
+ Having ProGuard run is completely optional, but highly recommended.</p>
+
+ <p>This document describes how to enable and configure ProGuard as well as use the
+ <code>retrace</code> tool to decode obfuscated stack traces.</p>
+
+ <h2 id="enabling">Enabling ProGuard</h2>
+
+ <p>When you create an Android project, a <code>proguard.cfg</code> file is automatically
+ generated in the root directory of the project. This file defines how ProGuard optimizes and
+ obfuscates your code, so it is very important that you understand how to customize it for your
+ needs. The default configuration file only covers general cases, so you most likely have to edit
+ it for your own needs. See the following section about <a href="#configuring">Configuring ProGuard</a> for information on
+ customizing the ProGuard configuration file.</p>
+
+ <p>To enable ProGuard so that it runs as part of an Ant or Eclipse build, set the
+ <code>proguard.config</code> property in the <code><project_root>/project.properties</code>
+ file. The path can be an absolute path or a path relative to the project's root.</p>
+<p>If you left the <code>proguard.cfg</code> file in its default location (the project's root directory),
+you can specify its location like this:</p>
+<pre class="no-pretty-print">
+proguard.config=proguard.cfg
+</pre>
+<p>
+You can also move the the file to anywhere you want, and specify the absolute path to it:
+</p>
+<pre class="no-pretty-print">
+proguard.config=/path/to/proguard.cfg
+</pre>
+
+
+ <p>When you build your application in release mode, either by running <code>ant release</code> or
+ by using the <em>Export Wizard</em> in Eclipse, the build system automatically checks to see if
+ the <code>proguard.config</code> property is set. If it is, ProGuard automatically processes
+ the application's bytecode before packaging everything into an <code>.apk</code> file. Building in debug mode
+ does not invoke ProGuard, because it makes debugging more cumbersome.</p>
+
+ <p>ProGuard outputs the following files after it runs:</p>
+
+ <dl>
+ <dt><code>dump.txt</code></dt>
+ <dd>Describes the internal structure of all the class files in the <code>.apk</code> file</dd>
+
+ <dt><code>mapping.txt</code></dt>
+ <dd>Lists the mapping between the original and obfuscated class, method, and field names.
+ This file is important when you receive a bug report from a release build, because it
+ translates the obfuscated stack trace back to the original class, method, and member names.
+ See <a href="#decoding">Decoding Obfuscated Stack Traces</a> for more information.</dd>
+
+ <dt><code>seeds.txt</code></dt>
+ <dd>Lists the classes and members that are not obfuscated</dd>
+
+ <dt><code>usage.txt</code></dt>
+ <dd>Lists the code that was stripped from the <code>.apk</code></dd>
+ </ul>
+
+ <p>These files are located in the following directories:</p>
+
+ <ul>
+ <li><code><project_root>/bin/proguard</code> if you are using Ant.</li>
+
+ <li><code><project_root>/proguard</code> if you are using Eclipse.</li>
+ </ul>
+
+
+ <p class="caution"><strong>Caution:</strong> Every time you run a build in release mode, these files are
+ overwritten with the latest files generated by ProGuard. Save a copy of them each time you release your
+ application in order to de-obfuscate bug reports from your release builds.
+ For more information on why saving these files is important, see
+ <a href="#considerations">Debugging considerations for published applications</a>.
+ </p>
+
+ <h2 id="configuring">Configuring ProGuard</h2>
+
+ <p>For some situations, the default configurations in the <code>proguard.cfg</code> file will
+ suffice. However, many situations are hard for ProGuard to analyze correctly and it might remove code
+ that it thinks is not used, but your application actually needs. Some examples include:</p>
+
+ <ul>
+ <li>a class that is referenced only in the <code>AndroidManifest.xml</code> file</li>
+
+ <li>a method called from JNI</li>
+
+ <li>dynamically referenced fields and methods</li>
+ </ul>
+
+ <p>The default <code>proguard.cfg</code> file tries to cover general cases, but you might
+ encounter exceptions such as <code>ClassNotFoundException</code>, which happens when ProGuard
+ strips away an entire class that your application calls.</p>
+
+ <p>You can fix errors when ProGuard strips away your code by adding a <code>-keep</code> line in
+ the <code>proguard.cfg</code> file. For example:</p>
+ <pre>
+-keep public class <MyClass>
+</pre>
+
+ <p>There are many options and considerations when using the <code>-keep</code> option, so it is
+ highly recommended that you read the <a href="http://proguard.sourceforge.net/manual/introduction.html">ProGuard
+ Manual</a> for more information about customizing your configuration file. The <a href=
+ "http://proguard.sourceforge.net/manual/usage.html#keepoverview">Overview of Keep options</a> and
+ <a href="http://proguard.sourceforge.net/index.html#/manual/examples.html">Examples section</a>
+ are particularly helpful. The <a href=
+ "http://proguard.sourceforge.net/manual/troubleshooting.html">Troubleshooting</a> section of the
+ ProGuard Manual outlines other common problems you might encounter when your code gets stripped
+ away.</p>
+
+ <h2 id="decoding">Decoding Obfuscated Stack Traces</h2>
+
+ <p>When your obfuscated code outputs a stack trace, the method names are obfuscated, which makes
+ debugging hard, if not impossible. Fortunately, whenever ProGuard runs, it outputs a
+ <code><project_root>/bin/proguard/mapping.txt</code> file, which shows you the original
+ class, method, and field names mapped to their obfuscated names.</p>
+
+ <p>The <code>retrace.bat</code> script on Windows or the <code>retrace.sh</code> script on Linux
+ or Mac OS X can convert an obfuscated stack trace to a readable one. It is located in the
+ <code><sdk_root>/tools/proguard/</code> directory. The syntax for executing the
+ <code>retrace</code> tool is:</p>
+ <pre>retrace.bat|retrace.sh [-verbose] mapping.txt [<stacktrace_file>]</pre>
+ <p>For example:</p>
+
+ <pre>retrace.bat -verbose mapping.txt obfuscated_trace.txt</pre>
+
+ <p>If you do not specify a value for <em><stacktrace_file></em>, the <code>retrace</code> tool reads
+ from standard input.</p>
+
+ <h3 id="considerations">Debugging considerations for published applications</h3>
+
+ <p>Save the <code>mapping.txt</code> file for every release that you publish to your users.
+ By retaining a copy of the <code>mapping.txt</code> file for each release build,
+ you ensure that you can debug a problem if a user encounters a bug and submits an obfuscated stack trace.
+ A project's <code>mapping.txt</code> file is overwritten every time you do a release build, so you must be
+ careful about saving the versions that you need.</p>
+
+ <p>For example, say you publish an application and continue developing new features of
+ the application for a new version. You then do a release build using ProGuard soon after. The
+ build overwrites the previous <code>mapping.txt</code> file. A user submits a bug report
+ containing a stack trace from the application that is currently published. You no longer have a way
+ of debugging the user's stack trace, because the <code>mapping.txt</code> file associated with the version
+ on the user's device is gone. There are other situations where your <code>mapping.txt</code> file can be overwritten, so
+ ensure that you save a copy for every release that you anticipate you have to debug.</p>
+
+ <p>How you save the <code>mapping.txt</code> file is your decision. For example, you can rename them to
+ include a version or build number, or you can version control them along with your source
+ code.</p>
\ No newline at end of file
diff --git a/docs/html/tools/help/sqlite3.jd b/docs/html/tools/help/sqlite3.jd
new file mode 100644
index 0000000..9cc7e98
--- /dev/null
+++ b/docs/html/tools/help/sqlite3.jd
@@ -0,0 +1,59 @@
+page.title=sqlite3
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+ <p>From a remote shell to your device or from your host machine, you can use the <a href=
+ "http://www.sqlite.org/sqlite.html">sqlite3</a> command-line program to manage SQLite databases
+ created by Android applications. The <code>sqlite3</code> tool includes many useful commands,
+ such as <code>.dump</code> to print out the contents of a table and <code>.schema</code> to print
+ the SQL CREATE statement for an existing table. The tool also gives you the ability to execute
+ SQLite commands on the fly.</p>
+
+ <p>To use <code>sqlite3</code> from a remote shell:</p>
+
+ <ol>
+ <li>Enter a remote shell by entering the following command:
+ <pre>adb [-d|-e|-s {<serialNumber>}] shell</pre>
+ </li>
+
+ <li>From a remote shell, start the <code>sqlite3</code> tool by entering the following command:
+ <pre>sqlite3</pre>
+
+ <p>You can also optionally specify a full path to a database that you want to explore.
+ Emulator/device instances store SQLite3 databases in the directory
+ <code>/data/data/<package_name>/databases/</code>.</p>
+ </li>
+
+ <li>Once you invoke <code>sqlite3</code>, you can issue <code>sqlite3</code> commands in the
+ shell. To exit and return to the adb remote shell, enter <code>exit</code> or press
+ <code>CTRL+D</code>.</li>
+ </ol>
+
+
+ <p>Here's an example:</p>
+ <pre>$ adb -s emulator-5554 shell
+# sqlite3 /data/data/com.example.google.rss.rssexample/databases/rssitems.db
+SQLite version 3.3.12
+Enter ".help" for instructions
+<em>.... enter commands, then quit...</em>
+# sqlite> .exit
+</pre>
+
+ <p>To use <code>sqlite3</code> locally, instead of within a shell,
+ pull the database file from the device and start {@code sqlite3}:</p>
+
+ <ol>
+ <li>Copy a database file from your device to your host machine:
+ <pre>
+adb pull <database-file-on-device>
+</pre>
+ </li>
+
+ <li>Start the sqlite3 tool from the <code>/tools</code> directory, specifying the database
+ file:
+ <pre>
+sqlite3 <database-file-on-host>
+</pre>
+ </li>
+ </ol>
\ No newline at end of file
diff --git a/docs/html/tools/help/traceview.jd b/docs/html/tools/help/traceview.jd
new file mode 100644
index 0000000..6555ac0
--- /dev/null
+++ b/docs/html/tools/help/traceview.jd
@@ -0,0 +1,16 @@
+page.title=Traceview
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>Traceview is a graphical viewer for execution logs saved by your application.
+Traceview can help you debug your application and profile its performance.</p>
+
+<p>To start Traceview, enter the following command from the SDK <code>tools/</code> directory:</p>
+ <pre>traceview</pre>
+</ol>
+
+<p>For more information on how to use Traceview, see
+<a href="{@docRoot}tools/debugging/debugging-tracing.html">Profiling with Traceview and dmtracedump</a>
+</p>
+
diff --git a/docs/html/tools/help/zipalign.jd b/docs/html/tools/help/zipalign.jd
new file mode 100644
index 0000000..184cdcb
--- /dev/null
+++ b/docs/html/tools/help/zipalign.jd
@@ -0,0 +1,67 @@
+page.title=zipalign
+parent.title=Tools
+parent.link=index.html
+@jd:body
+
+<p>zipalign is an archive alignment tool that provides important
+optimization to Android application (.apk) files.
+The purpose is to ensure that all uncompressed data starts
+with a particular alignment relative to the start of the file. Specifically,
+it causes all uncompressed data within the .apk, such as images or raw files,
+to be aligned on 4-byte boundaries. This
+allows all portions to be accessed directly with {@code mmap()} even if they
+contain binary data with alignment restrictions.
+The benefit is a reduction in the amount of RAM consumed
+when running the application.</p>
+
+<p>This tool should always be used to align your .apk file before
+distributing it to end-users. The Android build tools can handle
+this for you. When using Eclipse with the ADT plugin, the Export Wizard
+will automatically zipalign your .apk after it signs it with your private key.
+The build scripts used
+when compiling your application with Ant will also zipalign your .apk,
+as long as you have provided the path to your keystore and the key alias in
+your project {@code ant.properties} file, so that the build tools
+can sign the package first.</p>
+
+<p class="caution"><strong>Caution:</strong> zipalign must only be performed
+<strong>after</strong> the .apk file has been signed with your private key.
+If you perform zipalign before signing, then the signing procedure will undo
+the alignment. Also, do not make alterations to the aligned package.
+Alterations to the archive, such as renaming or deleting entries, will
+potentially disrupt the alignment of the modified entry and all later
+entries. And any files added to an "aligned" archive will not be aligned.</p>
+
+<p>The adjustment is made by altering the size of
+the "extra" field in the zip Local File Header sections. Existing data
+in the "extra" fields may be altered by this process.</p>
+
+<p>For more information about how to use zipalign when building your
+application, please read <a href="{@docRoot}tools/publishing/app-signing.html">Signing
+Your Application</a>.</p>
+
+
+<h3>Usage</h3>
+
+<p>To align {@code infile.apk} and save it as {@code outfile.apk}:</p>
+
+<pre>zipalign [-f] [-v] <alignment> infile.apk outfile.apk</pre>
+
+<p>To confirm the alignment of {@code existing.apk}:</p>
+
+<pre>zipalign -c -v <alignment> existing.apk</pre>
+
+<p>The {@code <alignment>} is an integer that defines the byte-alignment boundaries.
+This must always be 4 (which provides 32-bit alignment) or else it effectively
+does nothing.</p>
+
+<p>Flags:</p>
+
+<ul>
+ <li>{@code -f} : overwrite existing outfile.zip</li>
+ <li>{@code -v} : verbose output</li>
+ <li>{@code -c} : confirm the alignment of the given file</li>
+</ul>
+
+
+
diff --git a/docs/html/tools/index.jd b/docs/html/tools/index.jd
new file mode 100644
index 0000000..929f849
--- /dev/null
+++ b/docs/html/tools/index.jd
@@ -0,0 +1,96 @@
+page.title=Developer Tools
+@jd:body
+
+
+<img src="{@docRoot}images/tools-home.png" style="float:right;" height="415" width="763" />
+
+<div style="position:relative;height:0">
+<div style="position:absolute;width:420px">
+ <p>The Android Developer Tools (ADT) plugin for Eclipse provides
+ a professional-grade development environment for building
+ Android apps. It's a full Java IDE with advanced features to help you build, test, debug,
+ and package your Android apps. </p>
+ <p>Free, open-source, and runs on most major OS platforms.<br>To get started,
+ <a href="{@docRoot}sdk/index.html">download the Android SDK.</a></p>
+</div>
+</div>
+
+<div style="margin-top:20px;"></div>
+
+<div class="col-6">
+<h3>Full Java IDE</h3>
+
+ <ul>
+ <li>Android-specific refactoring, quick fixes, integrated navigation between Java and Android XML resources.</li>
+ <li>Enhanced XML editors for Android XML resources</li>
+ <li>Static analysis tools to catch performance, usability, and correctness problems</li>
+ <li>Build support for complex projects, command-line support for CI through Ant. Includes ProGuard and app-signing. </li>
+ </ul>
+</div>
+
+<div class="col-6">
+<h3>Graphical UI Builders</h3>
+
+ <ul>
+ <li>Build rich Android UI with drag and drop.
+ <li>Vsualize your UI on tablets, phones, and other devices. Switch themes, locales, even plaform versions instantly, without building.</li>
+ <li>Visual refactoring lets you extracts layout for inclusion, convert layouts, extract styles</li>
+ <li>Editor support for working with custom UI components</li>
+ </ul>
+</div>
+
+<div class="col-6" style="clear:both">
+<h3>Develop on Hardware Devices</h3>
+
+ <ul>
+ <li>Use any commercial Android hardware device or multiple devices.</li>
+ <li>Deploy your app to connected devices directy from the IDE</li>
+ <li>Live, on-device debugging, testing, and profiling</li>
+ </ul>
+</div>
+
+<div class="col-6">
+<h3>Develop on Virtual Devices</h3>
+ <ul>
+ <li>Emulate any device. Use custom screen sizes, keyboards, and other hardware components. </li>
+ <li>Advanced hardware emulation, including camera, sensors, multitouch, telephony.</li>
+ <li>Develop and test for broadest compatibility at lowest cost.</li>
+ </ul>
+
+</div>
+
+<div style="margin-top:20px;"></div>
+
+<div class="col-5">
+<h3>Powerful Debugging</h3>
+
+ <ul>
+ <li>Full Java debugger with on-device debugging and Android-specidic tools</li>
+ <li>Built-in memory analysis, performance/CPU profiling.</li>
+ <li>Graphical tools for debugging and optimizing UI, runtime inspecton of UI structure and performance.</li>
+ <li>Runtime graphical analysis of your app's network bandwidth usage.</li>
+ </ul>
+</div>
+
+<div style="float:right;width:360px;padding-top:1em;">
+ <img src="{@docRoot}images/debugging-tall.png" align="left">
+</div>
+
+
+<div class="col-6">
+<h3>Testing</h3>
+
+ <ul>
+ <li>Fully instrumentated, scriptable test environment.</li>
+ <li>Integrated reports using standard test UI.</li>
+ <li>Create and run unit tests on hardware devices or emulator.</li>
+ </ul>
+
+<h3>Native Development</h3>
+
+ <ul>
+ <li>Support for compiling and packaging existing code written in C or C++.</li>
+ <li>Support for packaging multiple architectures in a single binary, for broad compatibility.</li>
+ </ul>
+</div>
+
diff --git a/docs/html/tools/other-ide.html b/docs/html/tools/other-ide.html
new file mode 100644
index 0000000..2bfe876
--- /dev/null
+++ b/docs/html/tools/other-ide.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/projects/projects-cmdline.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/projects/projects-cmdline.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/othertools.html b/docs/html/tools/othertools.html
new file mode 100644
index 0000000..ed45ccd
--- /dev/null
+++ b/docs/html/tools/othertools.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/tools/index.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/tools/index.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/projects/index.jd b/docs/html/tools/projects/index.jd
new file mode 100644
index 0000000..6a49ac9
--- /dev/null
+++ b/docs/html/tools/projects/index.jd
@@ -0,0 +1,446 @@
+page.title=Managing Projects
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#ApplicationProjects">Android Projects</a></li>
+
+ <li><a href="#LibraryProjects">Library Projects</a>
+ <ol>
+ <li><a href="#considerations">Development considerations</a></li>
+ </ol>
+ </li>
+
+ <li><a href="#TestProjects">Test Projects</a></li>
+
+ <li><a href="#testing">Testing a Library Project</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>Projects act as containers for storing things such as code and resource files. The SDK tools
+ expect your projects to follow a specific structure so it can compile and package your
+ application correctly, so it is highly recommended that you create them with Eclipse and ADT or
+ with the <code>android</code> tool on the command line. There are three types of projects, and
+ they all share the same general structure but differ in function:</p>
+
+ <dl>
+ <dt><strong>Android Projects</strong></dt>
+
+ <dd>An Android project is the container for your application's source code, resource files, and
+ files such as the Ant build and Android Manifest file. An application project is the main type
+ of project and the contents are eventually built into an <code>.apk</code> file that you install on a
+ device.</dd>
+
+ <dt><strong>Test Projects</strong></dt>
+
+ <dd>These projects contain code to test your application projects and are built into
+ applications that run on a device.</dd>
+
+ <dt><strong>Library Projects</strong></dt>
+
+ <dd>These projects contain shareable Android source code and resources that you can reference
+ in Android projects. This is useful when you have common code that you want to reuse.
+ Library projects cannot be installed onto a device, however, they are
+ pulled into the <code>.apk</code> file at build time.</dd>
+ </dl>
+
+ <p>When you use the Android development tools to create a new project, the essential files and
+ folders will be created for you. There are only a handful of files and folders generated for you,
+ and some of them depend on whether you use the Eclipse plugin or the {@code android} tool to
+ generate your project. As your application grows in complexity, you might require new kinds of
+ resources, directories, and files.</p>
+
+ <h2 id="ApplicationProjects">Android Projects</h2>
+
+ <p>Android projects are the projects that eventually get built into an <code>.apk</code> file that you install
+ onto a device. They contain things such as application source code and resource files.
+ Some are generated for you by default, while others should be created if
+ required. The following directories and files comprise an Android project:</p>
+
+ <dl>
+ <dt><code>src/</code></dt>
+
+ <dd>Contains your stub Activity file, which is stored at
+ <code>src<em>/your/package/namespace/ActivityName</em>.java</code>. All other source code
+ files (such as <code>.java</code> or <code>.aidl</code> files) go here as well.</dd>
+
+ <dt><code>bin</code></dt>
+
+ <dd>Output directory of the build. This is where you can find the final <code>.apk</code> file and other
+ compiled resources.</dd>
+
+ <dt><code>jni</code></dt>
+
+ <dd>Contains native code sources developed using the Android NDK. For more information, see the
+ <a href="{@docRoot}tools/sdk/ndk/index.html">Android NDK documentation</a>.</dd>
+
+ <dt><code>gen/</code></dt>
+
+ <dd>Contains the Java files generated by ADT, such as your <code>R.java</code> file and
+ interfaces created from AIDL files.</dd>
+
+ <dt><code>assets/</code></dt>
+
+ <dd>This is empty. You can use it to store raw asset files. Files that you save here are
+ compiled into an <code>.apk</code> file as-is, and the original filename is preserved. You can navigate this
+ directory in the same way as a typical file system using URIs and read files as a stream of
+ bytes using the the {@link android.content.res.AssetManager}. For example, this is a good
+ location for textures and game data.</dd>
+
+ <dt><code>res/</code></dt>
+
+ <dd>
+ Contains application resources, such as drawable files, layout files, and string values. See
+ <a href="{@docRoot}guide/topics/resources/index.html">Application Resources</a> for more
+ information.
+
+ <dl>
+ <dt><code>anim/</code></dt>
+
+ <dd>For XML files that are compiled into animation objects. See the <a href=
+ "{@docRoot}guide/topics/resources/animation-resource.html">Animation</a> resource
+ type.</dd>
+
+ <dt><code>color/</code></dt>
+
+ <dd>For XML files that describe colors. See the <a href=
+ "{@docRoot}guide/topics/resources/color-list-resource.html">Color Values</a> resource
+ type.</dd>
+
+ <dt><code>drawable/</code></dt>
+
+ <dd>For bitmap files (PNG, JPEG, or GIF), 9-Patch image files, and XML files that describe
+ Drawable shapes or a Drawable objects that contain multiple states (normal, pressed, or
+ focused). See the <a href=
+ "{@docRoot}guide/topics/resources/drawable-resource.html">Drawable</a> resource type.</dd>
+
+ <dt><code>layout/</code></dt>
+
+ <dd>XML files that are compiled into screen layouts (or part of a screen). See the <a href=
+ "{@docRoot}guide/topics/resources/layout-resource.html">Layout</a> resource type.</dd>
+
+ <dt><code>menu/</code></dt>
+
+ <dd>For XML files that define application menus.
+ See the <a href="{@docRoot}guide/topics/resources/menu-resource.html">Menus</a>
+ resource type.</dd>
+
+ <dt><code>raw/</code></dt>
+
+ <dd>For arbitrary raw asset files. Saving asset files here instead of in the
+ <code>assets/</code> directory only differs in the way that you access them. These files
+ are processed by aapt and must be referenced from the application using a resource
+ identifier in the {@code R} class. For example, this is a good place for media, such as MP3
+ or Ogg files.</dd>
+
+ <dt><code>values/</code></dt>
+
+ <dd>For XML files that are compiled into many kinds of resource. Unlike other resources in
+ the <code>res/</code> directory, resources written to XML files in this folder are not
+ referenced by the file name. Instead, the XML element type controls how the resources is
+ defined within them are placed into the {@code R} class.</dd>
+
+ <dt><code>xml/</code></dt>
+
+ <dd>For miscellaneous XML files that configure application components. For example, an XML
+ file that defines a {@link android.preference.PreferenceScreen}, {@link
+ android.appwidget.AppWidgetProviderInfo}, or <a href=
+ "{@docRoot}reference/android/app/SearchManager.html#SearchabilityMetadata">Searchability
+ Metadata</a>. See <a href="{@docRoot}guide/topics/resources/index.html">Application Resources</a>
+ for more information about configuring these application components.</dd>
+ </dl>
+ </dd>
+
+ <dt><code>libs/</code></dt>
+
+ <dd>Contains private libraries.</dd>
+
+ <dt><code>AndroidManifest.xml</code></dt>
+
+ <dd>The control file that describes the nature of the application and each of its components.
+ For instance, it describes: certain qualities about the activities, services, intent receivers,
+ and content providers; what permissions are requested; what external libraries are needed; what
+ device features are required, what API Levels are supported or required; and others. See the
+ <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">AndroidManifest.xml</a>
+ documentation for more information</dd>
+
+ <dt><code>project.properties</code></dt>
+
+ <dd>This file contains project settings, such as the build target. This file is integral to
+ the project, so maintain it in a source revision control system. To edit project
+ properties in Eclipse, right-click the project folder and select
+ <strong>Properties</strong>.</dd>
+
+ <dt><code>local.properties</code></dt>
+
+ <dd>Customizable computer-specific properties for the build system. If you use Ant to build
+ the project, this contains the path to the SDK installation. Because the content of the file
+ is specific to the local installation of the SDK, the <code>local.properties</code> should not
+be maintained in a source revision control system. If you use Eclipse, this file is not
+used.</dd>
+
+ <dt><code>ant.properties</code></dt>
+
+ <dd>Customizable properties for the build system. You can edit this file to override default
+ build settings used by Ant and also provide the location of your keystore and key alias so that
+ the build tools can sign your application when building in release mode. This file is integral
+ to the project, so maintain it in a source revision control system. If you use Eclipse, this
+ file is not used.</dd>
+
+ <dt><code>build.xml</code></dt>
+
+ <dd>The Ant build file for your project. This is only applicable for projects that
+ you build with Ant.</dd>
+
+ </dl>
+
+ <h2 id="LibraryProjects">Library Projects</h2>
+
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Library project example code</h2>
+
+ <p>The SDK includes an example application called <code>TicTacToeMain</code> that shows how a dependent
+ application can use code and resources from an Android Library project. The TicTacToeMain
+ application uses code and resources from an example library project called TicTacToeLib.</p>
+
+ <p>To download the sample applications and run them as projects in
+ your environment, use the <em>Android SDK Manager</em> to download the "Samples for
+ SDK API 8" (or later) package into your SDK.</p>
+
+ <p>For more information and to browse the code of the samples, see
+ the <a href="{@docRoot}resources/samples/TicTacToeMain/index.html">TicTacToeMain
+ application</a>.</p>
+ </div>
+ </div>
+
+ <p>An Android <em>library project</em> is a development project that holds shared Android
+ source code and resources. Other Android application projects can reference the library project
+ and, at build time, include its compiled sources in their <code>.apk</code> files. Multiple
+ application projects can reference the same library project and any single application project
+ can reference multiple library projects.</p>
+
+ <p class="note"><strong>Note:</strong> You need SDK Tools r14 or newer to use the new library
+ project feature that generates each library project into its own JAR file.
+ You can download the tools and platforms using the
+ <em>Android SDK Manager</em>, as described in
+ <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</p>
+
+ <p>If you have source code and resources that are common to multiple Android projects, you
+ can move them to a library project so that it is easier to maintain across applications and
+ versions. Here are some common scenarios in which you could make use of library projects:</p>
+
+ <ul>
+ <li>If you are developing multiple related applications that use some of the same components,
+ you move the redundant components out of their respective application projects and create a
+ single, reuseable set of the same components in a library project.</li>
+
+ <li>If you are creating an application that exists in both free and paid versions. You move
+ the part of the application that is common to both versions into a library project. The two
+ dependent projects, with their different package names, will reference the library project
+ and provide only the difference between the two application versions.</li>
+ </ul>
+
+ <p>Structurally, a library project is similar to a standard Android application project. For
+ example, it includes a manifest file at the project root, as well as <code>src/</code>,
+ <code>res/</code> and similar directories. The project can contain the same types of source
+ code and resources as a standard Android project, stored in the same way. For example, source
+ code in the library project can access its own resources through its <code>R</code> class.</p>
+
+ <p>However, a library project differs from an standard Android application project in that you
+ cannot compile it directly to its own <code>.apk</code> and run it on an Android device.
+ Similarly, you cannot export the library project to a self-contained JAR file, as you would do
+ for a true library. Instead, you must compile the library indirectly, by referencing the
+ library in the dependent application and building that application.</p>
+
+ <p>When you build an application that depends on a library project, the SDK tools compile the
+ library into a temporary JAR file and uses it in the main project, then uses the
+ result to generate the <code>.apk</code>. In cases where a resource ID is defined in both the
+ application and the library, the tools ensure that the resource declared in the application gets
+ priority and that the resource in the library project is not compiled into the application
+ <code>.apk</code>. This gives your application the flexibility to either use or redefine any
+ resource behaviors or values that are defined in any library.</p>
+
+ <p>To organize your code further, your application can add references to multiple library
+ projects, then specify the relative priority of the resources in each library. This lets you
+ build up the resources actually used in your application in a cumulative manner. When two
+ libraries referenced from an application define the same resource ID, the tools select the
+ resource from the library with higher priority and discard the other.</p>
+
+ <p>Once you have added references to library projects to your Android project,
+ you can set their relative priority. At build time, the
+ libraries are merged with the application one at a time, starting from the lowest priority to
+ the highest.</p>
+
+ <p>Library projects can reference other library projects and can import an external library
+ (JAR) in the normal way.</p>
+
+ <h3 id="considerations">Development considerations</h3>
+
+ <p>As you develop your library project and dependent applications, keep the points listed below
+ in mind:</p>
+
+ <ul>
+ <li><p><strong>Resource conflicts</strong></p>
+ <p>Since the tools merge the resources of a library project with those of a dependent application
+ project, a given resource ID might be defined in both projects. In this case, the tools select
+ the resource from the application, or the library with highest priority, and discard the other
+ resource. As you develop your applications, be aware that common resource IDs are likely to be
+ defined in more than one project and will be merged, with the resource from the application or
+ highest-priority library taking precedence.</p>
+ </li>
+
+ <li><p><strong>Use prefixes to avoid resource conflicts</strong></p>
+
+ <p>To avoid resource conflicts for common resource IDs, consider using a prefix or other
+ consistent naming scheme that is unique to the project (or is unique across all projects).</p></li>
+
+ <li><p><strong>You cannot export a library project to a JAR file</strong></p>
+
+ <p>A library cannot be distributed as a binary file (such as a JAR file). This will
+be added in a future
+ version of the SDK Tools.</p></li>
+
+ <li><p><strong>A library project can include a JAR library</strong></p>
+
+ <p>You can develop a library project that itself includes a JAR library, however you need to
+ manually edit the dependent application project's build path and add a path to the JAR file.</p></li>
+
+ <li><p><strong>A library project can depend on an external JAR library</strong></p>
+
+ <p>You can develop a library project that depends on an external library (for example, the Maps
+ external library). In this case, the dependent application must build against a target that
+ includes the external library (for example, the Google APIs Add-On). Note also that both the
+ library project and the dependent application must declare the external library in their manifest
+ files, in a <a href=
+ "{@docRoot}guide/topics/manifest/uses-library-element.html"><code><uses-library></code></a>
+ element.</p></li>
+
+ <li> <p><strong>Library projects cannot include raw assets</strong></p>
+
+ <p>The tools do not support the use of raw asset files (saved in the <code>assets/</code> directory)
+ in a library project. Any asset resources
+ used by an application must be stored in the <code>assets/</code> directory of the application
+ project itself. However, resource files saved in the
+ <code>res/</code> directory are supported.</p></li>
+
+ <li><p><strong>Platform version must be lower than or equal to the Android project</strong></p>
+
+ <p>A library is compiled as part of the dependent application project, so the API used in the
+ library project must be compatible with the version of the Android library used to compile the
+ application project. In general, the library project should use an <a href=
+ "{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API level</a> that is the same as — or lower
+ than — that used by the application. If the library project uses an API level that is
+ higher than that of the application, the application project will not compile. It is
+ perfectly acceptable to have a library that uses the Android 1.5 API (API level 3) and that is
+ used in an Android 1.6 (API level 4) or Android 2.1 (API level 7) project, for instance.</p></li>
+
+ <li> <p><strong>No restriction on library package names</strong></p>
+
+ <p>There is no requirement for the package name of a library to be the same as that of
+ applications that use it.</p></li>
+
+ <li><p><strong>Each library project creates its own R class </strong></p>
+
+ <p>When you build the dependent application project, library projects are compiled and
+ merged with the application project. Each library has its own <code>R</code> class, named according
+ to the library's package name. The <code>R</code> class generated from main
+ project and the library project is created in all the packages that are needed including the main
+ project's package and the libraries' packages.</p></li>
+
+ <li><p><strong>Library project storage location</strong></p>
+
+ <p>There are no specific requirements on where you should store a library project, relative to a
+ dependent application project, as long as the application project can reference the library
+ project by a relative link. What is important is that the main
+ project can reference the library project through a relative link.</p></li>
+ </ul>
+
+ <h2 id="TestProjects">Test Projects</h2>
+
+ <p>Test projects contain Android applications that you write using the
+ <a href="{@docRoot}tools/testing/index.html">Testing and
+ Instrumentation framework</a>. The framework is an extension of the JUnit test framework and adds
+ access to Android system objects. The file structure of a test project is the same as an
+ Android project.</p>
+
+ <dl>
+ <dt><code>src/</code></dt>
+
+ <dd>Includes your test source files. Test projects do not require an Activity <code>.java</code>
+ file, but can include one.</dd>
+
+ <dt><code>gen/</code></dt>
+
+ <dd>This contains the Java files generated by ADT, such as your <code>R.java</code> file and
+ interfaces created from AIDL files.</dd>
+
+ <dt><code>assets/</code></dt>
+
+ <dd>This is empty. You can use it to store raw asset files.</dd>
+
+ <dt><code>res/</code></dt>
+
+ <dd>A folder for your application resources, such as drawable files, layout files, string
+ values, etc. See <a href="{@docRoot}guide/topics/resources/index.html">Application
+ Resources</a>.</dd>
+
+ <dt><code>AndroidManifest.xml</code></dt>
+
+ <dd>The Android Manifest for your project. See <a href=
+ "{@docRoot}guide/topics/manifest/manifest-intro.html">The AndroidManifest.xml File</a>. Test
+ Projects have a special <a href=
+ "{@docRoot}guide/topics/manifest/instrumentation-element.html">
+ <code><instrumentation></code></a>
+ element that connects the test project with the application project.</dd>
+
+ <dt><code>project.properties</code></dt>
+
+ <dd>This file contains project settings, such as the build target and links to the project being
+tested. This file is integral to the project, so maintain it in a source
+revision control system. To edit project properties in Eclipse, right-click the project folder
+and select <strong>Properties</strong>.</dd>
+
+ <dt><code>local.properties</code></dt>
+
+ <dd>Customizable computer-specific properties for the build system. If you use Ant to build
+ the project, this contains the path to the SDK installation. Because the content of the file
+ is specific to the local installation of the SDK, it should not be maintained in a Source
+ Revision Control system. If you use Eclipse, this file is not used.</dd>
+
+ <dt><code>ant.properties</code></dt>
+
+ <dd>Customizable properties for the build system. You can edit this file to override default
+ build settings used by Ant and provide the location to your keystore and key alias, so that the
+ build tools can sign your application when building in release mode. This file is integral to
+ the project, so maintain it in a source revision control system.
+ If you use Eclipse, this file is not used.</dd>
+
+ <dt><code>build.xml</code></dt>
+
+ <dd>The Ant build file for your project. This is only applicable for projects that
+ you build with Ant.</dd>
+ </dl>
+
+ <p>For more information, see the <a href=
+ "{@docRoot}tools/testing/index.html">Testing</a> section.</p>
+
+
+ <h2 id="testing">Testing a Library Project</h2>
+
+ <p>There are two recommended ways of setting up testing on code and resources in a library
+ project:</p>
+
+ <ul>
+ <li>You can set up a <a href="{@docRoot}tools/testing/testing_otheride.html">test
+ project</a> that instruments an application project that depends on the library project. You
+ can then add tests to the project for library-specific features.</li>
+
+ <li>You can set up a standard application project that depends on the library and put
+ the instrumentation in that project. This lets you create a self-contained project that
+ contains both the tests/instrumentations and the code to test.</li>
+ </ul>
diff --git a/docs/html/tools/projects/projects-cmdline.jd b/docs/html/tools/projects/projects-cmdline.jd
new file mode 100644
index 0000000..29d0e57
--- /dev/null
+++ b/docs/html/tools/projects/projects-cmdline.jd
@@ -0,0 +1,295 @@
+page.title=Managing Projects from the Command Line
+parent.title=Managing Projects
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#CreatingAProject">Creating an Android Project</a></li>
+ <li><a href="#UpdatingAProject">Updating a Project</a></li>
+ <li><a href="#SettingUpLibraryProject">Setting up a Library Project</a>
+ <ol>
+ <li><a href="#CreatingManifestFile">Creating the manifest file</a></li>
+ <li><a href="#UpdatingLibraryProject">Updating a library project</a></li>
+ </ol>
+ </li>
+ <li><a href="#ReferencingLibraryProject">Referencing a Library Project</a>
+ <ol>
+ <li><a href="#DeclaringLibrary">Declaring library components in the manifest
+file</a></li>
+ <li><a href="#depAppBuild">Building a dependent application</a></li>
+ </ol>
+ </li>
+ </ol>
+
+ <h2>See also</h2>
+
+ <ol>
+ <li><a href=
+ "{@docRoot}tools/testing/testing_otheride.html#CreateTestProjectCommand">Testing
+ from Other IDEs</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The <code>android</code> tool provides you with commands to create all three types of
+ projects. An Android project contains all of the files and resources that are needed to build a
+ project into an .apk file for installation.
+
+ <ul>
+ <li>An Android project contains all of the files and resources that are needed to build a project into
+ an .apk file for installation. You need to create an Android project for any application that you
+ want to eventually install on a device.</li>
+
+ <li>You can also designate an Android project as a library project, which allows it to be shared
+ with other projects that depend on it. Once an Android project is designated as a library
+ project, it cannot be installed onto a device.</li>
+
+ <li>Test projects extend JUnit test functionality to include Android specific functionality. For
+ more information on creating a test project, see <a href=
+ "{@docRoot}tools/testing/testing_otheride.html">Testing from other IDEs</a>.</li>
+ </ul>
+
+
+ <h2 id="CreatingAProject">Creating an Android Project</h2>
+
+ <p>To create an Android project, you must use the <code>android</code> tool. When you create a
+ new project with <code>android</code>, it will generate a project directory with some default
+ application files, stub files, configuration files and a build file.</p>
+
+ <p>To create a new Android project, open a command-line, navigate to the <code>tools/</code>
+ directory of your SDK and run:</p>
+ <pre>
+android create project \
+--target <target_ID> \
+--name <your_project_name> \
+--path path/to/your/project \
+--activity <your_activity_name> \
+--package <your_package_namespace>
+</pre>
+
+ <ul>
+ <li><code>target</code> is the "build target" for your application. It corresponds to an
+ Android platform library (including any add-ons, such as Google APIs) that you would like to
+ build your project against. To see a list of available targets and their corresponding IDs,
+ execute: <code>android list targets</code>.</li>
+
+ <li><code>name</code> is the name for your project. This is optional. If provided, this name
+ will be used for your .apk filename when you build your application.</li>
+
+ <li><code>path</code> is the location of your project directory. If the directory does not
+ exist, it will be created for you.</li>
+
+ <li><code>activity</code> is the name for your default {@link android.app.Activity} class. This
+ class file will be created for you inside
+ <code><em><path_to_your_project></em>/src/<em><your_package_namespace_path></em>/</code>
+ . This will also be used for your .apk filename unless you provide a <code>name</code>.</li>
+
+ <li><code>package</code> is the package namespace for your project, following the same rules as
+ for packages in the Java programming language.</li>
+ </ul>
+
+ <p>Here's an example:</p>
+ <pre>
+android create project \
+--target 1 \
+--name MyAndroidApp \
+--path ./MyAndroidAppProject \
+--activity MyAndroidAppActivity \
+--package com.example.myandroid
+</pre>
+
+ <p>Once you've created your project, you're ready to begin development. You can move your project
+ folder wherever you want for development, but keep in mind that you must use the <a href=
+ "{@docRoot}tools/help/adb.html">Android Debug Bridge</a> (adb) — located in the
+ SDK <code>platform-tools/</code> directory — to send your application to the emulator (discussed
+ later). So you need access between your project solution and the <code>platform-tools/</code> folder.</p>
+
+ <p class="note"><strong>Tip:</strong> Add the <code>platform-tools/</code> as well as the <code>tools/</code> directory
+ to your <code>PATH</code> environment variable.</p>
+
+ <p class="caution"><strong>Caution:</strong> You should refrain from moving the location of the
+ SDK directory, because this will break the SDK location property located in <code>local.properties</code>.
+ If you need to update the SDK location, use the <code>android update project</code> command.
+ See <a href="#UpdatingAProject">Updating a Project</a> for more information.</p>
+
+ <h2 id="UpdatingAProject">Updating a Project</h2>
+
+ <p>If you're upgrading a project from an older version of the Android SDK or want to create a new
+ project from existing code, use the <code>android update project</code> command to update the
+ project to the new development environment. You can also use this command to revise the build
+ target of an existing project (with the <code>--target</code> option) and the project name (with
+ the <code>--name</code> option). The <code>android</code> tool will generate any files and
+ folders (listed in the previous section) that are either missing or need to be updated, as needed
+ for the Android project.</p>
+
+ <p>To update an existing Android project, open a command-line and navigate to the
+ <code>tools/</code> directory of your SDK. Now run:</p>
+ <pre>
+android update project --name <project_name> --target <target_ID>
+--path <path_to_your_project>
+</pre>
+
+ <ul>
+ <li><code>target</code> is the "build target" for your application. It corresponds to an
+ Android platform library (including any add-ons, such as Google APIs) that you would like to
+ build your project against. To see a list of available targets and their corresponding IDs,
+ execute: <code>android list targets</code>.</li>
+
+ <li><code>path</code> is the location of your project directory.</li>
+
+ <li><code>name</code> is the name for the project. This is optional—if you're not
+ changing the project name, you don't need this.</li>
+ </ul>
+
+ <p>Here's an example:</p>
+ <pre>
+android update project --name MyApp --target 2 --path ./MyAppProject
+</pre>
+
+ <h2 id="SettingUpLibraryProject">Setting up a Library Project</h2>
+
+ <p>A library project is a standard Android project, so you can create a new one in the same way
+ as you would a new application project. Specifically, you can use the <code>android</code> tool
+ to generate a new library project with all of the necessary files and folders.</p>
+
+ <p>To create a new library project, navigate to the <code><sdk>/tools/</code> directory and
+ use this command:</p>
+ <pre class="no-pretty-print">
+android create lib-project --name <your_project_name> \
+--target <target_ID> \
+--path path/to/your/project \
+--package <your_library_package_namespace>
+</pre>
+
+ <p>The <code>create lib-project</code> command creates a standard project structure that includes
+ preset property that indicates to the build system that the project is a library. It does this by
+ adding this line to the project's <code>project.properties</code> file:</p>
+ <pre class="no-pretty-print">
+android.library=true
+</pre>
+
+ <p>Once the command completes, the library project is created and you can begin moving source
+ code and resources into it, as described in the sections below.</p>
+
+ <p>If you want to convert an existing application project to a library project, so that other
+ applications can use it, you can do so by adding a the <code>android.library=true</code> property
+ to the application's <code>project.properties</code> file.</p>
+
+ <h3 id="CreatingManifestFile">Creating the manifest file</h3>
+
+ <p>A library project's manifest file must declare all of the shared components that it includes,
+ just as would a standard Android application. For more information, see the documentation for
+ <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">AndroidManifest.xml</a>.</p>
+
+ <p>For example, the <a href=
+ "{@docRoot}resources/samples/TicTacToeLib/AndroidManifest.html">TicTacToeLib</a> example library
+ project declares the Activity <code>GameActivity</code>:</p>
+ <pre>
+<manifest>
+ ...
+ <application>
+ ...
+ <activity android:name="GameActivity" />
+ ...
+ </application>
+</manifest>
+</pre>
+
+ <h3 id="UpdatingLibraryProject">Updating a library project</h3>
+
+ <p>If you want to update the build properties (build target, location) of the library project,
+ use this command:</p>
+ <pre>
+android update lib-project \
+--target <em><target_ID></em> \
+--path <em>path/to/your/project</em>
+</pre>
+
+ <h2 id="ReferencingLibraryProject">Referencing a Library Project</h2>
+
+ <p>If you are developing an application and want to include the shared code or resources from a
+ library project, you can do so easily by adding a reference to the library project in the
+ application project's build properties.</p>
+
+ <p>To add a reference to a library project, navigate to the <code><sdk>/tools/</code>
+ directory and use this command:</p>
+ <pre>
+android update project \
+--target <em><target_ID></em> \
+--path <em>path/to/your/project</em>
+--library <em>path/to/library_projectA</em>
+</pre>
+
+ <p>This command updates the application project's build properties to include a reference to the
+ library project. Specifically, it adds an <code>android.library.reference.<em>n</em></code>
+ property to the project's <code>project.properties</code> file. For example:</p>
+ <pre class="no-pretty-print">
+android.library.reference.1=path/to/library_projectA
+</pre>
+
+ <p>If you are adding references to multiple libraries, note that you can set their relative
+ priority (and merge order) by manually editing the <code>project.properties</code> file and
+ adjusting the each reference's <code>.<em>n</em></code> index as appropriate. For example, assume
+ these references:</p>
+ <pre class="no-pretty-print">
+android.library.reference.1=path/to/library_projectA
+android.library.reference.2=path/to/library_projectB
+android.library.reference.3=path/to/library_projectC
+</pre>
+
+ <p>You can reorder the references to give highest priority to <code>library_projectC</code> in
+ this way:</p>
+ <pre class="no-pretty-print">
+android.library.reference.2=path/to/library_projectA
+android.library.reference.3=path/to/library_projectB
+android.library.reference.1=path/to/library_projectC
+</pre>
+
+ <p>Note that the <code>.<em>n</em></code> index in the references must begin at "1" and increase
+ uniformly without "holes". References appearing in the index after a hole are ignored.</p>
+
+ <p>At build time, the libraries are merged with the application one at a time, starting from the
+ lowest priority to the highest. Note that a library cannot itself reference another library and
+ that, at build time, libraries are not merged with each other before being merged with the
+ application.</p>
+
+ <h3 id="DeclaringLibrary">Declaring library components in the manifest file</h3>
+
+ <p>In the manifest file of the application project, you must add declarations of all components
+ that the application will use that are imported from a library project. For example, you must
+ declare any <code><activity></code>, <code><service></code>,
+ <code><receiver></code>, <code><provider></code>, and so on, as well as
+ <code><permission></code>, <code><uses-library></code>, and similar elements.</p>
+
+ <p>Declarations should reference the library components by their fully-qualified package names,
+ where appropriate.</p>
+
+ <p>For example, the <a href=
+ "{@docRoot}resources/samples/TicTacToeMain/AndroidManifest.html">TicTacToeMain</a> example
+ application declares the library Activity <code>GameActivity</code> like this:</p>
+ <pre>
+<manifest>
+ ...
+ <application>
+ ...
+ <activity android:name="com.example.android.tictactoe.library.GameActivity" />
+ ...
+ </application>
+</manifest>
+</pre>
+
+ <p>For more information about the manifest file, see the documentation for
+ <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">AndroidManifest.xml</a>.</p>
+
+ <h3 id="depAppBuild">Building a dependent application</h3>
+
+ <p>To build an application project that depends on one or more library projects, you can use the
+ standard Ant build commands and compile modes, as described in <a href=
+ "{@docRoot}tools/building/index.html">Building and Running</a>. The tools
+compile and merge all libraries referenced by the application as part of
+ compiling the dependent application project. No additional commands or steps are necessary.</p>
+
diff --git a/docs/html/tools/projects/projects-eclipse.jd b/docs/html/tools/projects/projects-eclipse.jd
new file mode 100644
index 0000000..f1972bc
--- /dev/null
+++ b/docs/html/tools/projects/projects-eclipse.jd
@@ -0,0 +1,237 @@
+page.title=Managing Projects from Eclipse with ADT
+parent.title=Managing Projects
+parent.link=index.html
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#CreatingAProject">Creating an Android Project</a></li>
+
+ <li><a href="#SettingUpLibraryProject">Setting up a Library Project</a></li>
+
+ <li><a href="#ReferencingLibraryProject">Referencing a Library Project</a></li>
+ </ol>
+
+ <h2>See also</h2>
+
+ <ol>
+ <li><a href=
+ "{@docRoot}tools/testing/testing_eclipse.html#CreateTestProjectEclipse">Testing
+ from Eclipse with ADT</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>Eclipse and the ADT plugin provide GUIs and wizards to create all three types of projects
+ (Android project, Library project, and Test project):
+
+ <ul>
+ <li>An Android project contains all of the files and resources that are needed to build a project into
+ an .apk file for installation. You need to create an Android project for any application that you
+ want to eventually install on a device.</li>
+
+ <li>You can also designate an Android project as a library project, which allows it to be shared
+ with other projects that depend on it. Once an Android project is designated as a library
+ project, it cannot be installed onto a device.</li>
+
+ <li>Test projects extend JUnit test functionality to include Android specific functionality. For
+ more information on creating a test project, see <a href=
+ "{@docRoot}tools/testing/testing_eclipse.html">Testing from Eclipse with ADT</a>.</li>
+ </ul>
+
+ <h2 id="CreatingAProject">Creating an Android Project</h2>
+
+ <p>The ADT plugin provides a <em>New Project Wizard</em> that you can use to quickly create a new Android
+ project (or a project from existing code). To create a new project:</p>
+
+ <ol>
+ <li>Select <strong>File</strong> > <strong>New</strong> > <strong>Project</strong>.</li>
+
+ <li>Select <strong>Android</strong> > <strong>Android Project</strong>, and click
+ <strong>Next</strong>.</li>
+
+ <li>Select the contents for the project:
+
+ <ul>
+ <li>Enter a <em>Project Name</em>. This will be the name of the folder where your project
+ is created.</li>
+
+ <li>Under Contents, select <strong>Create new project in workspace</strong>. Select your
+ project workspace location.</li>
+
+ <li>Under Target, select an Android target to be used as the project's Build Target. The
+ Build Target specifies which Android platform you'd like your application built against.
+
+ <p>Select the lowest platform with which your application is compatible.</p>
+
+ <p class="note"><strong>Note:</strong> You can change your the Build Target for your
+ project at any time: Right-click the project in the Package Explorer, select
+ <strong>Properties</strong>, select <strong>Android</strong> and then check the desired
+ Project Target.</p>
+ </li>
+
+ <li>Under Properties, fill in all necessary fields.
+
+ <ul>
+ <li>Enter an <em>Application name</em>. This is the human-readable title for your
+ application — the name that will appear on the Android device.</li>
+
+ <li>Enter a <em>Package name</em>. This is the package namespace (following the same
+ rules as for packages in the Java programming language) where all your source code will
+ reside.</li>
+
+ <li>Select <em>Create Activity</em> (optional, of course, but common) and enter a name
+ for your main Activity class.</li>
+
+ <li>Enter a <em>Min SDK Version</em>. This is an integer that indicates the minimum API
+ Level required to properly run your application. Entering this here automatically sets
+ the <code>minSdkVersion</code> attribute in the <a href=
+ "{@docRoot}guide/topics/manifest/uses-sdk-element.html"><uses-sdk></a> of your
+ Android Manifest file. If you're unsure of the appropriate <a href=
+ "{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Level</a> to use, copy the API Level
+ listed for the Build Target you selected in the Target tab.</li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+
+ <li>Click <strong>Finish</strong>.</li>
+ </ol>
+
+ <p class="note"><strong>Tip:</strong> You can also start the New Project Wizard from the
+ <em>New</em> icon in the toolbar.</p>
+
+ <h2 id="SettingUpLibraryProject">Setting up a Library Project</h2>
+
+ <p>A library project is a standard Android project, so you can create a new one in the same way
+ as you would a new application project.</p>
+
+ <p>When you are creating the library project, you can select any application name, package, and
+ set other fields as needed, as shown in figure 1.</p>
+
+ <p>Next, set the project's properties to indicate that it is a library project:</p>
+
+ <ol>
+ <li>In the <strong>Package Explorer</strong>, right-click the library project and select
+ <strong>Properties</strong>.</li>
+
+ <li>In the <strong>Properties</strong> window, select the "Android" properties group at left
+ and locate the <strong>Library</strong> properties at right.</li>
+
+ <li>Select the "is Library" checkbox and click <strong>Apply</strong>.</li>
+
+ <li>Click <strong>OK</strong> to close the <em>Properties</em> window.</li>
+ </ol>
+
+ <p>The new project is now marked as a library project. You can begin moving source code and
+ resources into it, as described in the sections below.</p>
+
+ <p>You can also convert an existing application project into a library. To do so, simply open the
+ Properties for the project and select the "is Library" checkbox. Other application projects can
+ now reference the existing project as a library project.</p>
+
+ <img src= "{@docRoot}images/developing/adt-props-isLib.png">
+
+ <p class="img-caption"><strong>Figure 1.</strong> Marking a project as an
+ Android library project.</p>
+
+ <h3>Creating the manifest file</h3>
+
+ <p>A library project's manifest file must declare all of the shared components that it includes,
+ just as would a standard Android application. For more information, see the documentation for
+ <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">AndroidManifest.xml</a>.</p>
+
+ <p>For example, the <a href=
+ "{@docRoot}resources/samples/TicTacToeLib/AndroidManifest.html">TicTacToeLib</a> example library
+ project declares the Activity <code>GameActivity</code>:</p>
+ <pre>
+<manifest>
+ ...
+ <application>
+ ...
+ <activity android:name="GameActivity" />
+ ...
+ </application>
+</manifest>
+</pre>
+
+ <h2 id="ReferencingLibraryProject">Referencing a library project</h2>
+
+ <p>If you are developing an application and want to include the shared code or resources from a
+ library project, you can do so easily by adding a reference to the library project in the
+ application project's Properties.</p>
+
+ <p>To add a reference to a library project, follow these steps:</p>
+
+ <ol>
+ <li>In the <strong>Package Explorer</strong>, right-click the dependent project and select
+ <strong>Properties</strong>.</li>
+
+ <li>In the <strong>Properties</strong> window, select the "Android" properties group at left
+ and locate the <strong>Library</strong> properties at right.</li>
+
+ <li>Click <strong>Add</strong> to open the <strong>Project Selection</strong> dialog.</li>
+
+ <li>From the list of available library projects, select a project and click
+ <strong>OK</strong>.</li>
+
+ <li>When the dialog closes, click <strong>Apply</strong> in the <strong>Properties</strong>
+ window.</li>
+
+ <li>Click <strong>OK</strong> to close the <strong>Properties</strong> window.</li>
+ </ol>
+
+ <p>As soon as the Properties dialog closes, Eclipse rebuilds the project, including the contents
+ of the library project.</p>
+
+ <p>Figure 2 shows the Properties dialog that lets you add library references and move
+ them up and down in priority.</p><img src="{@docRoot}images/developing/adt-props-libRef.png">
+
+ <p class="img-caption"><strong>Figure 2.</strong> Adding a reference to a
+ library project in the properties of an application project.</p>
+
+ <p>If you are adding references to multiple libraries, note that you can set their relative
+ priority (and merge order) by selecting a library and using the <strong>Up</strong> and
+ <strong>Down</strong> controls. The tools merge the referenced libraries with your application
+ starting from lowest priority (bottom of the list) to highest (top of the list). If more than one
+ library defines the same resource ID, the tools select the resource from the library with higher
+ priority. The application itself has highest priority and its resources are always used in
+ preference to identical resource IDs defined in libraries.</p>
+
+ <h3>Declaring library components in the manifest file</h3>
+
+ <p>In the manifest file of the application project, you must add declarations of all components
+ that the application will use that are imported from a library project. For example, you must
+ declare any <code><activity></code>, <code><service></code>,
+ <code><receiver></code>, <code><provider></code>, and so on, as well as
+ <code><permission></code>, <code><uses-library></code>, and similar elements.</p>
+
+ <p>Declarations should reference the library components by their fully-qualified package names,
+ where appropriate.</p>
+
+ <p>For example, the <a href=
+ "{@docRoot}resources/samples/TicTacToeMain/AndroidManifest.html">TicTacToeMain</a> example
+ application declares the library Activity <code>GameActivity</code> like this:</p>
+ <pre>
+<manifest>
+ ...
+ <application>
+ ...
+ <activity android:name="com.example.android.tictactoe.library.GameActivity" />
+ ...
+ </application>
+</manifest>
+</pre>
+
+ <p>For more information about the manifest file, see the documentation for <a href=
+ "{@docRoot}guide/topics/manifest/manifest-intro.html">AndroidManifest.xml</a>.</p>
+
+
+
+
+
+
+
diff --git a/docs/html/tools/publishing/app-signing.jd b/docs/html/tools/publishing/app-signing.jd
new file mode 100644
index 0000000..ac45242
--- /dev/null
+++ b/docs/html/tools/publishing/app-signing.jd
@@ -0,0 +1,618 @@
+page.title=Signing Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>All Android apps <em>must</em> be signed</li>
+<li>You can sign with a self-signed key</li>
+<li>How you sign your apps is critical — read this document carefully</li>
+<li>Determine your signing strategy early in the development process</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#signing">Signing Process</a></li>
+<li><a href="#strategies">Signing Strategies</a></li>
+<li><a href="#setup">Basic Setup for Signing</a></li>
+<li><a href="#debugmode">Signing in Debug Mode</a></li>
+<li><a href="#releasemode">Signing Release Mode</a>
+ <ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+ <li><a href="#ExportWizard">Compile and sign with Eclipse ADT</a></li>
+ </ol>
+</li>
+<li><a href="#secure-key">Securing Your Private Key</a></li>
+
+</ol>
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/versioning.html">Versioning Your Applications</a></li>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>The Android system requires that all installed applications be digitally signed with a
+certificate whose private key is held by the application's developer. The Android system uses the
+certificate as a means of identifying the author of an application and establishing trust
+relationships between applications. The certificate is not used to control which applications the
+user can install. The certificate does not need to be signed by a certificate authority: it is
+perfectly allowable, and typical, for Android applications to use self-signed certificates.</p>
+
+<p>The important points to understand about signing Android applications are:</p>
+
+<ul>
+ <li>All applications <em>must</em> be signed. The system will not install an application
+on an emulator or a device if it is not signed.</li>
+ <li>To test and debug your application, the build tools sign your application with a special debug
+ key that is created by the Android SDK build tools.</li>
+ <li>When you are ready to release your application for end-users, you must sign it with a suitable
+ private key. You cannot publish an application that is signed with the debug key generated
+ by the SDK tools.</li>
+ <li>You can use self-signed certificates to sign your applications. No certificate authority is
+ needed.</li>
+ <li>The system tests a signer certificate's expiration date only at install time. If an
+application's signer certificate expires after the application is installed, the application
+will continue to function normally.</li>
+ <li>You can use standard tools — Keytool and Jarsigner — to generate keys and
+sign your application {@code .apk} files.</li>
+ <li>After you sign your application for release, we recommend that you use the
+ <code>zipalign</code> tool to optimize the final APK package.</li>
+</ul>
+
+<p>The Android system will not install or run an application that is not signed appropriately. This
+applies wherever the Android system is run, whether on an actual device or on the emulator.
+For this reason, you must <a href="#setup">set up signing</a> for your application before you can
+run it or debug it on an emulator or device.</p>
+
+<h2 id="signing">Signing Process</h3>
+
+<p>The Android build process signs your application differently depending on which build mode you
+use to build your application. There are two build modes: <em>debug mode</em> and <em>release
+mode</em>. You use debug mode when you are developing and testing your application. You use
+release mode when you want to build a release version of your application that you can
+distribute directly to users or publish on an application marketplace such as Google Play.</p>
+
+<p>When you build in <em>debug mode</em> the Android SDK build tools use the Keytool utility
+(included in the JDK) to create a debug key. Because the SDK build tools created the debug key,
+they know the debug key's alias and password. Each time you compile your application in debug mode,
+the build tools use the debug key along with the Jarsigner utility (also included in the JDK) to
+sign your application's <code>.apk</code> file. Because the alias and password are known to the SDK
+build tools, the tools don't need to prompt you for the debug key's alias and password each time
+you compile.</p>
+
+<p>When you build in <em>release mode</em> you use your own private key to sign your application. If
+you don't have a private key, you can use the Keytool utility to create one for you. When you
+compile your application in release mode, the build tools use your private key along with the
+Jarsigner utility to sign your application's <code>.apk</code> file. Because the certificate and
+private key you use are your own, you will have to provide the password for the keystore and key
+alias.</p>
+
+<p>The debug signing process happens automatically when you run or debug your application using
+Eclipse with the ADT plugin. Debug signing also happens automatically when you use the Ant build
+script with the <code>debug</code> option. You can automate the release signing process by using the
+Eclipse Export Wizard or by modifying the Ant build script and building with the
+<code>release</code> option.</p>
+
+<h2 id="strategies">Signing Strategies</h2>
+
+<p>Some aspects of application signing may affect how you approach the development
+of your application, especially if you are planning to release multiple
+applications. </p>
+
+<p>In general, the recommended strategy for all developers is to sign
+all of your applications with the same certificate, throughout the expected
+lifespan of your applications. There are several reasons why you should do so: </p>
+
+<ul>
+<li>Application upgrade – As you release updates to your application, you
+will want to continue to sign the updates with the same certificate or set of
+certificates, if you want users to upgrade seamlessly to the new version. When
+the system is installing an update to an application, it compares the
+certificate(s) in the new version with those in the existing version. If the
+certificates match exactly, including both the certificate data and order, then
+the system allows the update. If you sign the new version without using matching
+certificates, you will also need to assign a different package name to the
+application — in this case, the user installs the new version as a
+completely new application. </li>
+
+<li>Application modularity – The Android system allows applications that
+are signed by the same certificate to run in the same process, if the
+applications so requests, so that the system treats them as a single application.
+In this way you can deploy your application in modules, and users can update
+each of the modules independently if needed.</li>
+
+<li>Code/data sharing through permissions – The Android system provides
+signature-based permissions enforcement, so that an application can expose
+functionality to another application that is signed with a specified
+certificate. By signing multiple applications with the same certificate and
+using signature-based permissions checks, your applications can share code and
+data in a secure manner. </li>
+
+</ul>
+
+<p>Another important consideration in determining your signing strategy is
+how to set the validity period of the key that you will use to sign your
+applications.</p>
+
+<ul>
+<li>If you plan to support upgrades for a single application, you should ensure
+that your key has a validity period that exceeds the expected lifespan of
+that application. A validity period of 25 years or more is recommended.
+When your key's validity period expires, users will no longer be
+able to seamlessly upgrade to new versions of your application.</li>
+
+<li>If you will sign multiple distinct applications with the same key,
+you should ensure that your key's validity period exceeds the expected
+lifespan of <em>all versions of all of the applications</em>, including
+dependent applications that may be added to the suite in the future. </li>
+
+<li>If you plan to publish your application(s) on Google Play, the
+key you use to sign the application(s) must have a validity period
+ending after 22 October 2033. Google Play enforces this requirement
+to ensure that users can seamlessly upgrade applications when
+new versions are available. </li>
+</ul>
+
+<p>As you design your application, keep these points in mind and make sure to
+use a <a href="#cert">suitable certificate</a> to sign your applications. </p>
+
+<h2 id="setup">Basic Setup for Signing</h2>
+
+<p>Before you begin, make sure that the Keytool utility and Jarsigner utility are available to
+the SDK build tools. Both of these tools are available in the JDK. In most cases, you can tell
+the SDK build tools how to find these utilities by setting your <code>JAVA_HOME</code> environment
+variable so it references a suitable JDK. Alternatively, you can add the JDK version of Keytool and
+Jarsigner to your <code>PATH</code> variable.</p>
+
+<p>If you are developing on a version of Linux that originally came with GNU Compiler for
+Java, make sure that the system is using the JDK version of Keytool, rather than the gcj
+version. If Keytool is already in your <code>PATH</code>, it might be pointing to a symlink at
+<code>/usr/bin/keytool</code>. In this case, check the symlink target to be sure it points
+to the Keytool in the JDK.</p>
+
+<h2 id="debugmode">Signing in Debug Mode</h2>
+
+<p>The Android build tools provide a debug signing mode that makes it easier for you
+to develop and debug your application, while still meeting the Android system
+requirement for signing your APK.
+When using debug mode to build your app, the SDK tools invoke Keytool to automatically create
+a debug keystore and key. This debug key is then used to automatically sign the APK, so
+you do not need to sign the package with your own key.</p>
+
+<p>The SDK tools create the debug keystore/key with predetermined names/passwords:</p>
+<ul>
+<li>Keystore name: "debug.keystore"</li>
+<li>Keystore password: "android"</li>
+<li>Key alias: "androiddebugkey"</li>
+<li>Key password: "android"</li>
+<li>CN: "CN=Android Debug,O=Android,C=US"</li>
+</ul>
+
+<p>If necessary, you can change the location/name of the debug keystore/key or
+supply a custom debug keystore/key to use. However, any custom debug
+keystore/key must use the same keystore/key names and passwords as the default
+debug key (as described above). (To do so in Eclipse/ADT, go to
+<strong>Windows</strong> > <strong>Preferences</strong> >
+<strong>Android</strong> > <strong>Build</strong>.) </p>
+
+<p class="caution"><strong>Caution:</strong> You <em>cannot</em> release your application
+to the public when signed with the debug certificate.</p>
+
+<h3>Eclipse Users</h3>
+
+<p>If you are developing in Eclipse/ADT (and have set up Keytool and Jarsigner as described above in
+<a href="#setup">Basic Setup for Signing</a>),
+signing in debug mode is enabled by default. When you run or debug your
+application, ADT signs the {@code .apk} file with the debug certificate, runs {@code zipalign} on
+the package, then installs it on
+the selected emulator or connected device. No specific action on your part is needed,
+provided ADT has access to Keytool.</p>
+
+<h3>Ant Users</h3>
+
+<p>If you are using Ant to build your {@code .apk} file, debug signing mode
+is enabled by using the <code>debug</code> option with the <code>ant</code> command
+(assuming that you are using a <code>build.xml</code> file generated by the
+<code>android</code> tool). When you run <code>ant debug</code> to
+compile your app, the build script generates a keystore/key and signs the APK for you.
+The script then also aligns the APK with the <code>zipalign</code> tool.
+No other action on your part is needed. Read
+<a href="{@docRoot}tools/building/building-cmdline.html#DebugMode">Building and Running Apps
+on the Command Line</a> for more information.</p>
+
+
+<h3 id="debugexpiry">Expiry of the Debug Certificate</h3>
+
+<p>The self-signed certificate used to sign your application in debug mode (the default on
+Eclipse/ADT and Ant builds) will have an expiration date of 365 days from its creation date.</p>
+
+<p>When the certificate expires, you will get a build error. On Ant builds, the error
+looks like this:</p>
+
+<pre>debug:
+[echo] Packaging bin/samples-debug.apk, and signing it with a debug key...
+[exec] Debug Certificate expired on 8/4/08 3:43 PM</pre>
+
+<p>In Eclipse/ADT, you will see a similar error in the Android console.</p>
+
+<p>To fix this problem, simply delete the <code>debug.keystore</code> file.
+The default storage location for AVDs is in <code>~/.android/</code> on OS X and Linux,
+in <code>C:\Documents and Settings\<user>\.android\</code> on Windows XP, and in
+<code>C:\Users\<user>\.android\</code> on Windows Vista and Windows 7.</p>
+
+
+<p>The next time you build, the build tools will regenerate a new keystore and debug key.</p>
+
+<p>Note that, if your development machine is using a non-Gregorian locale, the build
+tools may erroneously generate an already-expired debug certificate, so that you get an
+error when trying to compile your application. For workaround information, see the
+troubleshooting topic <a href="{@docRoot}resources/faq/troubleshooting.html#signingcalendar">
+I can't compile my app because the build tools generated an expired debug
+certificate</a>. </p>
+
+
+<h2 id="releasemode">Signing in Release Mode</h2>
+
+<p>When your application is ready for release to other users, you must:</p>
+<ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+</ol>
+
+<p>If you are developing in Eclipse with the ADT plugin, you can use the Export Wizard
+to perform the compile, sign, and align procedures. The Export Wizard even allows you to
+generate a new keystore and private key in the process. So if you use Eclipse, you can
+skip to <a href="#ExportWizard">Compile and sign with Eclipse ADT</a>.</p>
+
+
+
+<h3 id="cert">1. Obtain a suitable private key</h3>
+
+<p>In preparation for signing your application, you must first ensure that
+you have a suitable private key with which to sign. A suitable private
+key is one that:</p>
+
+<ul>
+<li>Is in your possession</li>
+<li>Represents the personal, corporate, or organizational entity to be identified
+with the application</li>
+<li>Has a validity period that exceeds the expected lifespan of the application
+or application suite. A validity period of more than 25 years is recommended.
+<p>If you plan to publish your application(s) on Google Play, note that a
+validity period ending after 22 October 2033 is a requirement. You can not upload an
+application if it is signed with a key whose validity expires before that date.
+</p></li>
+<li>Is not the debug key generated by the Android SDK tools. </li>
+</ul>
+
+<p>The key may be self-signed. If you do not have a suitable key, you must
+generate one using Keytool. Make sure that you have Keytool available, as described
+in <a href="#setup">Basic Setup</a>.</p>
+
+<p>To generate a self-signed key with Keytool, use the <code>keytool</code>
+command and pass any of the options listed below (and any others, as
+needed). </p>
+
+<p class="warning"><strong>Warning:</strong> Keep your private key secure.
+Before you run Keytool, make sure to read
+<a href="#secure-key">Securing Your Private Key</a> for a discussion of how to keep
+your key secure and why doing so is critically important to you and to users. In
+particular, when you are generating your key, you should select strong passwords
+for both the keystore and key.</p>
+
+<table>
+<tr>
+<th>Keytool Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-genkey</code></td><td>Generate a key pair (public and private
+keys)</td>
+</tr>
+<tr>
+<td><code>-v</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-alias <alias_name></code></td><td>An alias for the key. Only
+the first 8 characters of the alias are used.</td>
+</tr>
+<tr>
+<td><code>-keyalg <alg></code></td><td>The encryption algorithm to use
+when generating the key. Both DSA and RSA are supported.</td>
+</tr>
+<tr>
+<td><code>-keysize <size></code></td><td>The size of each generated key
+(bits). If not supplied, Keytool uses a default key size of 1024 bits. In
+general, we recommend using a key size of 2048 bits or higher. </td>
+</tr>
+<tr>
+<td><code>-dname <name></code></td><td><p>A Distinguished Name that describes
+who created the key. The value is used as the issuer and subject fields in the
+self-signed certificate. </p><p>Note that you do not need to specify this option
+in the command line. If not supplied, Jarsigner prompts you to enter each
+of the Distinguished Name fields (CN, OU, and so on).</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the
+key.</p> <p>As a security precaution, do not include this option in your command
+line. If not supplied, Keytool prompts you to enter the password. In this way,
+your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-validity <valdays></code></td><td><p>The validity period for the
+key, in days. </p><p><strong>Note:</strong> A value of 10000 or greater is recommended.</p></td>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>A name
+for the keystore containing the private key.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>A password for the
+keystore.</p><p>As a security precaution, do not include this option in your
+command line. If not supplied, Keytool prompts you to enter the password. In
+this way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's an example of a Keytool command that generates a private key:</p>
+
+<pre>$ keytool -genkey -v -keystore my-release-key.keystore
+-alias alias_name -keyalg RSA -keysize 2048 -validity 10000</pre>
+
+<p>Running the example command above, Keytool prompts you to provide
+passwords for the keystore and key, and to provide the Distinguished
+Name fields for your key. It then generates the keystore as a file called
+<code>my-release-key.keystore</code>. The keystore and key are
+protected by the passwords you entered. The keystore contains
+a single key, valid for 10000 days. The alias is a name that you —
+will use later, to refer to this keystore when signing your application. </p>
+
+<p>For more information about Keytool, see the documentation at
+<a
+href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html</a></p>
+
+
+
+<h3 id="releasecompile">2. Compile the application in release mode</h3>
+
+<p>In order to release your application to users, you must compile it in release mode.
+In release mode, the compiled application is not signed by default and you will need
+to sign it with your private key.</p>
+
+<p class="caution"><strong>Caution:</strong>
+You can not release your application unsigned, or signed with the debug key.</p>
+
+<h4>With Eclipse</h4>
+
+<p>To export an <em>unsigned</em> APK from Eclipse, right-click the project in the Package
+Explorer and select <strong>Android Tools</strong> > <strong>Export Unsigned Application
+Package</strong>. Then specify the file location for the unsigned APK.
+(Alternatively, open your <code>AndroidManifest.xml</code> file in Eclipse, select
+the <strong>Manifest</strong> tab, and click <strong>Export an unsigned APK</strong>.)</p>
+
+<p>Note that you can combine the compiling and signing steps with the Export Wizard. See
+<a href="#ExportWizard">Compiling and signing with Eclipse ADT</a>.</p>
+
+<h4>With Ant</h4>
+
+<p>If you are using Ant, you can enable release mode by using the <code>release</code> option
+with the <code>ant</code> command. For example, if you are running Ant from the
+directory containing your {@code build.xml} file, the command would look like this:</p>
+
+<pre>$ ant release</pre>
+
+<p>By default, the build script compiles the application APK without signing it. The output file
+in your project {@code bin/} will be <code><em><your_project_name></em>-unsigned.apk</code>.
+Because the application APK is still unsigned, you must manually sign it with your private
+key and then align it using {@code zipalign}.</p>
+
+<p>However, the Ant build script can also perform the signing
+and aligning for you, if you have provided the path to your keystore and the name of
+your key alias in the project's {@code ant.properties} file. With this information provided,
+the build script will prompt you for your keystore and alias password when you perform
+<code>ant release</code>, it will sign the package and then align it. The final output
+file in {@code bin/} will instead be
+<code><em><your_project_name></em>-release.apk</code>. With these steps
+automated for you, you're able to skip the manual procedures below (steps 3 and 4).
+To learn how to specify your keystore and alias in the {@code ant.properties} file,
+see <a href="{@docRoot}tools/building/building-cmdline.html#ReleaseMode">
+Building and Running Apps on the Command Line</a>.</p>
+
+
+
+<h3 id="signapp">3. Sign your application with your private key</h3>
+
+<p>When you have an application package that is ready to be signed, you can do sign it
+using the Jarsigner tool. Make sure that you have Jarsigner available on your
+machine, as described in <a href="#setup">Basic Setup</a>. Also, make sure that
+the keystore containing your private key is available.</p>
+
+<p>To sign your application, you run Jarsigner, referencing both the
+application's APK and the keystore containing the private key with which to
+sign the APK. The table below shows the options you could use. </p>
+
+<table>
+<tr>
+<th>Jarsigner Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>The name of
+the keystore containing your private key.</td>
+</tr>
+<tr>
+<td><code>-verbose</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-sigalg</code></td><td>The name of the signature algorithim to use in signing the APK.
+Use the value {@code MD5withRSA}.</td>
+</tr>
+<tr>
+<td><code>-digestalg</code></td><td>The message digest algorithim to use in processing the entries
+of an APK. Use the value {@code SHA1}.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>The password for the
+keystore. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the private
+key. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's how you would use Jarsigner to sign an application package called
+<code>my_application.apk</code>, using the example keystore created above.
+</p>
+
+<pre>$ jarsigner -verbose -sigalg MD5withRSA -digestalg SHA1 -keystore my-release-key.keystore
+my_application.apk alias_name</pre>
+
+<p>Running the example command above, Jarsigner prompts you to provide
+passwords for the keystore and key. It then modifies the APK
+in-place, meaning the APK is now signed. Note that you can sign an
+APK multiple times with different keys.</p>
+
+<p class="caution"><strong>Caution:</strong> As of JDK 7, the default signing algorithim has
+changed, requiring you to specify the signature and digest algorithims ({@code -sigalg} and {@code
+-digestalg}) when you sign an APK.</p>
+
+<p>To verify that your APK is signed, you can use a command like this:</p>
+
+<pre>$ jarsigner -verify my_signed.apk</pre>
+
+<p>If the APK is signed properly, Jarsigner prints "jar verified".
+If you want more details, you can try one of these commands:</p>
+
+<pre>$ jarsigner -verify -verbose my_application.apk</pre>
+
+<p>or</p>
+
+<pre>$ jarsigner -verify -verbose -certs my_application.apk</pre>
+
+<p>The command above, with the <code>-certs</code> option added, will show you the
+"CN=" line that describes who created the key.</p>
+
+<p class="note"><strong>Note:</strong> If you see "CN=Android Debug", this means the APK was
+signed with the debug key generated by the Android SDK. If you intend to release
+your application, you must sign it with your private key instead of the debug
+key.</p>
+
+<p>For more information about Jarsigner, see the documentation at
+<a href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html</a></p>
+
+
+<h3 id="align">4. Align the final APK package</h3>
+
+<p>Once you have signed the APK with your private key, run <code>zipalign</code> on the file.
+This tool ensures that all uncompressed data starts with a particular byte alignment,
+relative to the start of the file. Ensuring alignment at 4-byte boundaries provides
+a performance optimization when installed on a device. When aligned, the Android
+system is able to read files with {@code mmap()}, even if
+they contain binary data with alignment restrictions, rather than copying all
+of the data from the package. The benefit is a reduction in the amount of
+RAM consumed by the running application.</p>
+
+<p>The <code>zipalign</code> tool is provided with the Android SDK, inside the
+<code>tools/</code> directory. To align your signed APK, execute:</p>
+
+<pre>$ zipalign -v 4 <em>your_project_name</em>-unaligned.apk <em>your_project_name</em>.apk</pre>
+
+<p>The {@code -v} flag turns on verbose output (optional). {@code 4} is the
+byte-alignment (don't use anything other than 4). The first file argument is
+your signed {@code .apk} file (the input) and the second file is the destination {@code .apk} file
+(the output). If you're overriding an existing APK, add the {@code -f} flag.</p>
+
+<p class="caution"><strong>Caution:</strong> Your input APK must be signed with your
+private key <strong>before</strong> you optimize the package with {@code zipalign}.
+If you sign it after using {@code zipalign}, it will undo the alignment.</p>
+
+<p>For more information, read about the
+<a href="{@docRoot}tools/help/zipalign.html">zipalign</a> tool.
+
+
+<h3 id="ExportWizard">Compile and sign with Eclipse ADT</h3>
+
+<p>If you are using Eclipse with the ADT plugin, you can use the Export Wizard to
+export a <em>signed</em> APK (and even create a new keystore,
+if necessary). The Export Wizard performs all the interaction with
+the Keytool and Jarsigner for you, which allows you to sign the package using a GUI
+instead of performing the manual procedures to compile, sign,
+and align, as discussed above. Once the wizard has compiled and signed your package,
+it will also perfom package alignment with {@code zipalign}.
+Because the Export Wizard uses both Keytool and Jarsigner, you should
+ensure that they are accessible on your computer, as described above
+in the <a href="#setup">Basic Setup for Signing</a>.</p>
+
+<p>To create a signed and aligned APK in Eclipse:</p>
+
+<ol>
+ <li>Select the project in the Package
+Explorer and select <strong>File > Export</strong>.</li>
+ <li>Open the Android folder, select Export Android Application,
+ and click <strong>Next</strong>.
+ <p>The Export Android Application wizard now starts, which will
+ guide you through the process of signing your application,
+ including steps for selecting the private key with which to sign the APK
+ (or creating a new keystore and private key).</p>
+ <li>Complete the Export Wizard and your application will be compiled,
+ signed, aligned, and ready for distribution.</li>
+</ol>
+
+
+
+<h2 id="secure-key">Securing Your Private Key</h2>
+
+<p>Maintaining the security of your private key is of critical importance, both
+to you and to the user. If you allow someone to use your key, or if you leave
+your keystore and passwords in an unsecured location such that a third-party
+could find and use them, your authoring identity and the trust of the user
+are compromised. </p>
+
+<p>If a third party should manage to take your key without your knowledge or
+permission, that person could sign and distribute applications that maliciously
+replace your authentic applications or corrupt them. Such a person could also
+sign and distribute applications under your identity that attack other
+applications or the system itself, or corrupt or steal user data. </p>
+
+<p>Your reputation as a developer entity depends on your securing your private
+key properly, at all times, until the key is expired. Here are some tips for
+keeping your key secure: </p>
+
+<ul>
+<li>Select strong passwords for the keystore and key.</li>
+<li>When you generate your key with Keytool, <em>do not</em> supply the
+<code>-storepass</code> and <code>-keypass</code> options at the command line.
+If you do so, your passwords will be available in your shell history,
+which any user on your computer could access.</li>
+<li>Similarly, when signing your applications with Jarsigner,
+<em>do not</em> supply the <code>-storepass</code> and <code>-keypass</code>
+options at the command line. </li>
+<li>Do not give or lend anyone your private key, and do not let unauthorized
+persons know your keystore and key passwords.</li>
+</ul>
+
+<p>In general, if you follow common-sense precautions when generating, using,
+and storing your key, it will remain secure. </p>
\ No newline at end of file
diff --git a/docs/html/tools/publishing/preparing.jd b/docs/html/tools/publishing/preparing.jd
new file mode 100644
index 0000000..3ebf3f7
--- /dev/null
+++ b/docs/html/tools/publishing/preparing.jd
@@ -0,0 +1,359 @@
+page.title=Preparing for Release
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>Quickview</h2>
+ <ul>
+ <li>Learn which resources you'll need to release your app.</li>
+ <li>Find out how to configure and build your app for release.</li>
+ <li>Learn best practices for releasing your app.</li>
+ </ul>
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#publishing-intro">Introduction</a></li>
+ <li><a href="#publishing-gather">Gathering Materials and Resources</a></li>
+ <li><a href="#publishing-configure">Configuring Your Application</a></li>
+ <li><a href="#publishing-build">Building Your Application</a></li>
+ <li><a href="#publishing-resources">Preparing External Servers and Resources</a></li>
+ <li><a href="#publishing-test">Testing Your Application for Release</a></li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing Overview</a></li>
+ <li><a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a></li>
+ <li><a href="{@docRoot}distribute/googleplay/publish/preparing.html">Publishing Checklist for Google Play</a></li>
+ </ol>
+ </div>
+</div>
+
+<p>Before you distribute your Android application to users you need to prepare it for release. The
+preparation process is a required <a href="{@docRoot}tools/workflow/index.html">development
+task</a> for all Android applications and is the first step in the publishing process (see figure
+1).</p>
+
+<p>When you prepare your application for release, you configure, build, and test a release
+version of your application. The configuration tasks are straightforward, involving basic code
+cleanup and code modification tasks that help optimize your application. The build process is
+similar to the debug build process and can be done using JDK and Android SDK tools. The testing
+tasks serve as a final check, ensuring that your application performs as expected under real-world
+conditions. When you are finished preparing your application for release you have a signed
+<code>.apk</code> file, which you can distribute directly to users or distribute through an
+application marketplace such as Google Play.</p>
+
+<p>This document summarizes the main tasks you need to perform to prepare your application for
+release. The tasks that are described in this document apply to all Android applications regardless
+how they are released or distributed to users. If you are releasing your application through Google
+Play, you should also read <a href="{@docRoot}distribute/googleplay/publish/preparing.html">Publishing
+Checklist for Google Play</a> to be sure your release-ready application satisfies all Google Play
+requirements.</p>
+
+<p class="note"><strong>Note:</strong> As a best practice, your application should meet all of your
+release criteria for functionality, performance, and stability before you perform the tasks outlined
+in this document.</p>
+
+<img src="{@docRoot}images/publishing/publishing_overview_prep.png"
+ alt="Shows how the preparation process fits into the development process"
+ height="190"
+ id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> Preparing for release is a required <a
+href="{@docRoot}tools/workflow/index.html">development
+task</a> and is the first step in the publishing process.
+</p>
+
+<h2 id="publishing-intro">Introduction</h2>
+
+<p>To release your application to users you need to create a release-ready package that users can
+install and run on their Android-powered devices. The release-ready package contains the same
+components as the debug <code>.apk</code> file — compiled source code, resources, manifest
+file, and so on — and it is built using the same build tools. However, unlike the debug
+<code>.apk</code> file, the release-ready <code>.apk</code> file is signed with your own certificate
+and it is optimized with the zipalign tool.</p>
+
+<div class="figure" style="width:331px">
+ <img src="{@docRoot}images/publishing/publishing_preparing.png"
+ alt="Shows the five tasks you perform to prepare your app for release"
+ height="450" />
+ <p class="img-caption">
+ <strong>Figure 2.</strong> You perform five main tasks to prepare your application for
+ release.
+ </p>
+</div>
+
+<p>The signing and optimization tasks are usually seamless if you are building your application with
+Eclipse and the ADT plugin or with the Ant build script (included with the Android SDK). For
+example, you can use the Eclipse Export Wizard to compile, sign, and optimize your application all
+at once. You can also configure the Ant build script to do the same when you build from the command
+line.</p>
+
+<p>To prepare your application for release you typically perform five main tasks (see figure 2).
+Each main task may include one or more smaller tasks depending on how you are releasing your
+application. For example, if you are releasing your application through Google Play you may want
+to add special filtering rules to your manifest while you are configuring your application for
+release. Similarly, to meet Google Play publishing guidelines you may have to prepare screenshots
+and create promotional text while you are gathering materials for release.</p>
+
+<p>You usually perform the tasks listed in figure 2 after you have throroughly debugged and tested
+your application. The Android SDK contains several tools to help you test and debug your Android
+applications. For more information, see the <a
+href="{@docRoot}tools/debugging/index.html">Debugging</a> and <a
+href="{@docRoot}tools/testing/index.html">Testing</a> sections in the Dev Guide.</p>
+
+<h2 id="publishing-gather">Gathering Materials and Resources</h2>
+
+<p>To begin preparing your application for release you need to gather several supporting items. At a
+minimum this includes cryptographic keys for signing your application and an application icon. You
+might also want to include an end-user license agreement.</p>
+
+<h4 id="publishing-keys">Cryptographic keys</h4>
+
+<p>The Android system requires that each installed application be digitally signed with a
+certificate that is owned by the application's developer (that is, a certificate for which the
+developer holds the private key). The Android system uses the certificate as a means of identifying
+the author of an application and establishing trust relationships between applications. The
+certificate that you use for signing does not need to be signed by a certificate authority; the
+Android system allows you to sign your applications with a self-signed certificate. To learn about
+certificate requirements, see <a href="{@docRoot}tools/publishing/app-signing.html#cert">Obtain a
+suitable private key</a>.</p>
+
+<p class="caution"><strong>Important:</strong> Your application must be signed with a cryptographic
+key whose validity period ends after 22 October 2033.</p>
+
+<p>You may also have to obtain other release keys if your application accesses a service or uses a
+third-party library that requires you to use a key that is based on your private key. For example,
+if your application uses the <a
+href="http://code.google.com/android/add-ons/google-apis/reference/com/google/android/maps/MapView.html">MapView</a>
+class, which is part of the <a
+href="http://code.google.com/android/add-ons/google-apis/maps-overview.html">Google Maps external
+library</a>, you will need to register your application with the Google Maps service and obtain
+a Maps API key. For information about getting a Maps API key, see <a
+href="http://code.google.com/android/add-ons/google-apis/mapkey.html"> Obtaining a Maps API
+key</a>.</p>
+
+<h4>Application Icon</h4>
+
+<p>Be sure you have an application icon and that it meets the recommended <a
+href="{@docRoot}guide/practices/ui_guidelines/icon_design_launcher.html">icon guidelines</a>. Your
+application's icon helps users identify your application on a device's Home
+screen and in the Launcher window. It also appears in Manage Applications, My Downloads, and
+elsewhere. In addition, publishing services such as Google Play display your icon to users.</p>
+
+<p class="note"><strong>Note:</strong> If you are releasing your application on Google Play, you
+need to create a high resolution
+ version of your icon. See <a
+href="https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870">Graphic
+Assets for your Application</a> for more information.</p>
+
+<h4>End-user License Agreement</h4>
+
+<p>Consider preparing an End User License Agreement (EULA) for your application. A EULA can help
+protect your person, organization, and intellectual property, and we recommend that you provide one
+with your application.</p>
+
+<h4>Miscellaneous Materials</h4>
+
+<p>You might also have to prepare promotional and marketing materials to publicize your application.
+For example, if you are releasing your application on Google Play you will need to prepare some
+promotional text and you will need to create screenshots of your application. For more
+information, see
+<a href="https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870">
+Graphic Assets for your Application</a></p>
+
+<h2 id="publishing-configure">Configuring Your Application for Release</h2>
+
+<p>After you gather all of your supporting materials you can start configuring your application
+for release. This section provides a summary of the configuration changes we recommend that you make
+to your source code, resource files, and application manifest prior to releasing your application.
+Although most of the configuration changes listed in this section are optional, they are
+considered good coding practices and we encourage you to implement them. In some cases,
+you may have already made these configuration changes as part of your development process.</p>
+
+<h4>Choose a good package name</h4>
+
+<p>Make sure you choose a package name that is suitable over the life of your application. You
+cannot change the package name after you distribute your application to users. You can set the
+package name in application's manifest file. For more information, see the <a
+href="{@docRoot}guide/topics/manifest/manifest-element.html#package">package</a> attribute
+documentation.</p>
+
+<h4>Turn off logging and debugging</h4>
+
+<p>Make sure you deactivate logging and disable the debugging option before you build your
+application for release. You can deactivate logging by removing calls to
+{@link android.util.Log} methods in your source files. You can disable debugging by removing the
+<code>android:debuggable</code> attribute from the <code><application></code> tag in your
+manifest file, or by setting the <code>android:debuggable</code> attribute to
+<code>false</code> in your manifest file. Also, remove any log files or static test files that
+were created in your project.</p>
+
+<p>Also, you should remove all {@link android.os.Debug} tracing calls that you
+added to your code, such as {@link android.os.Debug#startMethodTracing()} and
+{@link android.os.Debug#stopMethodTracing()} method calls.</p>
+
+<h4>Clean up your project directories</h4>
+
+<p>Clean up your project and make sure it conforms to the directory structure described in <a
+href="{@docRoot}tools/projects/index.html#ApplicationProjects">Android Projects</a>.
+Leaving stray or orphaned files in your project can prevent your application from compiling and
+cause your application to behave unpredictably. At a minimum you should do the following cleanup
+tasks:</p>
+
+<ul>
+ <li>Review the contents of your <code>jni/</code>, <code>lib/</code>, and <code>src/</code>
+ directories. The <code>jni/</code> directory should contain only source files associated with the
+ <a href="{@docRoot}tools/sdk/ndk/index.html">Android NDK</a>, such as
+ <code>.c</code>, <code>.cpp</code>, <code>.h</code>, and <code>.mk</code> files. The
+ <code>lib/</code> directory should contain only third-party library files or private library
+ files, including prebuilt shared and static libraries (for example, <code>.so</code> files). The
+ <code>src/</code> directory should contain only the source files for your application
+ (<code>.java</code> and <code>.aidl</code> files). The <code>src/</code> directory should not
+ contain any <code>.jar</code> files.</li>
+ <li>Check your project for private or proprietary data files that your application does not use
+ and remove them. For example, look in your project's <code>res/</code> directory for old
+ drawable files, layout files, and values files that you are no longer using and delete them.</li>
+ <li>Check your <code>lib/</code> directory for test libraries and remove them if they are no
+ longer being used by your application.</li>
+ <li>Review the contents of your <code>assets/</code> directory and your <code>res/raw/</code>
+ directory for raw asset files and static files that you need to update or remove prior to
+ release.</li>
+</ul>
+
+<h4>Review and update your manifest settings</h4>
+
+<p>Verify that the following manifest items are set correctly:</p>
+
+<ul>
+ <li><a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">
+ <uses-permission></a> element
+ <p>You should specify only those permissions that are relevant and required for your application.</p>
+ </li>
+ <li><code>android:icon</code> and <code>android:label</code> attributes
+ <p>You must specify values for these attributes, which are located in the
+ <a href="{@docRoot}guide/topics/manifest/application-element.html"><application></a>
+ element.</p>
+ </li>
+ <li><code>android:versionCode</code> and <code>android:versionName</code> attributes.
+ <p>We recommend that you specify values for these attributes, which are located in the
+ <a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a>
+ element. For more information see
+ <a href="{@docRoot}tools/publishing/versioning.html">Versioning your Application</a>.</p>
+ </li>
+</ul>
+
+<p>There are several additional manifest elements that you can set if you are releasing your
+application on Google Play. For example, the <code>android:minSdkVersion</code> and
+<code>android:targetSdkVersion</code> attributes, which are located in the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"> <uses-sdk></a> element. For more
+information about these and other Google Play settings, see <a
+href="{@docRoot}guide/google/play/filters.html">Filters on Google Play</a>.</p>
+
+<h4>Address compatibility issues</h4>
+
+<p>Android provides several tools and techniques to make your application compatible with a wide
+range of devices. To make your application available to the largest number of users, consider
+doing the following:</p>
+
+<ul>
+ <li><strong>Add support for multiple screen configurations</strong>
+ <p>Make sure you meet the
+ <a href="{@docRoot}guide/practices/screens_support.html#screen-independence">
+ best practices for supporting multiple screens</a>. By supporting multiple screen configurations
+ you can create an application that functions properly and looks good on any of the screen sizes
+ supported by Android.</p>
+ </li>
+ <li><strong>Optimize your application for Android tablet devices.</strong>
+ <p>If your application is designed for devices older than Android 3.0, make it compatible
+ with Android 3.0 devices by following the guidelines and best practices described in
+ <a href="{@docRoot}guide/practices/optimizing-for-3.0.html">Optimizing Apps for Android 3.0
+ </a>.</p>
+ </li>
+ <li><strong>Consider using the Support Library</strong>
+ <p>If your application is designed for devices running Android 3.x, make your application
+ compatible with older versions of Android by adding the
+ <a href="{@docRoot}tools/extras/support-library.html">Support Library</a> to your
+ application project. The Support Library provides static support libraries that you can add to
+ your Android application, which enables you to use APIs that are either not available on
+ older platform versions or use utility APIs that are not part of the framework APIs.</p>
+ </li>
+</ul>
+
+<h4>Update URLs for servers and services</h4>
+
+<p>If your application accesses remote servers or services, make sure you are using the production
+URL or path for the server or service and not a test URL or path.</p>
+
+<h4>Implement Licensing (if you are releasing on Google Play)</h4>
+
+<p>If you are releasing a paid application through Google Play, consider adding support for
+Google Play Licensing. Licensing lets you control access to your application based on whether the
+current user has purchased it. Using Google Play Licensing is optional even if you are
+releasing your app through Google Play.</p>
+
+<p>For more information about Google Play Licensing Service and how to use it in your
+application, see <a href="{@docRoot}guide/google/play/licensing/index.html">Application Licensing</a>.</p>
+
+<h2 id="publishing-build">Building Your Application for Release</h2>
+
+<p>After you finish configuring your application you can build it into a release-ready
+<code>.apk</code> fle that is signed and optimized. The JDK includes the tools for signing the
+<code>.apk</code> file (Keytool and Jarsigner); the Android SDK includes the tools for compiling and
+optimizing the <code>.apk</code> file. If you are using Eclipse with the ADT plugin or you are using
+the Ant build script from the command line, you can automate the entire build process.</p>
+
+<h3>Building with Eclipse</h3>
+
+<p>You can use the Eclipse Export Wizard to build a release-ready <code>.apk</code> file that is
+signed with your private key and optimized. To learn how to run the Export Wizard, see
+<a href="{@docRoot}tools/publishing/app-signing.html#ExportWizard">Compile and sign with Eclipse
+ADT</a>. The Export Wizard compiles your application for release, signs your application with your
+private key, and optimizes your application with the zipalign tool. The Export Wizard should run
+successfully if you have run or debugged your application from Eclipse and you have no errors in
+your application (see <a href="{@docRoot}tools/building/building-eclipse.html">Building
+and Running from Eclipse with ADT</a> for more information.</p>
+
+<p>The Export Wizard assumes that you have a <a href="#billing-keys">certificate and private key</a>
+suitable for signing your application. If you do not have a suitable certificate and private key,
+the Export Wizard will help you generate one (see
+<a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a> for more
+information about the signing process and signing guidelines.</p>
+
+<h3>Building with Ant</h3>
+
+<p>You can use the Ant build script (included in the Android SDK) to build a release-ready
+<code>.apk</code> file that is signed with your private key and optimized. To learn how to do this,
+see <a href="{@docRoot}tools/building/building-cmdline.html#ReleaseMode">Building in
+Release Mode</a>. This build method assumes you have a <a href="#billing-keys">certificate and
+private key</a> suitable for signing your application. If you do not have a suitable certificate and
+private key, the Export Wizard will help you generate one (see
+<a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a> for more
+information about the signing process and signing guidelines.</p>
+
+<h2 id="publishing-resources">Preparing External Servers and Resources</h2>
+
+<p>If your application relies on a remote server, make sure the server is secure and that it is
+configured for production use. This is particularly important if you are implementing <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> in your application and you are
+performing the signature verification step on a remote server.</p>
+
+<p>Also, if your application fetches content from a remote server or a real-time service (such as a
+content feed), be sure the content you are providing is up to date and production-ready.</p>
+
+<h2 id="publishing-test">Testing Your Application for Release</h2>
+
+<p>Testing the release version of your application helps ensure that your application runs properly
+under realistic device and network conditions. Ideally, you should test your application on at least
+one handset-sized device and one tablet-sized device to verify that your user interface elements are
+sized correctly and that your application's performance and battery efficiency are acceptable.</p>
+
+<p>As a starting point for testing, see
+<a href="{@docRoot}tools/testing/what_to_test.html">What to Test</a>. This article provides
+a summary of common Android situations that you should consider when you are testing. When you are
+done testing and you are satisfied that the release version of your application
+behaves correctly, you can release your application to users. For more information, see
+<a href="{@docRoot}tools/publishing/publishing_overview.html#publishing-release">Releasing Your
+Application to Users</a>. If you are publishing your application on Google Play, see
+<a href="{@docRoot}distribute/googleplay/publish/preparing.html">Publishing Checklist
+for Google Play</a>.</p>
+
+
diff --git a/docs/html/tools/publishing/publishing_overview.jd b/docs/html/tools/publishing/publishing_overview.jd
new file mode 100755
index 0000000..572766c9
--- /dev/null
+++ b/docs/html/tools/publishing/publishing_overview.jd
@@ -0,0 +1,238 @@
+page.title=Publishing Overview
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>Quickview</h2>
+ <ul>
+ <li>Learn how to publish Android apps.</li>
+ <li>Find out how to prepare apps for release.</li>
+ <li>Learn how to release apps to users.</li>
+ </ul>
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#publishing-prepare">Preparing Your Application for Release</a></li>
+ <li><a href="#publishing-release">Releasing Your Application to Users</a>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}distribute/googleplay/publish/preparing.html">Publishing on Google Play</a></li>
+ </ol>
+</div>
+</div>
+
+<p>Publishing is the general process that makes your Android applications available to users. When you
+publish an Android application you perform two main tasks:</p>
+
+<ul>
+ <li>You prepare the application for release.
+ <p>During the preparation step you build a release version of your application, which users can
+ download and install on their Android-powered devices.</p>
+ </li>
+ <li>You release the application to users.
+ <p>During the release step you publicize, sell, and distribute the release version of your
+ application to users.</p>
+ </li>
+</ul>
+
+<p>Usually, you release your application through an application marketplace, such as <a href="{@docRoot}distribute/index.html">Google Play</a>.
+However, you can also release applications by sending them directly to users or by letting users
+download them from your own website.</p>
+
+<p>Figure 1 shows how the publishing process fits into the overall Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+The publishing process is typically performed after you finish testing your application in a debug
+environment. Also, as a best practice, your application should meet all of your release criteria for
+functionality, performance, and stability before you begin the publishing process.</p>
+
+<img src="{@docRoot}images/publishing/publishing_overview.png" alt="Shows where the publishing
+ process fits into the overall development process" height="86" id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> Publishing is the last phase of the Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+</p>
+
+<h2 id="publishing-prepare">Preparing Your Application for Release</h2>
+
+<p>Preparing your application for release is a multi-step process that involves the following
+tasks:</p>
+
+<ul>
+ <li>Configuring your application for release.
+ <p>At a minimum you need to remove {@link android.util.Log} calls and remove the
+ <a href="{@docRoot}guide/topics/manifest/application-element.html#debug">android:debuggable</a>
+ attribute from your manifest file. You should also provide values for the
+ <code>android:versionCode</code> and <code>android:versionName</code> attributes, which are
+ located in the
+ <a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a>
+ element. You may also have to configure several other settings to meet Google Play
+ requirements or accomodate whatever method you're using to release your application.</p>
+ </li>
+ <li>Building and signing a release version of your application.
+ <p>The Android Development Tools (ADT) plugin and the Ant build script that are provided
+ with the Android SDK tools provide everything you need to build and sign a release version of
+ your application.</p>
+ </li>
+ <li>Testing the release version of your application.
+ <p>Before you distribute your application, you should thoroughly test the release version on at
+ least one target handset device and one target tablet device.</p>
+ </li>
+ <li>Updating application resources for release.
+ <p>You need to be sure that all application resources such as multimedia files and graphics
+ are updated and included with your application or staged on the proper production servers.</p>
+ </li>
+ <li>Preparing remote servers and services that your application depends on.
+ <p>If your application depends on external servers or services, you need to be sure they
+ are secure and production ready.</p>
+ </li>
+</ul>
+
+<p>You may have to perform several other tasks as part of the preparation process. For example, you
+will need to get a private key for signing your application, and you may need to get a Maps API
+release key if you are using the <a
+href="http://code.google.com/android/add-ons/google-apis/maps-overview.html">Google Maps external
+library</a>. You will also need to create an icon for your application, and you may want to prepare
+an End User License Agreement (EULA) to protect your person, organization, and intellectual
+property.</p>
+
+<p>When you are finished preparing your application for release you will have a signed
+<code>.apk</code> file that you can distribute to users.</p>
+
+<p>To learn how to prepare your application for release, see <a
+href="{@docRoot}tools/publishing/preparing.html">Preparing for Release</a> in the Dev Guide. This
+topic provides step-by-step instructions for configuring and building a release version of your
+application.</p>
+
+<h2 id="publishing-release">Releasing Your Application to Users</h2>
+
+<p>You can release your Android applications several ways. Usually, you release applications
+through an application marketplace such as Google Play, but you can also release applications
+on your own website or by sending an application directly to a user.
+
+<h3 id="publishing-marketplace">Releasing through an App Marketplace</h3>
+
+<p>If you want to distribute your apps to the broadest possible audience, releasing through
+an app marketplace such as Google Play is ideal. </p>
+
+<p>Google Play is the premier marketplace for Android apps and is particularly
+useful if you want to distribute your applications to a large global audience.
+However, you can distribute your apps through any app marketplace you want or
+you can use multiple marketplaces.</p>
+
+
+<h4 id="publishing-market">Releasing Your Applications on Google Play</h4>
+
+<p>Google Play is a robust publishing platform that helps you publicize, sell, and distribute
+your Android applications to users around the world. When you release your applications through
+Google Play you have access to a suite of developer tools that let you analyze your sales,
+identify market trends, and control who your applications are being distributed to. You also have
+access to several revenue-enhancing features such as <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> and <a
+href="{@docRoot}guide/google/play/licensing/index.html">application licensing</a>. The rich array of tools
+and features, coupled with numerous end-user community features, makes Google Play the premier
+marketplace for selling and buying Android applications.</p>
+
+<p>Releasing your application on Google Play is a simple process that involves three basic
+ steps:</p>
+
+<ul>
+ <li>Preparing promotional materials.
+ <p>To fully leverage the marketing and publicity capabilities of Google Play, you need to
+ create promotional materials for your application, such as screenshots, videos, graphics, and
+ promotional text.</p>
+ </li>
+ <li>Configuring options and uploading assets.
+ <p>Google Play lets you target your application to a worldwide pool of users and devices.
+ By configuring various Google Play settings, you can choose the countries you want to
+ reach, the listing languages you want to use, and the price you want to charge in each
+ country. You can also configure listing details such as the application type, category, and
+ content rating. When you are done configuring options you can upload your promotional materials
+ and your application as a draft (unpublished) application.</p>
+ </li>
+ <li>Publishing the release version of your application.
+ <p>If you are satisfied that your publishing settings are correctly configured and your
+ uploaded application is ready to be released to the public, you can simply click
+ <strong>Publish</strong > in the developer console and within minutes your application will be
+ live and available for download around the world.</p>
+ </li>
+</ul>
+
+<p>For information complete information, see <a href="{@docRoot}distribute/index.html">Google Play</a>.</p>
+
+
+<h3 id="publishing-email">Releasing your application through email</h3>
+
+<div class="figure" style="width:246px">
+ <img src="{@docRoot}images/publishing/publishing_via_email.png"
+ alt="Screenshot showing the graphical user interface users see when you send them an app"
+ style="width:240px;" />
+ <p class="img-caption">
+ <strong>Figure 1.</strong> Users can simply click <strong>Install</strong> when you send them
+ an application via email.
+ </p>
+</div>
+
+<p>The easiest and quickest way to release your application is to send it to a user through
+email. To do this, you prepare your application for release and then attach it to an email
+and send it to a user. When the user opens your email message on their Android-powered device
+the Android system will recognize the APK and display an <strong>Install Now</strong>
+button in the email message (see figure 1). Users can install your application by touching the
+button.</p>
+
+<p class="note"><strong>Note:</strong> The <strong>Install Now</strong> button
+shown in Figure 1 appears only if a user has configured their device to allow
+installation from <a href="#unknown-sources">unknown sources</a> and has opened your
+email with the native Gmail application.</p>
+
+<p>Distributing applications through email is convenient if you are sending your application to
+only a few trusted users, but it provides few protections from piracy and unauthorized
+distribution; that is, anyone you send your application to can simply forward it to someone else.</p>
+
+<h2 id="publishing-website">Releasing through a web site</h2>
+
+<p>If you do not want to release your app on a marketplace like Google Play, you
+can make the app available for download on your own website or server, including
+on a private or enterprise server. To do this, you must first prepare your
+application for release in the normal way. Then all you need to do is host the
+release-ready APK file on your website and provide a download link to users.
+</p>
+
+<p>When users browse to the download link from their Android-powered devices,
+the file is downloaded and Android system automatically starts installing it on
+the device. However, the installation process will start automatically only if
+the user has configured their Settings to allow the installation of apps from
+<a href="#unknown-sources">unknown sources</a>.</p>
+
+<p>Although it is relatively easy to release your application on your own
+website, it can be inefficient. For example, if you want to monetize your
+application you will have to process and track all financial transactions
+yourself and you will not be able to use Google Play's <a
+href="{@docRoot}guide/google/play/billing/index.html">In-app Billing service</a>
+to sell in-app products. In addition, you will not be able to use the <a
+href="{@docRoot}guide/google/play/licensing/index.html">Licensing service</a> to
+help prevent unauthorized installation and use of your application.</p>
+
+
+<h2 id="unknown-sources">User Opt-In for Apps from Unknown Sources</h2>
+
+<div class="figure" style="width:246px;margin-top:0;">
+ <img src="{@docRoot}images/publishing/publishing_unknown_sources_sm.png"
+ alt="Screenshot showing the setting for accepting download and install of
+ apps from unknown sources." style="width:240px;" />
+ <p class="img-caption">
+ <strong>Figure 2.</strong> Users must enable the <strong>Unknown sources</strong>
+ setting before they can install apps not downloaded from Google Play.
+ </p>
+</div>
+
+<p>Android protects users from inadvertent download and install of apps from
+locations other than Google Play (which is trusted). It blocks such installs
+until the user opts-in <strong>Unknown sources</strong> in
+Settings <strong>></strong> Security, shown in Figure 2. To allow
+the installation of applications from other sources, users need to enable the
+Unknown sources setting on their devices, and they need to make this
+configuration change <em>before</em> they download your application to their
+devices.</p>
+
+<p class="note">Note that some network providers do not allow users to install
+applications from unknown sources.</p>
diff --git a/docs/html/tools/publishing/versioning.jd b/docs/html/tools/publishing/versioning.jd
new file mode 100644
index 0000000..8f602b4
--- /dev/null
+++ b/docs/html/tools/publishing/versioning.jd
@@ -0,0 +1,174 @@
+page.title=Versioning Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>Your application <em>must</em> be versioned</a></li>
+<li>You set the version in the application's manifest file</li>
+<li>How you version your applications affects how users upgrade </li>
+<li>Determine your versioning strategy early in the development process, including considerations for future releases.</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#appversioning">Setting Application Version</a></li>
+<li><a href="#minsdkversion">Specifying Your Application's System API Requirements</a>
+</ol>
+
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish Your Application</a></li>
+<li><a href="{@docRoot}distribute/googleplay/publish/preparing.html">Publishing Checklist for Google Play</a></li>
+<li><a href="{@docRoot}guide/topics/manifest/manifest-intro.html">The AndroidManifest.xml File</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>Versioning is a critical component of your application upgrade and maintenance
+strategy. Versioning is important because:</p>
+
+<ul>
+<li>Users need to have specific information about the application version that
+is installed on their devices and the upgrade versions available for
+installation. </li>
+<li>Other applications — including other applications that you publish as
+a suite — need to query the system for your application's version, to
+determine compatibility and identify dependencies.</li>
+<li>Services through which you will publish your application(s) may also need to
+query your application for its version, so that they can display the version to
+users. A publishing service may also need to check the application version to
+determine compatibility and establish upgrade/downgrade relationships.</li>
+</ul>
+
+<p>The Android system does not use app version information to enforce
+restrictions on upgrades, downgrades, or compatibility of third-party apps. Instead, you (the
+developer) are responsible for enforcing version restrictions within your application or by
+informing users of the version restrictions and limitations. The Android system does, however,
+enforce system version compatibility as expressed by the <code>minSdkVersion</code> attribute in the
+manifest. This attribute allows an application to specify the minimum system API with which it is
+compatible. For more information see <a href="#minsdkversion">Specifying Minimum System API
+Version</a>.</p>
+
+<h2 id="appversioning">Setting Application Version</h2>
+<p>To define the version information for your application, you set attributes in
+the application's manifest file. Two attributes are available, and you should
+always define values for both of them: </p>
+
+<ul>
+<li><code>android:versionCode</code> — An integer value that represents
+the version of the application code, relative to other versions.
+
+<p>The value is an integer so that other applications can programmatically
+evaluate it, for example to check an upgrade or downgrade relationship. You can
+set the value to any integer you want, however you should make sure that each
+successive release of your application uses a greater value. The system does not
+enforce this behavior, but increasing the value with successive releases is
+normative. </p>
+
+<p>Typically, you would release the first version of your application with
+versionCode set to 1, then monotonically increase the value with each release,
+regardless whether the release constitutes a major or minor release. This means
+that the <code>android:versionCode</code> value does not necessarily have a
+strong resemblance to the application release version that is visible to the
+user (see <code>android:versionName</code>, below). Applications and publishing
+services should not display this version value to users.</p>
+</li>
+<li><code>android:versionName</code> — A string value that represents the
+release version of the application code, as it should be shown to users.
+<p>The value is a string so that you can describe the application version as a
+<major>.<minor>.<point> string, or as any other type of
+absolute or relative version identifier. </p>
+
+<p>As with <code>android:versionCode</code>, the system does not use this value
+for any internal purpose, other than to enable applications to display it to
+users. Publishing services may also extract the <code>android:versionName</code>
+value for display to users.</p>
+</li>
+</ul>
+
+<p>You define both of these version attributes in the
+<code><manifest></code> element of the manifest file. </p>
+
+<p>Here's an example manifest that shows the <code>android:versionCode</code>
+and <code>android:versionName</code> attributes in the
+<code><manifest></code> element. </p>
+
+<pre>
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.example.package.name"
+ android:versionCode="2"
+ android:versionName="1.1">
+ <application android:icon="@drawable/icon" android:label="@string/app_name">
+ ...
+ </application>
+</manifest>
+</pre>
+
+<p>In this example, note that <code>android:versionCode</code> value indicates
+that the current .apk contains the second release of the application code, which
+corresponds to a minor follow-on release, as shown by the
+<code>android:versionName</code> string. </p>
+
+<p>The Android framework provides an API to let applications query the system
+for version information about your application. To obtain version information,
+applications use the
+{@link android.content.pm.PackageManager#getPackageInfo(java.lang.String, int)}
+method of {@link android.content.pm.PackageManager PackageManager}. </p>
+
+<h2 id="minsdkversion">Specifying Your Application's System API Requirements</h2>
+
+<p>If your application requires a specific minimum version of the Android
+platform, or is designed only to support a certain range of Android platform
+versions, you can specify those version requirements as API Level identifiers
+in the application's manifest file. Doing so ensures that your
+application can only be installed on devices that
+are running a compatible version of the Android system. </p>
+
+<p>To specify API Level requirements, add a <code><uses-sdk></code>
+element in the application's manifest, with one or more of these attributes: </p>
+
+<ul>
+<li><code>android:minSdkVersion</code> — The minimum version
+of the Android platform on which the application will run, specified
+by the platform's API Level identifier. </li>
+<li><code>android:targetSdkVersion</code> — Specifies the API Level
+on which the application is designed to run. In some cases, this allows the
+application to use manifest elements or behaviors defined in the target
+API Level, rather than being restricted to using only those defined
+for the minimum API Level.</li>
+<li><code>android:maxSdkVersion</code> — The maximum version
+of the Android platform on which the application is designed to run,
+specified by the platform's API Level identifier. <strong>Important:</strong> Please read the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+documentation before using this attribute. </li>
+</ul>
+
+<p>When preparing to install your application, the system checks the value of this
+attribute and compares it to the system version. If the
+<code>android:minSdkVersion</code> value is greater than the system version, the
+system aborts the installation of the application. Similarly, the system
+installs your application only if its <code>android:maxSdkVersion</code>
+is compatible with the platform version.</p>
+
+<p>If you do not specify these attributes in your manifest, the system assumes
+that your application is compatible with all platform versions, with no
+maximum API Level. </p>
+
+<p>To specify a minimum platform version for your application, add a
+<code><uses-sdk></code> element as a child of
+<code><manifest></code>, then define the
+<code>android:minSdkVersion</code> as an attribute. </p>
+
+<p>For more information, see the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+manifest element documentation and the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Levels</a> document.</p>
diff --git a/docs/html/tools/revisions/index.jd b/docs/html/tools/revisions/index.jd
new file mode 100644
index 0000000..0e7ceef
--- /dev/null
+++ b/docs/html/tools/revisions/index.jd
@@ -0,0 +1,9 @@
+page.title=Revisions
+page.noplus=1
+@jd:body
+
+<p>The Android SDK is composed of individual packages that may undergo
+an update at their own schedule, so some have their own set of release notes. You can
+find information about some of the packages in this section, including the core <a
+href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools</a> and the latest <a
+href="{@docRoot}tools/revisions/platforms.html">Platforms</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/revisions/platforms.jd b/docs/html/tools/revisions/platforms.jd
new file mode 100644
index 0000000..e57c221
--- /dev/null
+++ b/docs/html/tools/revisions/platforms.jd
@@ -0,0 +1,831 @@
+page.title=Platforms
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+
+<h2>See Also</h2>
+<ol>
+ <li><a href="{@docRoot}about/versions/android-4.0-highlights.html">Ice Cream Sandwich
+Highlights and APIs</a></li>
+ <li><a href="{@docRoot}about/versions/android-3.0-highlights.html">Honeycomb
+Highlights and APIs</a></li>
+ <li><a href="{@docRoot}about/versions/android-2.3-highlights.html">Gingerbread
+Highlights and APIs</a></li>
+</ol>
+
+</div>
+</div>
+
+
+
+<p>To develop an Android app, you must install at least one Android platform from the SDK Manager
+against which you can compile your app. Often, any given version of the Android will be revised
+with bug fixes or other changes, as denoted by the "revision" number. Below, you'll find the
+release notes for each version of the platform and the subsequent revisions to the platform
+version.</p>
+
+<p>To determine what revision of an Android platform you
+have installed, refer to the "Installed Packages" listing in the Android SDK Manager.</p>
+
+
+
+
+
+
+
+
+<h2 id="4.0.3">Android 4.0.3</h2>
+
+
+<p class="caution"><strong>Important:</strong> To download the new Android
+4.0.x system components from the Android SDK Manager, you must first update the
+SDK tools to revision 14 or later and restart the Android SDK Manager. If you do not,
+the Android 4.0.x system components will not be available for download.</p>
+
+<div class="toggle-content opened">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-opened.png"
+class="toggle-content-img" alt="" />
+ Revision 3</a> <em>(March 2012)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+
+ <p>Maintenance update. The system version is 4.0.4.</p>
+ <p class="note"><strong>Note:</strong> This system image includes support for emulator
+hardware graphics acceleration when used with SDK Tools r17 or higher.
+(<a href="{@docRoot}tools/devices/emulator.html#accel-graphics">more info</a>)</p>
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>SDK Tools r17 or higher is required.</dd>
+ </dl>
+
+ </div>
+</div>
+
+<div class="toggle-content closed" >
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Revision 2</a> <em>(January 2012)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+
+ <p>Maintenance update. The system version is 4.0.3.</p>
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>SDK Tools r14 or higher is required.</dd>
+ </dl>
+
+ </div>
+</div>
+
+<div class="toggle-content closed" >
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Revision 1</a> <em>(December 2011)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+
+ <p>Initial release. The system version is 4.0.3.</p>
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>SDK Tools r14 or higher is required.</dd>
+ </dl>
+
+ </div>
+</div>
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes the following emulator skins:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA400 (240x400, low density, normal screen)
+ </li>
+ <li>
+ WQVGA432 (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+ <li>
+ WXGA720 (1280x720, extra-high density, normal screen)
+ </li>
+ <li>
+ WSVGA (1024x600, medium density, large screen)
+ </li>
+ <li>
+ WXGA (1280x800, medium density, xlarge screen)
+ </li>
+</ul>
+
+<p>To test your application on an emulator that represents the latest Android device, you can create
+an AVD with the new WXGA720 skin (it's an xhdpi, normal screen device). Note that the emulator
+currently doesn't support the new on-screen navigation bar for devices without hardware navigation
+buttons, so when using this skin, you must use keyboard keys <em>Home</em> for the Home button,
+<em>ESC</em> for the Back button, and <em>F2</em> or <em>Page-up</em> for the Menu button.</p>
+
+<p>However, due to performance issues in the emulator when running high-resolution screens such as
+the one for the WXGA720 skin, we recommend that you primarily use the traditional WVGA800 skin
+(hdpi, normal screen) to test your application.</p>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="4.0">Android 4.0</h2>
+
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 4.0, Revision 2</a> <em>(December 2011)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+ <p>Maintenance update. The system version is 4.0.2.</p>
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>SDK Tools r14 or higher is required.</dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 4.0, Revision 1</a> <em>(October 2011)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+ <p>Initial release. The system version is 4.0.1.</p>
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>SDK Tools r14 or higher is required.</dd>
+ </dl>
+ </div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes the following emulator skins:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA400 (240x400, low density, normal screen)
+ </li>
+ <li>
+ WQVGA432 (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+ <li>
+ WXGA720 (1280x720, extra-high density, normal screen) <span class="new">new</span>
+ </li>
+ <li>
+ WSVGA (1024x600, medium density, large screen) <span class="new">new</span>
+ </li>
+ <li>
+ WXGA (1280x800, medium density, xlarge screen)
+ </li>
+</ul>
+
+<p>To test your application on an emulator that represents the latest Android device, you can create
+an AVD with the new WXGA720 skin (it's an xhdpi, normal screen device). Note that the emulator
+currently doesn't support the new on-screen navigation bar for devices without hardware navigation
+buttons, so when using this skin, you must use keyboard keys <em>Home</em> for the Home button,
+<em>ESC</em> for the Back button, and <em>F2</em> or <em>Page-up</em> for the Menu button.</p>
+
+<p>However, due to performance issues in the emulator when running high-resolution screens such as
+the one for the WXGA720 skin, we recommend that you primarily use the traditional WVGA800 skin
+(hdpi, normal screen) to test your application.</p>
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="3.2">Android 3.2</h2>
+
+
+
+<div class="toggle-content closed">
+
+ <p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 3.2, Revision 1</a> <em>(July 2011)</em>
+ </a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Initial release. SDK Tools r12 or higher is recommended.</dt>
+</dl>
+
+ </div>
+</div>
+
+
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes the following emulator skin:</p>
+
+<ul>
+ <li>
+ WXGA (1280x800, medium density, xlarge screen)
+ </li>
+</ul>
+
+<p>For more information about how to develop an application that displays
+and functions properly on all Android-powered devices, see <a
+href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple
+Screens</a>.</p>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="3.1">Android 3.1</h2>
+
+
+<div class="toggle-content closed">
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 3.1, Revision 3</a> <em>(July 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r12</a> or
+higher.</p>
+</dd>
+<dt>Notes:</dt>
+<dd>
+<p>Improvements to the platform's rendering library to support the visual layout editor in the ADT
+Eclipse plugin. This revision allows for more drawing features in ADT and fixes several
+bugs in the previous rendering library. It also unlocks several editor features that were added in
+ADT 12.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 3.1, Revision 2</a> <em>(May 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r11</a> or
+higher.</p>
+</dd>
+<dt>Notes:</dt>
+<dd>
+<p>Fixes an issue with the visual layout editor rendering library that prevented Android 3.1 from
+running in ADT.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+
+<div class="toggle-content closed">
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 3.1, Revision 1</a> <em>(May 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r11</a> or
+higher.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes the following emulator skin:</p>
+
+<ul>
+ <li>
+ WXGA (1280x800, medium density, xlarge screen)
+ </li>
+</ul>
+
+<p>For more information about how to develop an application that displays
+and functions properly on all Android-powered devices, see <a
+href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple
+Screens</a>.</p>
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="3.0">Android 3.0</h2>
+
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 3.0, Revision 2</a> <em>(July 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r12</a> or
+higher.</p>
+</dd>
+<dt>Notes:</dt>
+<dd>
+<p>Improvements to the platform's rendering library to support the visual layout editor in the ADT
+Eclipse plugin. This revision allows for more drawing features in ADT and fixes several
+bugs in the previous rendering library. It also unlocks several editor features that were added in
+ADT 12.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+<div class="toggle-content closed">
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" alt="" />
+ Android 3.0, Revision 1</a> <em>(February 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r10</a> or higher.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes the following emulator skin:</p>
+
+<ul>
+ <li>
+ WXGA (1280x800, medium density, xlarge screen)
+ </li>
+</ul>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="2.3.4">Android 2.3.4</h2>
+
+
+
+<p>The sections below provide notes about successive releases of
+the Android 2.3.4 platform component for the Android SDK, as denoted by
+revision number. To determine what revision(s) of the Android
+2.3.4 platforms are installed in your SDK environment, refer to
+the "Installed Packages" listing in the Android SDK and AVD Manager.</p>
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" alt="" />
+ Android 2.3.4, Revision 1</a> <em>(May 2011)</em>
+</a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>
+ <p>Requires SDK Tools r11 or higher.</p>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes a set of emulator skins that you can use
+for modeling your application in different screen sizes and resolutions. The
+emulator skins are:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA400 (240x400, low density, normal screen)
+ </li>
+ <li>
+ WQVGA432 (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+</ul>
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="2.3.3">Android 2.3.3</h2>
+
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 2.3.3, Revision 2</a> <em>(July 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r12</a> or
+higher.</p>
+</dd>
+<dt>Notes:</dt>
+<dd>
+<p>Improvements to the platform's rendering library to support the visual layout editor in the ADT
+Eclipse plugin. This revision allows for more drawing features in ADT and fixes several
+bugs in the previous rendering library. It also unlocks several editor features that were added in
+ADT 12.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android 2.3.3, Revision 1</a> <em>(February 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires SDK Tools r9 or higher.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes a set of emulator skins that you can use
+for modeling your application in different screen sizes and resolutions. The
+emulator skins are:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA400 (240x400, low density, normal screen)
+ </li>
+ <li>
+ WQVGA432 (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+</ul>
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="2.3">Android 2.3</h2>
+
+
+
+<p>The sections below provide notes about successive releases of
+the Android 2.3 platform component for the Android SDK, as denoted by
+revision number. To determine what revision(s) of the Android
+2.3 platforms are installed in your SDK environment, refer to
+the "Installed Packages" listing in the Android SDK and AVD Manager.</p>
+
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" alt="" />
+ Android 2.3, Revision 1</a> <em>(December 2010)</em>
+</a></p>
+
+ <div class="toggle-content-toggleme" style="padding-left:2em;">
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>
+ <p>Requires SDK Tools r8 or higher.</p>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes a set of emulator skins that you can use
+for modeling your application in different screen sizes and resolutions. The
+emulator skins are:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA400 (240x400, low density, normal screen)
+ </li>
+ <li>
+ WQVGA432 (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+</ul>
+
+
+
+
+
+
+
+
+
+<h2 id="2.2">Android 2.2</h2>
+
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android {@sdkPlatformVersion}, Revision 3</a> <em>(July 2011)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r12</a> or
+higher.</p>
+</dd>
+<dt>Notes:</dt>
+<dd>
+<p>Improvements to the platform's rendering library to support the visual layout editor in the ADT
+Eclipse plugin. This revision allows for more drawing features in ADT and fixes several
+bugs in the previous rendering library. It also unlocks several editor features that were added in
+ADT 12.</p>
+</dd>
+</dl>
+
+</div>
+</div>
+
+<div class="toggle-content closed" >
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android {@sdkPlatformVersion}, Revision 2</a> <em>(July 2010)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires SDK Tools r6 or higher.</p>
+</dd>
+
+<dt>System Image:</dt>
+<dd>
+<ul>
+<li>Adds default Search Widget.</li>
+<li>Includes proper provisioning for the platform's Backup Manager. For more information about how
+to use the Backup Manager, see <a href="{@docRoot}guide/topics/data/backup.html">Data
+Backup</a>.</li>
+<li>Updates the Android 2.2 system image to FRF91.</li>
+</ul>
+</dd>
+
+</dl>
+ </div>
+</div>
+
+<div class="toggle-content closed">
+
+<p><a href="#" onclick="return toggleContent(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png"
+class="toggle-content-img" alt="" />
+ Android {@sdkPlatformVersion}, Revision 1</a> <em>(May 2010)</em>
+</a></p>
+
+<div class="toggle-content-toggleme" style="padding-left:2em;">
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>Requires SDK Tools r6 or higher.</p>
+</dd>
+
+<dt>Tools:</dt>
+<dd>
+<p>Adds support for building with Android library projects. See <a href="tools-notes.html">SDK
+Tools, r6</a> for information.</p>
+</dd>
+
+</dl>
+ </div>
+</div>
+
+
+<h3>Emulator Skins</h3>
+
+<p>The downloadable platform includes a set of emulator skins that you can use
+for modeling your application in different screen sizes and resolutions. The
+emulator skins are:</p>
+
+<ul>
+ <li>
+ QVGA (240x320, low density, small screen)
+ </li>
+ <li>
+ WQVGA (240x400, low density, normal screen)
+ </li>
+ <li>
+ FWQVGA (240x432, low density, normal screen)
+ </li>
+ <li>
+ HVGA (320x480, medium density, normal screen)
+ </li>
+ <li>
+ WVGA800 (480x800, high density, normal screen)
+ </li>
+ <li>
+ WVGA854 (480x854 high density, normal screen)
+ </li>
+</ul>
\ No newline at end of file
diff --git a/docs/html/tools/samples/index.jd b/docs/html/tools/samples/index.jd
new file mode 100644
index 0000000..5c0e8db
--- /dev/null
+++ b/docs/html/tools/samples/index.jd
@@ -0,0 +1,31 @@
+page.title=Samples
+
+@jd:body
+
+<p>To help you understand some fundamental Android APIs and coding practices, a variety of sample
+code is available from the Android SDK Manager.</p>
+
+<p>To download the samples:</p>
+<ol>
+ <li>Launch the Android SDK Manager.
+ <ul>
+ <li>On Windows, double-click the SDK Manager.exe file at the root of the Android SDK
+directory.</li>
+ <li>On Mac or Linux, open a terminal to the {@code tools/} directory in the
+Android SDK, then execute {@code android sdk}.</ul>
+ </li>
+ <li>Expand the list of packages for the latest Android platform.</li>
+ <li>Select and download <em>Samples for SDK</em>.</li>
+</ol>
+
+<p>When the download is complete, you can find the samples sources at this location:</p>
+
+<p style="margin-left:2em">
+<code><em><sdk></em>/platforms/<android-version>/samples/</code>
+</p>
+
+<p>You can easily create new Android projects with the downloaded samples, modify them
+if you'd like, and then run them on an emulator or device. </p>
+<!--
+<p>Below are summaries for several of the available samples.</p>
+-->
\ No newline at end of file
diff --git a/docs/html/tools/sdk/OLD_RELEASENOTES.jd b/docs/html/tools/sdk/OLD_RELEASENOTES.jd
new file mode 100644
index 0000000..6865db2
--- /dev/null
+++ b/docs/html/tools/sdk/OLD_RELEASENOTES.jd
@@ -0,0 +1,527 @@
+page.title=Release Notes for Older SDK Versions
+@jd:body
+
+<div class="special">
+ <p><strong>Note:</strong> These are the release notes for the "early-look" SDK versions, released
+ before the full Android 1.0 release in September 2008.
+ Release notes for the Android 1.0 and later SDK versions are provided in the main
+ <a href="{@docRoot}sdk/RELEASENOTES.html">Release Notes</a> document.</p>
+</div>
+
+
+
+<a name="0.9_r1" id="0.9_r1"></a>
+<h2>Android 0.9 SDK Beta (r1)</h2>
+
+<p>This beta SDK release contains a large number of bug fixes and improvements from the early-look SDKs.
+The sections below describe the highlights of the release.
+
+<h3>New Features and Notable Changes</h3>
+
+<p><strong>Behavior and System Changes</strong></p>
+<ul>
+ <li>New Home screen and many user interface updates
+ </li>
+ <li>Minor changes to Activity lifecycle and task management
+ </li>
+ <li>New window option to request OpenGL acceleration for certain kinds of View structures
+ </li>
+</ul>
+<p>
+ <b>
+ Significant API Changes</b>
+</p>
+<ul>
+ <li>onFreeze(Bundle) renamed to onSaveInstanceState(Bundle), to better reflect the fact that it does not represent an actual change in application lifecycle
+ </li>
+ <li>IntentReceivers are now known as BroadcastReceivers (but still operate on Intents.)
+ </li>
+ <li>Various parts of the API cleaned up to use Intents instead of Bundles; Intent itself improved to reduce the need for separate payload Bundles.</li>
+ <li>ContentProvider Cursors have had significant changes to make them easier to create and remove certain data consistency bugs.
+ </li>
+ <li>Changes to menus to make them more flexible; also added context menus (similar to "right mouse button" menus)
+ </li>
+ <li>Changes to the Sensor API to make reading sensors more convenient and reduce the need to poll
+ </li>
+ <li>Improvements to the Camera API
+ </li>
+ <li>Significant changes to the Location API to make it easier to use and better self-documenting
+ </li>
+ <li>API cleanup on MapViews
+ </li>
+ <li>Performance-related changes to the MediaPlayer, as well as support for new types of ringtones
+ </li>
+ <li>Apache HTTPClient installation upgraded to 4.x of that API; 3.x version is removed
+ </li>
+ <li>HTTPClient 4.x removes multipart methods, include HttpMime which is an extension of Mime4j (http://james.apache.org/mime4j/index.html) in your project instead
+ </li>
+ <li>Improvements to WiFi and related networking
+ </li>
+ <li>New Preferences API to easily store small amounts of data
+ </li>
+ <li>Improvements to the Telephony API, including ability to obtain source number of incoming phone calls
+ </li>
+ <li>Variety of improvements to the View API
+ </li>
+ <li>Variety of improvements to component management, such as the ability to keep components private, better control over when processes are started, and ability to "alias" an Activity to more than one entry in AndroidManifest.xml
+ </li>
+ <li>Improvements to how the Browser and WebView, such as better control over content downloads
+ </li>
+ <li>A number of enhancements to XML layouts, such as the new <merge> tag
+ </li>
+ <li>Numerous improvements to the standard widgets
+ </li>
+ <li>Network access now requires that applications obtain a permission in their AndroidManifest.xml files.
+ </li>
+</ul>
+<p>
+ <b>
+ Maps & Location</b>
+</p>
+<ul>
+ <li>The MapView will require an API key on final Android 1.0 devices. This key can be obtained at no cost from Google, and will allow access to the full MapView API. In this release, the API key must be provided but can be any dummy value. In the final 1.0-compatible SDKs, this will need to be a real key.
+ </li>
+ <li>The KML-based mock location provider supported in previous releases is no longer supported. In the current SDK, you can use the emulator console to send GPS fix updates to the emulator and applications running on it. Also, the DDMS tool provides an UI that you can use to easily upload GPX and KML files. DDMS handles playback of the KML or GPX tracks automatically. </li>
+</ul>
+<p>
+ <b>ADT Plugin for Eclipse</b></p>
+ <p>The ADT Plugin that accompanies this SDK includes a preview of the Graphical Layout Editor. Files located in <project>/res/layout[-qualifiers]/ will be opened with the new layout editor. This is very much a work in progress, and provided here for preview purpose. The editor feature is subject to change.
+</p>
+<ul>
+ <li>Dual page editor with a WYSIWYG page (the graphical editor) and an XML page with content assist.
+ </li>
+ <li>The interactivity in the editor itself is limited to selection at the moment. Actions on the layout elements can be done from the following standard Eclipse views: Outline (add/remove/up/down), and Properties (editing of all the element properties with a tooltip in the status bar).
+ </li>
+ <li>Top part of the editor allows you to display the layout in different configurations (language, orientation, size, etc...), and different themes.
+
+ <ul>
+ <li>All referenced resources (strings, bitmaps, etc...) are resolved based on the selected configuration/theme.
+ </li>
+ <li>A green check mark next to a resource qualifier indicates that the opened file matches the value of the qualifier. A warning sign indicates that the opened file does not specifies any value for this qualifier.
+ </li>
+ <li>If a different version of the opened layout matches the new configuration selection (in a different res/layout-qualifier folder) then the editor automatically switches to that new file.
+ </li>
+ </ul>
+ </li>
+ <li>Custom Views are supported, however if they do too much in their constructor/onDraw method, it may not work (the layout library used by the editor only includes a sub-part of the Android framework). Check the android console for errors/exceptions.
+ </li>
+</ul>
+
+<p>Known issues/limitations for Graphical Layout Editor include:</p>
+
+ <ul>
+ <li>Font display is very close but not equals to on-device rendering since the font engine in Java slightly differs from the font engine in Android. This should not have any impact on your layouts.
+ </li>
+ <li>Creating new views in a relative layout automatically puts each new elements below each other using the <i>layout_below</i> attribute. However, until the layout file is saved, they will appear stacked on top of each other.
+ </li>
+ <li>Some XML based drawables don't draw. Fading in the scroll/list view appears as a white rectangle. Generally do not expect every single fancy drawing feature of the android framework to be supported in the layout editor (but we're working on it).
+ </li>
+ <li>Themes defined in the project are not added to the theme drop-down.
+ </li>
+ <li>No animation support!
+ </li>
+ <li>No support for WebView, MapView and SurfaceView.
+ </li>
+ <li>No UI support for <merge>, <include>, <ViewStub> elements. You can add these elements to your manifest using the xml editor only.
+ </li>
+ <li>If a layout fails to render in a way that prevents the whole editor from opening, you can:
+
+ <ul>
+ <li>open that particular file in a different editor: right click the file in the package explorer and choose Open With... > XML editor
+ </li>
+ <li>completely disable the layout editor, by setting a system wide environment variable called ANDROID_DISABLE_LAYOUT to any value.
+ </li>
+ </ul>
+ <li>If a layout fails to render, check the android console (in the standard Eclipse Console view). Errors/Exceptions will be displayed in there.
+ </li>
+ </ul>
+ </li>
+</ul>
+<p>Other ADT features/notes include:</p>
+<ul>
+ <li>There is a new launch option for activity. You can choose to launch the default activity (finds an activity configured to show up in the home screen), or a specific activity, or none.</li>
+ <li>Normal Java resources (non Java files placed in package folders) are now properly packaged in the final package, and can be accessed through normal java API such as ClassLoader.getResourceAsStream()</li>
+ <li>Launch configuration now has an option to wipe emulator data on launch. This always asks for confirmation.</li>
+ <li>Launch configuration now has an option to disable the boot animation. This will let the emulator start faster on older computers.</li>
+ <li>Installation of application is now more robust and will notify of installation failure. Also installation is blocking, removing issues where ADT tried to launch the activity before the app was installed.</li>
+
+</ul>
+
+<p><b>Ant Build Tools</b></p>
+
+<ul>
+ <li><span>External jar libraries are now directly supported by build.xml, just drop them in the libs directory.</li>
+</ul>
+
+<p><b>Emulator</b></p>
+
+<ul>
+ <li>The console port number of a given emulator instance is now displayed in its window's title bar.</li>
+ <li>You can define the console port number used by a given emulator instance.
+To do so, start the instance with the '-port <port>' option and
+specify which port the emulator should bind to for the console. <port> must be an *even* integer between 5554 and 5584 inclusive. The corresponding ADB port will be <port>+1.</li>
+ <li>The <code>-adb-port</code> command is deprecated. Please do not use it, as it will be removed soon and you cannot use both -port and -adb-port at the same time.</li>
+ <li>Voice/sms are automatically forwarded to other emulator instances running on the same machine, as long as you use their console port number as the destination phone number. For example, if you have two emulators running, the first one will typically use console port 5554, and the second one will use port 5556, dialing 5556 on the first emulator will generate an incoming call on the second emulator. You can also hold/unhold calls. This also works when sending SMS messages from one emulator to the other.</li>
+ <li>A new <code>-scale <fraction></code> option allows you to scale the emulator window. </li>
+ <li>A new <code>-no-boot-anim</code> option tells the emulator to disable the boot animation. On slower systems, this can significantly reduce the time to boot the system in the emulator.</li>
+
+</ul>
+
+<p>
+ <b>Other Development Tools</b>
+</p>
+
+<p>The SDK includes several new development tools, such as</p>
+<ul>
+ <li><a href="{@docRoot}tools/help/hierarchy-viewer.html">HierarchyViewer</a> is a visual tool for inspecting and debugging your user interfaces and layout. </li>
+ <li><a href="{@docRoot}tools/help/draw9patch.html">Draw 9-patch</a> allows you to easily create a NinePatch graphic using a WYSIWYG editor. </li>
+ <li>The <a href="{@docRoot}tools/help/monkey.html">UI/Application Exerciser Monkey</a> generates pseudo-random system and user events, for testing your application. </li>
+</ul>
+<p>
+ <b>Application Signing</b>
+</p>
+<ul>
+ <li>Starting with this release, Android .apk files must be cryptographically signed, or the system will reject them upon installation. The purpose of this requirement is to securely and uniquely identify developers, so that the system can -- for example -- safely let multiple .apk files signed by the same developer share resources.
+ </li>
+ <li>There are no requirements on the key used to sign .apk files; locally-generated and self-signed keys are allowed. There is no PKI, and developers will not be required to purchase certificates, or similar. For developers who use the Eclipse/ADT plugin, application signing will be largely automatic. Developers who do not use Eclipse/ADT can use the standard Java jarsigner tool to sign .apk files.
+ </li>
+</ul>
+<p>
+ <b>Sample Code</b>
+</p>
+<ul>
+ <li>LunarLander has been converted to render into a SurfaceView via a background Thread, for better performance.
+ </li>
+ <li>New sample: the source code for the now-obsolete Home screen from M5 is included as an example of how to construct a Home screen replacement.
+ </li>
+</ul>
+<p>
+ <b>
+ Removed Functionality</b>
+</p>
+<ul>
+ <li>Due to significant API changes in the upstream open-source project and due to the timeline of getting certain Bluetooth profile implementations certified, a comprehensive Bluetooth API will not be possible or present in Android 1.0.
+ </li>
+ <li>Due to the security risks inherent in accepting arbitrary data from "outside" the device, the data messaging facility of the GTalkService will not be present in Android 1.0. The GTalkService will provide connectivity to Google's servers for Google Talk instant messaging, but the API has been removed from this release while we improve the service. Note that this will be a Google-specific service and is not part of the core of Android.
+ </li>
+ <li>We know that these changes will affect many developers who have worked with the prior early looks at the SDK, and we are very sorry for the resulting inconvenience. We look forward to the possibilty of restoring some or all of this functionality in a later version of the Android platform.
+ </li>
+</ul>
+<p>
+ <b>
+ Miscellaneous</b>
+</p>
+<ul>
+ <li>Many internal and non-public APIs have been removed from the documentation. Classes and methods that are not present in the documentation are non-public and should not be used, even though they may appear in tools such as IDEs. A future version of the SDK will ship with an android.jar file that contains only public classes, to help developers avoid accidentally using non-public APIs.
+ </li>
+ <li>A few extraneous APIs (such as unnecessary packages under java.awt) have been removed.
+ </li>
+ <li>Several additional tools are included, such as a utility for easily drawing 9-patch images.
+ </li>
+ <li>The DDMS utility has been refactored into library form. This is not of direct interest to application developers, but may be of interest to vendors interested in integrating the Android SDK into their products. Watch for more information about the ddmlib library soon.
+ </li>
+ <li>For performance and maintainability reasons, some APIs were moved into separate modules that must be explicitly included in the application via a directive in AndroidManifest.xml. Notable APIs that fall into this category are the MapView, and the java.awt.* classes, which each now reside in separate modules that must be imported. Developers who overlook this requirement will see ClassNotFoundExceptions that seem spurious.
+ </li>
+ <li>Developers who use 'adb push' to install applications must now use 'adb install', since the full package manager is now implemented. 'adb push' will no longer work to install .apk files.
+ </li>
+ <li>The emulator supports a variety of new options, and some existing options have been changed. Please consult the updated emulator documentation for details.
+ </li>
+</ul>
+
+<h3>
+ Resolved Issues
+</h3>
+<p>
+ The list below is not comprehensive, but instead highlights the most interesting fixes since the last SDK release.
+</p>
+<ul>
+ <li>More of the standard Android user applications are now included, such as the Music and Messaging applications.
+ </li>
+ <li>Many bug fixes to the Media Player
+ </li>
+ <li>Emulator performance is improved, especially for startup
+ </li>
+ <li>More internal APIs are removed from class documentation. (However, this work is not quite yet complete.)
+ </li>
+ <li>It's now much easier to add media content to the SD card and have the ContentProvider locate and expose it to other applications.
+ </li>
+</ul>
+
+<h3>
+ Known Issues
+</h3>
+<ul>
+ <li>The final set of Intent patterns honored by Android 1.0 has not yet been fully documented. Documentation will be provided in future releases.
+ </li>
+ <li>We regret to inform developers that Android 1.0 will not support 3.5" floppy disks.
+ </li>
+ <li>Unfortunately, the ability to play audio streams from memory (such as via an InputStream or Reader) will not be possible in Android 1.0. As a workaround, we recommend that developers save media content to SD card and use MediaPlayer to play from a file URI, or embed a small HTTP server and play from a URI on localhost (such as http://127.0.0.1:4242/something).
+ </li>
+ <li>Android now supports modules or libraries that can be optionally linked into applications; a good example is the MapView, which has been moved into such a library. However, Android 1.0 will not support the ability for third-party developers to create such libraries for sharing with other applications.
+ </li>
+ <li>We believe that we have eliminated the problem with very long emulator startups on Windows, but had some trouble reproducing the issue. We are interested in feedback from developers, if this issue persists.
+ </li>
+</ul>
+
+
+
+
+<a name="m5-rc15"></a>
+<h2>Version m5-rc15</h2>
+
+<h3>New Features</h3>
+<p>m5-rc15 does not introduce any new features.</p>
+
+<h3>Resolved Issues</h3>
+<ul>
+ <li>1012640: Incorrect handling of BMP images.</li>
+</ul>
+
+<h3>Known Issues</h3>
+<p>Unless otherwise noted, Known Issues from m5-rc14 also apply to m5-rc15.</p>
+
+
+
+
+<a name="m5-rc14"></a>
+<h2>Version m5-rc14</h2>
+
+<h3>New Features</h3>
+
+<p>In addition to changes in the Android APIs, m5-rc14 also introduces changes to the Android Developer Tools:</p>
+
+<h4>emulator</h4>
+<ul>
+ <li>The Android emulator now support SD card images up to 128 GB in size. The previous limit was 2 GB.</li>
+</ul>
+
+<h4>DDMS</h4>
+<ul>
+ <li>Support for managing multiple devices has been integrated into DDMS. This should make it easier to debug applications that are run on multiple device scenarios.</li>
+</ul>
+
+<h4>ADT</h4>
+<ul>
+ <li>ADT now attempts to connect a debugger to any application that shows up
+ in the wait-for-debugger state, even if this application was not launched
+ from Eclipse.
+ <br /><br />
+ The connection is actually established only if there exists a project
+ in the Eclipse workspace that contains an <code>AndroidManifest.xml</code>
+ declaring a package matching the name of the process.
+ To force this connection from your code, use <code>Debug.waitForDebugger()</code>. Activities declaring that they require their own process through the
+ "process" attribute with a value like ":someProcess" will be
+ recognized and a debugger will be connected accordingly.
+ This should make it easier to debug intent receivers, services,
+ providers, and other activities not launched from the standard app
+ launcher.<br /><br /></li>
+ <li>ADT has launch modes for device target selection. Automatic mode will: 1) launch an emulator if no device is present, 2) automatically target the device if only one is connected, and 3) prompt the user if 2 or more are connected. Manual mode will always prompt the user.<br /><br /></li>
+ <li>ADT also contains the same support for multiple devices that has been introduced into DDMS.</li>
+</ul>
+
+<h4>AIDL</h4>
+<ul>
+ <li>AIDL files that import and reuse types is now supported by activityCreator.py and ADT.</li>
+</ul>
+
+<h4>traceview</h4>
+<ul>
+ <li>The <a href="{@docRoot}tools/help/traceview.html">traceview</a> tool is now included in the SDK.</li>
+</ul>
+
+<h3>Resolved Issues</h3>
+
+<p>The following Known Issues from m3-rc20 have been resolved:</p>
+<ul>
+ <li>917572: The activityCreator created incorrect IntelliJ scripts</li>
+ <li>917465: Unanswered incoming calls placed from the emulator console will result in an unfinished call UI if you press the call back button</li>
+ <li>917247: dmtracedump and traceview tools are not available in the SDK</li>
+ <li>912168: Extremely rapid or prolonged scrolling in the Maps application or MapsView will result in application errors</li>
+ <li>905852: adb emits warnings about deprecated API use on Mac OS X 10.5</li>
+ <li>905242: The Run dialog sometimes failed to show the Android Launcher</li>
+ <li>901122: The focus ring in the browser is sometimes incorrect</li>
+ <li>896274: On Windows, the emulator sometimes starts off-screen</li>
+ <li>778432: Icons for newly installed applications do not display</li>
+</ul>
+
+<h3>Known Issues</h3>
+
+<p>The following are known issues in m5-rc14:</p>
+
+<ul>
+ <li>1017312: The emulator window size has been reduced slightly, to allow it to be fully visible on smaller screens. This causes a slight clipping of the HVGA emulator skin but does not affect its function.</li>
+ <li>1021777: Setting a power requirement in a <code>Criteria</code> object passed to <code>{@link android.location.LocationManager#getBestProvider getBestProvider()}</code> will result in a value not being returned.</li>
+ <li>1025850: Emulator failing to launch from the Eclipse plugin due to wrong custom command line parameters do not report the error anywhere and silently fails.</li>
+</ul>
+
+<p>Unless otherwise noted, Known Issues from m3-rc20a also apply to m5-rc14.</p>
+
+
+
+
+<a name="m3-rc37a"></a>
+<h2>Version m3-rc37a</h2>
+
+<p>Version m3-rc37a and ADT 0.3.3 were released on December 14, 2007.</p>
+
+<h3>New Features</h3>
+
+<h4>Android Debug Bridge (ADB)</h4>
+<ul>
+<li>Now supports multiple emulators on one host computer. Please note that you need to use the <code>-data</code> option when starting secondary emulators, to allow those instances to save their data across sessions. Also, DDMS does not yet support debugging on multiple emulators yet. </li>
+</ul>
+
+<h4>ADT Plugin for Eclipse</h4>
+<ul>
+<li>Adds editor capabilities for working with Android manifest files, such as syntax highlighting and autocompletion. The editor capabilities require the Web Tools WST plugin for Eclipse, which is included in <a href="http://www.eclipse.org/downloads/moreinfo/compare.php">most Eclipse packages</a>. Not having WST does not prevent the ADT plugin from working. If necessary, you can download and install WST from the Web Tools Project <a href="http://download.eclipse.org/webtools/downloads">downloads page</a>. To update directly from an Eclipse installation, you can add a remote update site with this URL: http://download.eclipse.org/webtools/updates . Note that installing WST on Eclipse 3.4 will require installing other packages, as detailed on the WTP downloads page</a>.
+</li>
+<li>Now retries to launch the app on the emulator if it fails due to timing issues when the emulator is booting.</li>
+<li>Adds support for loading custom skins from the <SDK>/lib/images/skins/ directory. The Skin dropdown in the Emulator tab is now built from the content of the skins/ directory in order to support developer-made skins.</li>
+<li>Adds an Emulator control panel. This is a UI on top of the emulator console that allows you to change the state of the network and gsm connection, and to initiate incoming voice call. (This is also present in standalone DDMS.)</li>
+<li>Adds support for referenced projects. Android projects will add to the apk package any code from referenced projects.</li>
+<li>Eclipse console now warns if an .apk that is pushed to the device declares the same package as another already installed package.</li>
+<li>Java classes generated by the Eclipse plugin are now marked as derived automatically, so that Team plugins do not consider them as regular source.</li>
+</ul>
+
+<h4>Emulator Console</h4>
+<ul>
+<li>Now provides support for emulating inbound SMS messages. The ADT plugin and DDMS provide integrated access to
+this capability. For more information about how to emulate inbound SMS from the console,
+see <a href="{@docRoot}tools/help/emulator.html#sms">SMS Emulation</a>. </li>
+</ul>
+
+<h4>Emulator</h4>
+<ul><li>The default emulator skin has been changed to HVGA-P from QVGA-L. For information
+about emulator skins and how to load a specific skin when starting the emulator, see
+<a href="{@docRoot}tools/help/emulator.html#skins">Using Emulator Skins</a>.</li>
+</ul>
+
+<h3>Resolved Issues</h3>
+
+<h4>907947</h4>
+<p><code>adb -version</code> now returns a version number.</p>
+
+<h4>917462</h4>
+<p>Audio on Windows is fixed and is no longer 'choppy'. </p>
+
+<h4>Removed Manifest File Locking on Mac OS X</h4>
+
+<p>ADT plugin now uses a custom java editor for R.java/Manifest.java, to make those files non-editable. This is to replace the current locking mechanism which causes issues on Mac OS (preventing projects from being deleted). Note that your project must recompile at least once for the lock to be removed from the files.</p>
+
+<h4>The following known issues noted in m3-rc20 are now fixed:</h4>
+<p>
+<ul>
+<li>890937: Emulator does not support non-qwerty keyboards.
+<li>894618: <code>adb shell</code> may fail to connect when used the first time.
+<li>896274: On Windows, the emulator window may start off-screen.
+<li>899949: The emulator may fail to start with <code>-useaudio</code> on some environments.
+<li>912619: Emulator console listens on non-local ports 5554-5584.
+<li>917399: On Windows, running multiple emulator consoles can result in unexpected behavior when simulating incoming telephone calls.
+</ul>
+</p>
+
+<h3>Known Issues</h3>
+
+<p>Unless otherwise noted, Known Issues from m3-rc22a also apply to m3-rc37a.</p>
+
+
+
+
+<a name="m3-rc22a"></a>
+<h2>Version m3-rc22a</h2>
+
+<p>Version m3-rc22a and ADT 0.3.1 were released on November 16, 2007.</p>
+
+<h3>Resolved Issues</h3>
+
+<h4>920067</h4>
+<p>The New Android Project wizard provided by ADT 0.3.1 now properly displays error messages when used with Eclipse 3.2 on Windows.</p>
+
+<h4>920045</h4>
+<p>The <code>AndroidManifest.xml</code> files generated by ADT 0.3.1 now include the XML element required for displaying the associated app in the "Applications" menu. If you have applications created with ADT 0.3.0, simply ensure that your <code>AndroidManifest.xml</code> file contains the following highlighted line:</p>
+<pre>
+...
+ <intent-filter>
+ <action android:value="android.intent.action.MAIN" />
+ <strong><category android:value="android.intent.category.LAUNCHER" /></strong>
+ </intent-filter>
+...
+</pre>
+
+<h4>920098</h4>
+<p>ADT 0.3.1 is now compatible with Eclipse 3.4.</p>
+
+<h4>920282</h4>
+<p>Fixes a NullPointerException that is thrown in certain situations with the DDMS perspective in Eclipse.</p>
+
+<h4>918637</h4>
+<p>Address a keyboard lock-up issue when using <code>adb</code> on Mac OS X 10.4 and 10.5.</p>
+
+<h3>Known Issues</h3>
+
+<p>Unless otherwise noted, known issues from m3-rc20a also apply to m3-rc22a.</p>
+
+<a name="m3-rc20a"></a>
+
+<h2>Version m3-rc20a</h2>
+<h3>Known Issues</h3>
+
+<p>The following are known issues in m3-rc20a:</p>
+
+<h4>778432 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>In certain circumstances, icons for newly installed applications do not display as expected.</p>
+
+<h4>890937 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m3-rc37a">m3-rc37a</a></span></h4>
+<p>The emulator currently does not support non-QWERTY keyboards.</p>
+
+<h4>894618 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m3-rc37a">m3-rc37a</a></span></h4>
+<p>The adb shell command may fail to connect when used for the first time.</p>
+
+<h4>896274 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>On Windows, the emulator screen will sometimes show up off-screen when it is started. The workaround for this is to right-click on the emulator taskbar entry, select Move, and move the window using keyboard arrow keys</p>
+
+<h4>899949 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m3-rc37a">m3-rc37a</a></span></h4>
+<p>The emulator may fail to start when using the <code>-useaudio</code> in some environments</p>
+
+<h4>901122 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>The focus ring shown in the browser may sometimes not properly wrap links.</p>
+
+<h4>905242 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>On Mac OS X 10.5, the Eclipse plugin's Run Dialog may sometimes fail to show the option to select the Android Launcher.</p>
+
+<h4>905852 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>On Mac OS X 10.5, adb will emit warnings about deprecated API use when first used.</p>
+
+<h4>912168 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>extremely rapid or prolonged scrolling in the Maps application or in a MapView will result in application errors.</p>
+
+<h4>912619 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m3-rc37a">m3-rc37a</a></span></h4>
+<p>The emulator console listens for connections on ports 5554-5587. Future versions will only accept connections from localhost. It is recommend that you use a firewall to block external connections to those ports on your development machine.</p>
+
+<h4>912849</h4>
+<p>On Mac OS X 10.4, the emulator may hang if started in the background (i.e. <code>./emulator &</code>).</p>
+
+<h4>914692</h4>
+<p>On Mac OS X 10.5, the emulator will emit warnings about deprecated API use when started from the command line.</p>
+
+<h4>917247 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>The dmtracedump and traceview tools are not available in the SDK.</p>
+
+<h4>917399 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m3-rc37a">m3-rc37a</a></span></h4>
+<p>On Windows, running multiple emulator consoles can result in unexpected behavior when simulating incoming telephone calls.</p>
+
+<h4>917465 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>Unanswered incoming calls placed from the emulator console, will result in an unfinished call UI if you press the call back button.</p>
+
+<h4>917572 - <span style="font-weight: normal; font-size: 13px; font-style: italic">Resolved in <a href="#m5-rc14">m5</a></span></h4>
+<p>Using activityCreator with the <code>--ide intellij</code> option creates IntelliJ scripts with incorrect documentation location specified. To correct, change value for the <code><JAVADOC></code> element in the generated .ipr file from <code>file://.../docs/framework</code> to <code>file://.../docs/reference</code>.</p>
+
+<h4>917579</h4>
+<p>On Ubuntu 7.10 (Gusty), the Eclipse package installed by the <code>apt-get install eclipse</code> command uses java-gcj by default. This configuration is not compatible with the Android Eclipse plugin (ADT) and will result in "Class not found" errors whenever you access an ADT feature.</p>
+ <p>The resolution for this issue is to install a Sun JDK</p>
+ <pre>sudo update-java-alternatives --jre java-1.5.0-sun</pre>
+ <p>and then configure Eclipse to use it by exporting the following environment variable:</p>
+ <pre>export JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun</pre>
+ <p>or by adding following to your <code>.eclipse/eclipserc file</code>:</p>
+ <pre>JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun</pre>
+
diff --git a/docs/html/tools/sdk/RELEASENOTES.jd b/docs/html/tools/sdk/RELEASENOTES.jd
new file mode 100644
index 0000000..c7ece42
--- /dev/null
+++ b/docs/html/tools/sdk/RELEASENOTES.jd
@@ -0,0 +1,803 @@
+page.title=SDK Release Notes
+@jd:body
+
+<p>This document provides version-specific information about Android SDK
+releases. <!--For the latest known issues, please ensure that you're viewing this
+page at <a
+href="http://developer.android.com/sdk/RELEASENOTES.html">http://developer.
+android.com/sdk/RELEASENOTES.html</a>.--></p>
+
+<h2 id="multiversion_r1">Android SDK</h2>
+
+<p>The Android SDK has changed! If you've worked with the Android SDK before,
+you will notice several important differences:</p>
+
+<ul>
+<li style="margin-top:.5em">The SDK downloadable package includes <em>only</em>
+the latest version of the Android SDK Tools.</li>
+<li>Once you've installed the SDK, you now use the Android SDK and AVD Manager
+to download all of the SDK components that you need, such as Android platforms,
+SDK add-ons, tools, and documentation. </li>
+<li>The new approach is modular — you can install only the components you
+need and update any or all components without affecting your development
+environment.</li>
+<li>In short, once you've installed the new SDK, you will not need to download
+an SDK package again. Instead, you will use the Android SDK and AVD Manager to
+keep your development environment up-to-date. </li>
+</ul>
+
+<p>Note that if you are currently using the Android 1.6 SDK, you do not
+necessarily need to install the new SDK, since your existing SDK already
+includes the Android SDK and AVD Manager tool. To develop against Android 2.0.1,
+for example, you could just download the Android 2.0.1 platform into your existing
+SDK. </p>
+
+<p>Release notes for Android platforms and other SDK components are
+now available from the "SDK" tab, under "Downloadable SDK Components."</p>
+
+<ul>
+<li>Notes for the Android 2.0.1 platform are in the <a
+href="{@docRoot}about/versions/android-2.0.1.html">Android 2.0.1, Release 1</a> document. </li>
+<li>You can find information about tools changes in the <a
+href="{@docRoot}tools/sdk/tools-notes.html#notes">SDK Tools</a> and <a
+href="{@docRoot}tools/sdk/eclipse-adt.html#notes">ADT Plugin for Eclipse</a>.</li>
+</ul>
+
+<p>To get started with the SDK, review the Quick Start summary on the <a
+href="{@docRoot}sdk/index.html">Android SDK download page</a> or read <a
+href="{@docRoot}sdk/installing/index.html">Installing the SDK</a> for detailed
+installation instructions. </p>
+
+
+<h2 id="1.6_r1">Android 1.6 SDK, Release 1</h2>
+
+<p>This SDK provides updates to the development tools and Android system that
+you use to create applications for compliant Android-powered devices. </p>
+
+<h3>Release Overview</h3>
+
+<p>This SDK release includes several new features for developers. Highlights of the
+changes include: </p>
+
+ <ul>
+ <li>Emulator support for multiple screen sizes/densities, including new
+skins. </li>
+ <li>Android SDK and AVD Manager, a graphical UI to let you manage your
+SDK and AVD environments more easily. The tool lets you create and manage
+your <a href="{@docRoot}tools/devices/managing-avds.html">Android Virtual
+Devices</a> and download new SDK packages (such as platform versions and
+add-ons) into your environment.</li>
+ <li>Improved support for test packages in New Project Wizard</li>
+ <li>The reference documentation now offers a "Filter by API Level"
+capability that lets you display only the parts of the API that are actually
+available to your application, based on the <code>android:minSdkVersion</code>
+value the application declares in its manifest. For more information, see
+<a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">Android API Levels</a></li>
+ </ul>
+
+<p>For details about the Android platforms included in the SDK — including
+bug fixes, features, and API changes — please read the <a
+href="android-1.6.html">Android 1.6 version notes</a>.</p>
+
+<h3>Installation and Upgrade Notes</h3>
+
+<p>If you've been developing an application using an Android 1.1 SDK, you need
+to make a few changes to your development environment to migrate to the new SDK.
+Tools and documentation are provided to assist you. No changes to the source
+code of an existing application should be needed, provided that your application
+is not using Android internal structures or APIs.</p>
+
+<p>To ensure that your existing application will work properly on a device
+running the latest version of the Android platform, you are strongly encouraged
+to migrate the application to the new SDK, compile it using the platform
+matching the application's original API Level, and run it against the most
+current platform. </p>
+
+<h3>ADT Plugin for Eclipse</h3>
+
+<p>An updated version of the ADT Plugin for Eclipse is available with the
+Android 1.6 SDK. The new version, ADT 0.9.3, provides several new
+features, including integrated support for the Android SDK and AVD Manager
+and zipalign tool. In addition, the New Project Wizard now
+lets you create a test package containing tests for your application. These
+features are described in the sections below. </p>
+
+<p>If you are developing in Eclipse with ADT and want to get started with the
+Android 1.6 SDK, you should download and install a compatible version of the ADT
+Plugin (0.9.3 or higher). </p>
+
+<p>The new version of ADT is downloadable from the usual remote update site or
+is separately downloadable as a .zip archive. For instructions on how to
+download the plugin, please see <a
+href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin for Eclipse</a>. </p>
+
+<h3>Android SDK and AVD Manager</h3>
+
+<p>The SDK offers a new tool called Android SDK and AVD Manager that lets you
+manage your SDK and AVD environments more efficiently. </p>
+
+<p>Using the tool, you can quickly check what Android platforms, add-ons,
+extras, and documentation packages are available in your SDK environment, what
+their versions are, and whether updated versions are available. You can then
+download one or more items from remote repositories and install them directly in
+your SDK environment. For example, the tool lets you obtain updates to SDK tools
+incrementally, as they are made available, without having to wait for the next
+SDK release. You can also download Android platform versions into your
+environment that were not included in the SDK package.</p>
+
+<p>The tool also lets you quickly create new AVDs, manage
+their properties, and run a target AVD from a single window. </p>
+
+<p>If you are developing in Eclipse with ADT, you can access the Android SDK
+and AVD Manager from the <strong>Window</strong> menu. </p>
+
+<p>If you are developing in another IDE, you can access the Android SDK and
+AVD Manager through the <code>android</code> command-line tool, located in the
+<sdk>/tools directory. You can launch the tool with a graphical UI by
+using the <code>android</code> command without specifying any options. You can
+also simply double-click the android.bat (Windows) or android (OS X/Linux) file.
+You can still use <code>android</code> commands to create and manage AVDs,
+including AVDs with custom hardware configurations.</p>
+
+<h3>Integration with zipalign</h3>
+
+<p>The Android system offers a performance optimization for installed
+application packages whose contained uncompressed files are all aligned on
+4-byte boundaries. For these .apks, the system can read the files by mmap'ing
+the zip file, rather than by copying all the data out of them. This reduces
+the amount of memory used by the application at run time. The SDK includes
+a tool called <code>zipalign</code> that you can run against your .apks, to
+align them properly and enable them to benefit from this optimization.</p>
+
+<p>The ADT Plugin and the Ant build tools both provide integrated support for
+aligning your application packages. After you build an .apk, the SDK tools can
+sign and then run <code>zipalign</code> against it. The SDK includes the
+standalone version of the <code>zipalign</code> tool, so you can run also run it
+manually from the command line if you choose. </p>
+
+<ul>
+ <li>If you are developing in Eclipse with ADT, support for
+<code>zipalign</code> is integrated into the Export Wizard. When you use the
+Wizard to export a signed application package, ADT signs and then automatically
+runs <code>zipalign</code> against the exported package. If you use the Wizard
+to export an unsigned application package, then it will not zipalign the
+package because zipalign must be performed only after the APK has been signed.
+You must manually sign and zipalign the package after export. </li>
+ <li>If you are developing using Ant and are compiling in release mode, the
+build tools will automatically sign and then <code>zipalign</code> the
+application package, provided that you have specified the location of a valid
+keystore in the build properties file. If you are compiling in debug mode, the
+build tools will sign the package with the debug key and then <code>zipalign</code>
+it.</li>
+ <li>To use <code>zipalign</code> manually, change to the SDK tools directory
+and use the command syntax <code>$ zipalign 4 <infile>
+<outfile></code></li>
+</ul>
+
+<p>In general, note that you must <code>zipalign</code> an application only
+<em>after</em> it has been signed, as signing will disrupt the package
+alignment.</p>
+
+<h3>Support for Test Packages in New Project Wizard</h3>
+
+<p>The New Project Wizard available in the ADT 0.9.3 now lets you add a test
+package containing Instrumentation or other classes of tests while you are
+creating or importing a new Android application project. </p>
+
+<h3>New USB Driver for Windows</h3>
+
+<p>If you are using Windows and want to develop or test your application on an
+Android-powered device (such as the T-Mobile G1), you need an appropriate USB
+driver.
+
+<p>The Windows version of the Android 1.6 SDK includes a new, WinUSB-based
+driver that you can install. The driver is compatible with both 32- and 64-bit
+versions of Windows XP and Vista. The driver represents an upgrade from the USB
+driver included in previous Android SDKs, although installing the new driver is
+not required. </p>
+
+<p>If you installed the USB driver from a previous SDK release and it is working
+properly, you do not need to upgrade to the new driver. However, we recommend
+upgrading if you have had any problems with the older driver or simply want
+to upgrade to the latest version.</p>
+
+<p>For driver installation or
+upgrade instructions, see <a
+href="{@docRoot}sdk/win-usb.html">USB Driver for Windows</a>.</p>
+</p>
+
+<h3>Emulator Skins, Android 1.6 Platform</h3>
+
+<p>The Android 1.6 platform included in the SDK provides a new set of emulator
+skins, including: </p>
+
+<ul>
+ <li>QVGA — 240 x 320, low density (120 dpi)</li>
+ <li>HVGA — 320 x 480, medium density (160 dpi)</li>
+ <li>WVGA800 — 480 x 800, high density (240 dpi)</li>
+ <li>WVGA854 — 480 x 854, high density (240 dpi)</li>
+</ul>
+
+<p>Besides these defaults, You can also create an AVD that overrides the default
+density for each skin, to create any combination of resolution/density (WVGA
+with medium density, for instance). To do so, use the <code>android</code> tool
+command line to create a new AVD that uses a custom hardware configuration. See
+<a href="{@docRoot}tools/devices/managing-avds.html#createavd">Creating an
+AVD</a> for more information.</p>
+
+<h3>Other Notes and Resolved Issues</h3>
+
+<ul>
+ <li>This SDK release adds support for Eclipse 3.5 (Galileo) and deprecates
+support for Eclipse 3.3 (Europa). </li>
+ <li>We regret to inform developers that Android 1.6 will not include support
+for <a href="http://www.ietf.org/rfc/rfc2549">RFC 2549</a></li>
+ <li>The issue preventing adb from recognizing Samsung Galaxy devices (linux SDK
+only) has been fixed.</li>
+</ul>
+
+
+<h2 id="1.5_r3">Android 1.5 SDK, Release 3</h2>
+
+<p>Provides an updated Android 1.5 system image that includes permissions
+fixes, as described below, and a new application — an IME for Japanese
+text input. Also provides the same set of developer tools included in the
+previous SDK, but with bug fixes and several new features.</p>
+
+<h3>Permissions Fixes</h3>
+
+<p>The latest version of the Android platform, deployable to
+Android-powered devices, includes fixes to the permissions-checking
+in certain areas of the framework. Specifically, the Android system
+now properly checks and enforces several existing permissions where it
+did not do so in the previous release. Because of these changes in
+enforcement, you are strongly encouraged to test your application
+against the new Android 1.5 system image included in this SDK, to ensure
+that it functions normally. </p>
+
+<p>In particular, if your application uses any of the system areas listed below,
+you should add the required permissions to the application's manifest and then
+test the areas of your code that depend on the permission-protected services.
+Even if you believe your application does not use the permissions-protected
+services, you should compile and test your application under the latest platform
+version to ensure that users will not encounter problems when using your
+application. </p>
+
+<p>The changes to permissions are as follows:</p>
+
+<ul>
+<li>When an application requests access to device camera (through
+android.hardware.camera), the <code>CAMERA</code> permission check is now
+properly enforced. </li>
+<li>When an application requests access to device audio capture (through
+android.media.MediaRecorder), the <code>RECORD_AUDIO</code> permission check is
+now properly enforced.</li>
+</ul>
+
+<p>For more information, see the issue described in the oCert advisory
+below:</p>
+
+<p style="margin-left: 2em;"><a href="http://www.ocert.org/advisories/ocert-2009-011.html">http://www.ocert.org/advisories/ocert-2009-011.html</a> </p>
+
+<h3>Resolved Issues, Changes</h3>
+
+<ul>
+<li>The SDK includes a new version of the Google APIs add-on. The add-on
+provides an updated com.google.android.maps external library that fixes compile
+errors related to certain classes such as GeoPoint. For information about the
+Google APIs add-on and the library it provides, see:
+
+<p style="margin-left:2em;"><a
+href="http://code.google.com/android/add-ons/google-apis">http://code.google.com/android/add-ons/google-apis</a> </p></li>
+
+<li>The SDK add-on architecture now lets device manufacturers specify a USB
+Vendor ID in their add-ons.
+<li>The <code>android</code> tool provides a new command that scans SDK add-ons
+for their USB Vendor IDs and makes them available to adb (OS X and Linux
+versions of the SDK only). The command is <code>android update adb</code>. On
+Windows versions of the SDK, a custom USB driver is included that supports the
+"Google" and "HTC" Vendor IDs, which allow adb to recognize G1 and HTC
+Magic devices. For other devices, contact the device manufacturer
+to obtain a USB driver, especially if you have an SDK add-on that defines
+a new USB Vendor ID.</li>
+<li>The telephony, sensor, and geo fix issues in the emulator are now
+fixed.</li>
+<li>When you use adb to uninstall an upgraded application, the Android system
+now properly restores any permissions that had already been granted to the
+previous (downgrade) version of the application</li>
+</ul>
+
+<h2 id="1.5_r2">Android 1.5 SDK, Release 2</h2>
+
+<p>This SDK release provides the same developer tools as the Android 1.5 SDK,
+Release 1, but provides an updated Android 1.5 system image that includes a
+security patch for the issue described in the oCert advisory below:</p>
+
+<p style="margin-left:2em;"><a href="http://www.ocert.org/advisories/ocert-2009-006.html">http://www.ocert.org/advisories/ocert-2009-006.html</a></p>
+
+<h2 id="1.5_r1">Android 1.5 SDK, Release 1</h2>
+
+<p>This SDK provides updates to the development tools and Android system that
+you use to create applications for compliant Android-powered devices. </p>
+
+<h3>Release Overview</h3>
+
+<p>This SDK release includes many new features for developers. Highlights of the
+changes include: </p>
+
+ <ul>
+ <li>Multiple versions of the Android platform are included (Android 1.1,
+Android 1.5). The tools are updated to let you deploy your application
+on any platform in the SDK, which helps you ensure forward-compatibility and,
+if applicable, backward-compatibility.</li>
+ <li>Introduces <a href="{@docRoot}tools/devices/managing-avds.html">Android
+Virtual Devices</a> — (AVD) configurations of options that you
+run in the emulator to better model actual devices. Each AVD gets its
+own dedicated storage area, making it much easier to work with multiple emulators
+that are running concurrently.</li>
+ <li>Support for SDK add-ons, which extend the
+Android SDK to give you access to one or more external Android libraries and/or
+a customized (but compliant) system image that can run in the emulator. </li>
+ <li>The new Eclipse ADT plugin (version 0.9.x) offers new Wizards to let you
+create projects targeted for specific Android configurations, generate XML
+resources (such as layouts, animations, and menus), generate alternate layouts,
+and export and sign your application for publishing.</li>
+ <li>Improved JUnit support in ADT</li>
+ <li>Easier profiling of performance</li>
+ <li>Easier management of localized applications. You can now include or
+exclude locale resources when building your APK from a single
+Android project.</li>
+ <li>A new tool called "android" replaces the activitycreator script.</li>
+ </ul>
+
+<p>For details about the Android platforms included in the SDK — including
+bug fixes, features, and API changes — please read the <a
+href="{@docRoot}about/versions/android-1.5.html">Android 1.5 version notes</a>.</p>
+
+<h3>Installation and Upgrade Notes</h3>
+
+<p>If you've been developing an application using an Android 1.1 SDK, you need
+to make a few changes to your development environment to migrate to the new SDK.
+Tools and documentation are provided to assist you. No changes to the source
+code of an existing application should be needed, provided that your application
+is not using Android internal structures or APIs.</p>
+
+<p>To ensure that your existing application will work properly on a device
+running the latest version of the Android platform, you are strongly encouraged
+to migrate the application to the new SDK, compile it using the platform
+matching the application's original API Level, and run it against the most
+current platform. </p>
+
+<h3>SDK Add-Ons</h3>
+
+<p>This version of the SDK introduces support for SDK add-ons, which extend the
+Android SDK to give you access to one or more external Android libraries and/or
+a customized (but compliant) system image that can run in the emulator. The
+purpose of an SDK add-on is to give you a way to develop applications for a
+specific actual device (or family of devices) that extends the APIs available to
+Android applications through external libraries or system customizations. </p>
+
+<p>From the perspective of your Android development environment, an SDK add-on
+is similar to any of the Android platform targets included in the SDK — it
+includes an external library, a system image, as well as custom emulator skins
+and system properties. The add-on differs in that the Android platform it
+provides may include customized UI, resources, or behaviors, a different set of
+preinstalled applications, or other similar modifications.
+
+<p>The SDK includes a single SDK add-on — the Google APIs add-on. The
+Google APIs add-on gives your application access to the com.google.android.maps
+external library that is included on many (if not most) Android-powered devices.
+The Google APIs add-on also includes a {@link android.location.Geocoder Geocoder}
+backend service implementation. For more information, see the "Maps External
+Library" section below. </p>
+
+<h3>Android Virtual Devices (AVDs)</h3>
+
+<p>The SDK now gives you the capability to compile an application against any
+one of several system targets, then run it in the emulator on top of any
+compatible system image. There are two types of targets:</p>
+<ul>
+<li>Targets that represent core Android platform versions. </li>
+<li>Targets that are SDK add-ons, which typically provide application access to
+one or more external libraries and/or a customized (but compliant) system image
+that can run in the emulator.
+</ul>
+
+<p>A new tool called "android" lets you discover what targets and AVDs are
+available to use.</p>
+
+<p>For more information about AVDs, see <a
+href="{@docRoot}tools/devices/index.html">Creating and Managing Virtual Devices</a>
+
+<h3>Other Notes</h3>
+
+<p><strong>Maps External Library</strong></p>
+
+<p>In previous versions of the SDK, the com.google.android.maps package was
+included in the standard Android library and system image. In the Android 1.5
+SDK, that is not the case. The Android 1.5 library and system image do not
+include the Maps external library (com.google.android.maps). However, the Maps
+external library is available as part of the Google APIs add-on for the Android
+SDK, downloadable from this location: </p>
+
+<p style="margin-left:2em;"><a
+href="http://code.google.com/android/add-ons/google-apis">http://code.google.com
+/android/add-ons/google-apis</a> </p>
+
+<p>For your convenience, the Google APIs add-on is included in the SDK. </p>
+
+<p>For information about how to register for a Maps API Key, see
+<a href="http://code.google.com/android/add-ons/google-apis/mapkey.html">
+Obtaining a Maps API Key</a>.</p>
+
+<p><strong>USB Drivers for Windows</strong></p>
+
+<p>If you are using Windows and want to develop or test your application on an
+Android-powered device (such as the T-Mobile G1), you need an appropriate USB
+driver. For your convenience, the Windows version of the Android SDK includes
+these USB drivers that you can install, to let you develop on the device:</p>
+
+<ul>
+<li>USB driver for 32-bit XP and Vista</li>
+<li>USB driver for 64-bit Vista only</li>
+</ul>
+
+<p>For driver installation or
+upgrade instructions, see <a
+href="{@docRoot}sdk/win-usb.html">USB Driver for Windows</a>.</p>
+</p>
+
+<h3>Resolved Issues, Changes</h3>
+
+<p><strong>Media</strong></p>
+<ul>
+<li>Updated documentation for {@link android.media.SoundPool
+android.media.SoundPool}</li>
+<li>{@link android.webkit.WebView} objects no longer automatically save
+thumbnails. The {@link android.webkit.WebView#capturePicture() capturePicture()}
+method will need to be called manually.</li>
+</ul>
+
+<h3>Known Issues</h3>
+
+<p><strong>Sensor problems in Emulator</strong></p>
+
+<ul>
+<li>If your application uses the Sensor API and you are running it in the
+emulator on the Android 1.5 system image, you may experience problems. Your
+application may generate ANR messages or crash when using the sensors. The
+problem is being investigated.</li>
+</ul>
+
+<p><strong>Other</strong></p>
+
+<ul>
+<li>We regret to inform developers that Android 1.5 will not include support for
+the Zilog Z80 processor architecture.</li>
+</ul>
+
+
+<h2 id="1.1_r1">Android 1.1 SDK, Release 1</h2>
+
+<p>This SDK provides the development tools and Android system image you need to
+create applications for Android-powered devices. Applications developed on this
+SDK will be compatible with mobile devices running the Android 1.1 platform.
+</p>
+
+<p>This release provides an updated system image (Android 1.1), updated
+documentation, and the same set of development tools provided in the Android 1.0
+r2 SDK. The updated system image includes bug fixes and some smaller features,
+as well as a few minor API changes from the 1.0 version. </p>
+
+<p>For details about the Android 1.1 system image included in the SDK —
+including bug fixes, features, and API changes — please read the <a
+href="{@docRoot}about/versions/android-1.1.html">Android 1.1 version notes</a>.</p>
+
+<h3>App Versioning for Android 1.1</h3>
+
+<p>If you are using this SDK to build an application that is compatible
+<em>only</em> with Android-powered devices running the Android 1.1 platform,
+please note that you <strong>must</strong> set the the
+<code>android:minSdkVersion</code> attribute in the application's manifest to
+the API Level of Android 1.1 — "2".</p>
+
+<p>Specifically, you specify the <code>android:minSdkVersion</code> attribute in
+a <code><uses-sdk></code> element as a child of
+<code><manifest></code> in the manifest file. When set, the attribute
+looks like this: </p>
+
+<pre><code><manifest>
+ ...
+ <uses-sdk android:minSdkVersion="2" />
+ ...
+</manifest></code>
+</pre>
+
+<p>By setting <code>android:minSdkVersion</code> in this way, you ensure that
+users will only be able to install your application if their devices are running
+the Android 1.1 platform. In turn, this ensures that your application will
+function properly on their devices, especially if it uses APIs introduced in
+Android 1.1. </p>
+
+<p>If your application uses APIs introduced in Android 1.1 but does not declare
+<code><uses-sdk android:minSdkVersion="2" /></code>, then it will run properly on
+Android 1.1 devices but <em>not</em> on Android 1.0 devices. </p>
+
+<p>If your application does not use any new APIs introduced in Android 1.1, you
+can indicate Android 1.0 compatibility by removing <code>android:minSdkVersion</code> or
+setting the attribute to "1". However, before publishing your application, you
+must make sure to compile your application against the Android 1.0 system image
+(available in the Android 1.0 SDK), to ensure that it builds and functions
+properly for Android 1.0 devices. You should test the application against system
+images corresponding to the API Levels that the application is designed to be
+compatible with.</p>
+
+<p>If you are sure your application is not using Android 1.1 APIs and has no
+need to use them, you might find it easier to keep working in the Android 1.0
+SDK, rather than migrating to the Android 1.1 SDK and having to do additional
+testing.</p>
+
+
+<h3>ADT Plugin Compatibility</h3>
+
+<p>For this version of the SDK — Android 1.1 SDK, Release 1
+— the compatible version of the Android Development Tools (ADT)
+Plugin for Eclipse is <strong>0.8.0</strong>. If you are using a
+previous version of ADT, you should update to the latest version for use
+with this SDK. For information about how to update your ADT plugin, see
+<a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin for Eclipse</a>.</p>
+
+<h3>Installation and Upgrade Notes</h3>
+
+<p>If you've been developing an application using an Android 1.0 SDK no
+changes to your application are needed. You may want to wipe application
+user data (emulator option <code>-wipe-data</code>) when running your
+application on the Android 1.1 emulator for the first time.</p>
+
+<h3>Other Notes</h3>
+
+<p><strong>MapView API Key</strong></p>
+
+<p>com.google.android.maps.MapView is a class that lets you
+easily integrate Google Maps into your application. Before you can
+access the maps data, you will need to register with the Google Maps
+service and receive a Maps API Key, which you then add to your MapView
+for authentication to the server.</p>
+
+<p>Developers should note that the registration service for MapView is now
+active and Google Maps is actively enforcing the Maps API Key requirement.
+For information about how to register for a Maps API Key, see
+<a href="http://code.google.com/android/add-ons/google-apis/mapkey.html">
+Obtaining a Maps API Key</a>.</p>
+
+<p><strong>USB Drivers for Windows</strong></p>
+
+<p>If you using Windows and want to develop or test your application on an
+Android-powered device (such as the T-Mobile G1), you need an appropriate USB
+driver. For your convenience, the Windows version of the Android SDK includes
+these USB drivers that you can install, to let you develop on the device:</p>
+
+<ul>
+<li>USB driver for 32-bit XP and Vista</li>
+<li>USB driver for 64-bit Vista only</li>
+</ul>
+
+<p>The USB driver files are located in the
+<code><SDK>/usb_driver</code> directory. For details and
+installation instructions, see <a
+href="{@docRoot}tools/device.html#setting-up">Connecting Hardware Devices</a>.</p>
+</p>
+
+<h3>Resolved Issues, Changes</h3>
+
+<p><strong>Emulator</strong></p>
+<ul>
+<li>Emulator now saves the user image in <android>/SDK1.1/</code></li>
+</ul>
+
+<h3>Known Issues</h3>
+
+<p><strong>JUnit and Eclipse/ADT</strong></p>
+<ul>
+<li>If you are developing in Eclipse/ADT and want to add JUnit test
+classes, you can do so. However, you need to set up a custom JUnit configuration
+before your tests will run properly. For detailed information about how to set
+up the JUnit configuration, see the troubleshooting topic <a
+href="{@docRoot}resources/faq/troubleshooting.html#addjunit">Running a Junit test class
+in Eclipse</a>.</li>
+</ul>
+
+<p><strong>Other</strong></p>
+
+<ul>
+<li>It is not possible to send MMS messages between emulator instances. </li>
+<li>In some cases, you may encounter problems when using the browser on an
+emulator started with the command-line option <code>-http-proxy</code>. </li>
+<li>On the OSX platform, if you manually remove the ~/.android directory
+using <code>rm -rf ~/.android</code>, then try to run
+the emulator, it crashes. This happens because the emulator fails to create
+a new .android directory before attempting to create the child SDK1.0 directory.
+To work around this issue, manually create a new .android directory using
+<code>mkdir ~/.android</code>, then run the emulator. The emulator
+creates the SDK1.0 directory and starts normally. </li>
+<li>We regret to inform developers that Android 1.1 will not include support
+for ARCNet network interfaces.</li>
+<li>The final set of Intent patterns honored by Android 1.0 has not yet been
+fully documented. Documentation will be provided in future releases.</li>
+<li>In ADT Editor, you can add at most ten new resource values at a time,
+in a given res/values/*.xml, using the form in the Android Resources pane.
+If you add more than ten, the Android Resources pane will not display the
+attributes fields for the additional resource entries. To work around this
+problem, you can close the file in the editor and open it again, or you
+can edit the resource entries in the XML text mode. </li>
+<li>The emulator's battery-control commands (<code>power <option></code>)
+are not working in this release.</li>
+</ul>
+
+
+<h2 id="1.0_r2">Android 1.0 SDK, Release 2</h2>
+
+<p>This SDK release includes the Android 1.0 platform and application API.
+Applications developed on this SDK will be compatible with mobile devices
+running the Android 1.0 platform.</p>
+
+<p>This release includes mainly bug fixes, although some smaller features were
+added.</p>
+
+<h3>ADT Plugin Compatibility</h3>
+
+<p>For this release of the SDK, the compatible version of the Android
+Development Tools (ADT) Plugin for Eclipse is <strong>0.8.0</strong>. If you are
+using a previous version of ADT, you should update to the latest version for use
+with this SDK. For information about how to update your ADT plugin, see <a
+href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin for Eclipse</a>.</p>
+
+<h3>Other Notes</h3>
+
+<p><strong>T-Mobile G1 Compatibility</strong></p>
+
+<p>This version of the SDK has been tested for compatibility with the first
+Android-powered mobile device, the T-Mobile
+G1. </p>
+
+<p><strong>MapView API Key</strong></p>
+
+<p>MapView is a class that lets you easily integrate Google Maps into your
+application. Before you can access the maps data, you will need to register with
+the Google Maps service and receive a Maps API Key, which you then add to your
+MapView for authentication to the server.</p>
+
+<p>Developers should note that the registration service for MapView is now
+active and Google Maps is actively enforcing the Maps API Key requirement. For
+information about how to register for a Maps API Key, see <a
+href="http://code.google.com/android/add-ons/google-apis/mapkey.html">http://code.google.com/android/add-ons/google-apis/mapkey.html</a>.
+</p>
+
+<p><strong>USB Driver for Windows</strong></p>
+<p>If you using Windows and want to develop or test your application on an
+Android-powered device (such as the T-Mobile G1), you need an appropriate USB
+driver. For your convenience, the Windows version of the Android SDK includes a
+USB driver that you can install, to let you develop on the device. The USB
+driver files are located in the <code><SDK>/usb_driver</code> directory.
+
+</p>
+
+<h3>Resolved Issues, Changes</h3>
+<ul>
+<li>The android.jar in this SDK release now includes several classes that were
+missing from the previous SDK. </li>
+<li>The android.R.styleable class and its fields were removed from the public
+API, to better ensure forward-compatibility for applications. The constants
+declared in android.R.styleable were platform-specific and subject to arbitrary
+change across versions, so were not suitable for use by applications. You can
+still access the platform's styleable attributes from your resources or code. To
+do so, declare a custom resource element using a
+<code><declare-styleable></code> in your project's res/values/R.attrs
+file, then declare the attribute inside. For examples, see
+<sdk>/samples/ApiDemos/res/values/attrs.xml. For more information about
+custom resources, see <a
+href="{@docRoot}guide/topics/resources/available-resources.html#customresources">Custom
+Layout Resources</a>. Note that the android.R.styleable documentation is still
+provided in the SDK, but only as a reference of the platform's styleable
+attributes for the various elements.</li>
+<li>The VM now properly ensures that private classes are not
+available to applications through reflection. If you were using reflection
+to access private classes in a previous release, you will now get a run-time
+error. </li>
+
+<li>The Settings and Email applications are now included in the SDK and
+available in the emulator.</li>
+<li>We regret to inform developers that SDK 1.0_r2 does not support MFM, RLL,
+or Winchester hard disk drives.</li>
+<li>In the emulator, the control key for enabling/disabling trackball mode
+is changed from Control-T to F6. You can also enter trackball mode temporarily
+using the Delete key. While the key is pressed, you can send trackball events.</li>
+</ul>
+
+<p>Unless otherwise noted, Known Issues from the previous SDK release also apply
+to this release.</p>
+
+
+
+
+
+
+<h2 id="1.0_r1">Android 1.0 SDK, Release 1</h2>
+
+<p>This SDK release is the first to include the Android 1.0 platform and application API. Applications developed on this SDK will be compatible with mobile devices running the Android 1.0 platform, when such devices are available.</p>
+
+<p>This release includes mainly bug fixes, although some smaller features were added. The Android 1.0 also includes several API changes from the 0.9 version. For those porting from the M5 release, the SDK also includes the legacy changes overview and API Differences Reports. See the current Overview of Changes for more information. </p>
+
+<h3>ADT Plugin Compatibility</h3>
+
+<p>For this version of the SDK — Android 1.0 SDK, Release 1 — the compatible version of the Android Development Tools (ADT) Plugin for Eclipse is <strong>0.8.0</strong>. If you are using a previous version of ADT, you should update to the latest version for use with this SDK. For information about how to update your ADT plugin, see <a href="{@docRoot}sdk/1.0_r1/upgrading.html">Upgrading the SDK</a>.</p>
+
+<h3>Installation and Upgrade Notes</h3>
+
+<p>If you've been developing an application using a previous SDK version and you want the application to run on Android-powered mobile devices, you must port the application to the Android 1.0 SDK. Please see <a href="{@docRoot}sdk/1.0_r1/upgrading.html">Upgrading the SDK</a> for detailed instructions on how to make the transition to this release. Be sure to wipe application user data (emulator option <code>-wipe-data</code>) when running your application on the Android 1.0 SDK emulator.</p>
+
+<h3>Other Notes</h3>
+
+<p><strong>MapView API Key</strong></p>
+
+<p>MapView is a class that lets you easily integrate Google Maps into your application. Before you can access the maps data, you will need to register with the Google Maps service and receive a Maps API Key, which you then add to your MapView for authentication to the server.</p>
+
+<p>Currently, the registration service for MapView is not yet active and Google Maps is not yet enforcing the Maps API Key requirement. However, note that the registration service will be activated soon, so that MapViews in any application deployed to a mobile device will require registration and a valid Maps API Key. </p>
+
+<p>As soon as the registration service becomes available, we will update the page at <a href="http://code.google.com/android/add-ons/google-apis/mapkey.html">http://code.google.com/android/add-ons/google-apis/mapkey.html</a> with details about how and where to register. Please check that page periodically for registration information, if you are using a MapView.</p>
+
+
+<h3>Resolved Issues, Changes</h3>
+
+<p><strong>Emulator</strong></p>
+<ul>
+<li>Emulator now saves the user image in <android>/SDK1.0/</code></li>
+<li>Fixed EsounD-related freezes on Linux.</li>
+<li>Fixed the documentation in -help-audio. '-audio list' doesn't work, one
+ needs to call -help-audio-out and -help-audio-in to get the list of valid
+ audio backends.</li>
+<li>Fixed scrollwheel Dpad emulation in rotated mode. before that, using the
+ scroll-wheel would always generated Dpad Up/Down events, even when in
+ landscape mode.</li>
+
+<li>Several Obsolete command options were removed.</li>
+<li>Setting the network speed through the console or the -netspeed option will
+ properly modify the connectivity icon on the device.</li>
+<li>Setting the GSM voice registration state to 'roaming' in the console will
+ properly modify the voice icon on the device</li>
+</ul>
+
+<p><strong>SQLite</strong></p>
+<ul>
+<li>SQLite is now included in the SDK package on all platforms. </li>
+</ul>
+
+<p><strong>Other</strong></p>
+
+<ul>
+<li>It is not possible to send MMS messages between emulator instances. </li>
+<li>In some cases, you may encounter problems when using the browser on an
+emulator started with the command-line option <code>-http-proxy</code>. </li>
+
+<li>We regret to inform developers that Android 1.0 will not include support for
+dot-matrix printers.</li>
+<li>On the OSX platform, if you manually remove the ~/.android directory
+using <code>rm -rf ~/.android</code>, then try to run
+the emulator, it crashes. This happens because the emulator fails to create
+a new .android directory before attempting to create the child SDK1.0 directory.
+To work around this issue, manually create a new .android directory using
+<code>mkdir ~/.android</code>, then run the emulator. The emulator
+creates the SDK1.0 directory and starts normally. </li>
+<li>The final set of Intent patterns honored by Android 1.0 has not yet been
+fully documented. Documentation will be provided in future releases.</li>
+<li>In ADT Editor, you can add at most ten new resource values at a time,
+in a given res/values/*.xml, using the form in the Android Resources pane.
+If you add more than ten, the Android Resources pane will not display the
+attributes fields for the additional resource entries. To work around this
+problem, you can close the file in the editor and open it again, or you
+can edit the resource entries in the XML text mode. </li>
+<li>The emulator's battery-control commands (<code>power <option></code>)
+are not working in this release.</li>
+
+</ul>
+
diff --git a/docs/html/tools/sdk/addons.jd b/docs/html/tools/sdk/addons.jd
new file mode 100644
index 0000000..8c5e1ed
--- /dev/null
+++ b/docs/html/tools/sdk/addons.jd
@@ -0,0 +1,9 @@
+page.title=SDK Add-Ons
+
+@jd:body
+
+
+
+<p>A page that lists SDK addons and links to release notes. Links to dashboards etc.</p>
+
+
diff --git a/docs/html/tools/sdk/adt-notes.jd b/docs/html/tools/sdk/adt-notes.jd
new file mode 100644
index 0000000..291b543
--- /dev/null
+++ b/docs/html/tools/sdk/adt-notes.jd
@@ -0,0 +1,5 @@
+page.title=ADT Plugin for Eclipse
+sdk.redirect=true
+sdk.redirect.path=eclipse-adt.html
+
+@jd:body
diff --git a/docs/html/tools/sdk/adt_download.html b/docs/html/tools/sdk/adt_download.html
new file mode 100644
index 0000000..5ba2ef5
--- /dev/null
+++ b/docs/html/tools/sdk/adt_download.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0;url=http://developer.android.com/sdk/eclipse-adt.html">
+<title>Redirecting...</title>
+</head>
+<body>
+<p>You should be redirected. Please <a
+href="http://developer.android.com/sdk/eclipse-adt.html">click here</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/html/tools/sdk/download.jd b/docs/html/tools/sdk/download.jd
new file mode 100644
index 0000000..af25609
--- /dev/null
+++ b/docs/html/tools/sdk/download.jd
@@ -0,0 +1,93 @@
+page.title=Download an Archived Android SDK
+hide_license_footer=true
+
+@jd:body
+
+<script type="text/javascript">
+ function verify() {
+ document.getElementById('download-button').disabled =
+!document.getElementById('checkbox').checked;
+ }
+ function submit() {
+ var location = window.location.href;
+ if (location.indexOf('?v=') != -1) {
+ var filename = location.substring(location.indexOf('=')+1,location.length);
+ if (document.getElementById('checkbox').checked) {
+ document.location = "http://dl.google.com/android/" + filename;
+ }
+ document.getElementById('click-download').setAttribute("href", "http://dl.google.com/android/"
++ filename);
+ $("#terms-form").hide(500);
+ $("#next-steps").show(500);
+ document.getElementById('checkbox').disabled=true;
+ document.getElementById('download-button').disabled=true;
+ } else {
+ alert("You have not selected an SDK version. Please return to the SDK Archives page");
+ }
+ }
+</script>
+
+<div id="terms-form">
+ <p>Please carefully review the Android SDK License Agreement before downloading the SDK.
+The License Agreement constitutes a contract between you and Google with respect to your use of the
+SDK.</p>
+ <p class="note"><strong>Note:</strong> You must agree to this license agreement in order to
+download one of the archived SDKs, because these SDK packages contain Google software (whereas, the
+<a href="http://developer.android.com/sdk/index.html">current SDK</a> packages do not require a
+license agreement, because they contain only the open sourced SDK tools).</p>
+
+ <iframe id="terms" style="border:1px solid #888;margin:0 0 1em;height:400px;width:95%;"
+src="terms_body.html">
+ </iframe>
+
+ <p>
+ <input type="checkbox" id="checkbox" onclick="verify()" />
+ <label for="checkbox">I agree to the terms of the Android SDK License Agreement.</label>
+ </p>
+ <p>
+ <input type="submit" value="Download" id="download-button" disabled="disabled"
+onclick="submit()" />
+ </p>
+ <p>
+ <script language="javascript">
+ var loc = window.location.href;
+ if (loc.indexOf('?v=') != -1) {
+ var filename = loc.substring(loc.indexOf('=')+1,loc.length).replace(/</g,"<").replace(/>/g,">");
+ document.write("File: " + filename);
+ }
+ </script>
+ </p>
+</div><!-- end terms-form -->
+
+<noscript>
+ <p><strong>Please enable Javascript in your browser in order to agree to the terms and download
+the SDK.</strong></p>
+</noscript>
+
+<div class="special" id="next-steps" style="display:none">
+ <p>Your download should be underway. If not, <a id="click-download">click here to start the
+download</a>.</p>
+ <p>Beware that you've just downloaded a very old version of the Android SDK, which is not
+recommended. We no longer maintain documentation about how to install these archived SDKs nor
+support the tools contained within.</p>
+ <p>We recommend that you instead download the latest <a
+href="http://developer.android.com/sdk/index.html">Android SDK starter package</a>, which includes
+the latest SDK tools and allows you to develop against any version of the Android platform, back to
+Android 1.1.</p>
+</div>
+
+<script type="text/javascript">
+ var loc = window.location.href;
+ var filename = loc.substring(loc.indexOf('=')+1,loc.length);
+ version = filename.substring(filename.indexOf('.')-1,filename.lastIndexOf('.'));
+ $(".addVersionPath").each(function(i) {
+ var oldHref = $(this).attr("href");
+ $(this).attr({href: "/sdk/" + version + "/" + oldHref});
+ });
+</script>
+
+
+
+
+
+
diff --git a/docs/html/tools/sdk/eclipse-adt.jd b/docs/html/tools/sdk/eclipse-adt.jd
new file mode 100644
index 0000000..ac200b6
--- /dev/null
+++ b/docs/html/tools/sdk/eclipse-adt.jd
@@ -0,0 +1,1178 @@
+page.title=ADT Plugin
+
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}sdk/installing/installing-adt.html">Installing the Eclipse
+Plugin</a></li>
+ </ol>
+
+</div>
+</div>
+
+<p>Android Development Tools (ADT) is a plugin for the Eclipse IDE
+that is designed to give you a powerful, integrated environment in which
+to build Android applications.</p>
+
+<p>ADT extends the capabilities of Eclipse to let you quickly set up new Android
+projects, create an application UI, add packages based on the Android
+Framework API, debug your applications using the Android SDK tools, and even
+export signed (or unsigned) {@code .apk} files in order to distribute your application.</p>
+
+<p>Developing in Eclipse with ADT is highly recommended and is the fastest way
+to get started. With the guided project setup it provides, as well as tools
+integration, custom XML editors, and debug output pane, ADT gives you an
+incredible boost in developing Android applications. </p>
+
+<p>This document provides step-by-step instructions on how to download the ADT
+plugin and install it into your Eclipse development environment. Note that
+before you can install or use ADT, you must have compatible versions of both the
+Eclipse IDE and the Android SDK installed. For details, make sure to read <a
+href="#installing">Installing the ADT Plugin</a>, below. </p>
+
+<p>If you are already using ADT, this document also provides instructions on
+how to update ADT to the latest version or how to uninstall it, if necessary.
+</p>
+
+<p>For information about the features provided by the ADT plugin, such as code
+editor features, SDK tool integration, and the graphical layout editor (for drag-and-drop layout
+editing), see the <a href="{@docRoot}tools/help/adt.html">Android Developer Tools</a>
+document.</p>
+
+
+<h2 id="notes">Revisions</h2>
+
+<p>The sections below provide notes about successive releases of
+the ADT Plugin, as denoted by revision number. </p>
+
+<p>For a summary of all known issues in ADT, see <a
+href="http://tools.android.com/knownissues">http://tools.android.com/knownissues</a>.</p>
+
+<script type="text/javascript">
+function toggleDiv(link) {
+ var toggleable = $(link).parent();
+ if (toggleable.hasClass("closed")) {
+ //$(".toggleme", toggleable).slideDown("fast");
+ toggleable.removeClass("closed");
+ toggleable.addClass("open");
+ $(".toggle-img", toggleable).attr("title", "hide").attr("src", (toRoot + "assets/images/triangle-opened.png"));
+ } else {
+ //$(".toggleme", toggleable).slideUp("fast");
+ toggleable.removeClass("open");
+ toggleable.addClass("closed");
+ $(".toggle-img", toggleable).attr("title", "show").attr("src", (toRoot + "assets/images/triangle-closed.png"));
+ }
+ return false;
+}
+</script>
+
+<style>
+.toggleable {
+padding: 5px 0 0;
+}
+.toggleme {
+ padding: 10px 0 0 20px;
+}
+.toggleable a {
+ text-decoration:none;
+}
+.toggleme a {
+ text-decoration:underline;
+}
+.toggleable.closed .toggleme {
+ display:none;
+}
+#jd-content .toggle-img {
+ margin:0 5px 3px 0;
+}
+</style>
+
+
+<div class="toggleable opened">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 18.0.0</a> <em>(April 2012)</em>
+ <div class="toggleme">
+<dl>
+ <dt>Dependencies:</dt>
+
+ <dd>
+ <ul>
+ <li>Java 1.6 or higher is required for ADT 18.0.0.</li>
+ <li>Eclipse Helios (Version 3.6.2) or higher is required for ADT 18.0.0.</li>
+ <li>ADT 18.0.0 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools
+ r18</a>. If you haven't already installed SDK Tools r18 into your SDK, use the Android SDK
+ Manager to do so.</li>
+ </ul>
+ </dd>
+
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed problem where exporting release package does not recompile libraries in release
+ mode.
+ (<a href="http://code.google.com/p/android/issues/detail?id=27940">Issue 27940</a>)</li>
+ </ul>
+ </dd>
+
+</dl>
+
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 17.0.0</a> <em>(March 2012)</em>
+ <div class="toggleme">
+<dl>
+ <dt>Dependencies:</dt>
+
+ <dd>
+ <ul>
+ <li>Java 1.6 or higher is required for ADT 17.0.0.</li>
+ <li>Eclipse Helios (Version 3.6.2) or higher is required for ADT 17.0.0.</li>
+ <li>ADT 17.0.0 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools
+ r17</a>. If you haven't already installed SDK Tools r17 into your SDK, use the Android SDK
+ Manager to do so.</li>
+ </ul>
+ </dd>
+
+ <dt>General improvements:</dt>
+ <dd>
+ <ul>
+ <li>New build features
+ <ul>
+ <li>Added feature to automatically setup JAR dependencies. Any {@code .jar} files in the
+ {@code /libs} folder are added to the build configuration (similar to how the Ant build
+ system works). Also, {@code .jar} files needed by library projects are also automatically
+ added to projects that depend on those library projects.
+ (<a href="http://tools.android.com/recent/dealingwithdependenciesinandroidprojects">more
+ info</a>)</li>
+ <li>Added a feature that allows you to run some code only in debug mode. Builds now
+generate a class called {@code BuildConfig} containing a {@code DEBUG} constant that is
+automatically set according to your build type. You can check the ({@code BuildConfig.DEBUG})
+constant in your code to run debug-only functions.</li>
+ <li>Added support for custom views with custom attributes in libraries. Layouts using
+custom attributes must use the namespace URI {@code http://schemas.android.com/apk/res-auto} instead
+of the URI that includes the app package name. This URI is replaced with the app specific one at
+build time.</li>
+ </ul>
+ </li>
+ <li>Improved Lint features. See the <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r17</a>
+release notes.</li>
+ <li>Improved the Lint user interface
+ <ul>
+ <li>Added <strong>Run Lint</strong> toolbar action with a dropdown menu for selecting
+specific (or all) projects, clearing results and other actions.</li>
+ <li>Updated the results window to be organized as a tree rather than a flat list. Each
+issue type has a single top level item, which makes it easier to quickly scan through the reported
+issues and narrow down to the issues you are most interested in.</li>
+ <li>Added many new toolbar actions to the results window, including expand/collapse,
+ignore in file, ignore in project, ignore everywhere, show options, and configure columns.</li>
+ <li>Added new column options for the <strong>Lint Warnings</strong> tab, such as
+category, priority, project, file and line. The column selection (as well as the column sizes) are
+persisted. You can also click on columns to sort by those values.</li>
+ <li>Added Enable All and Disable All buttons to the Lint Options dialog, and a search
+filter textbox to filter by issue id, summary and severity.</li>
+ </ul>
+ </li>
+ <li>Added Quick Outline for XML editors (Ctrl-O, Command-O). This feature shows the structure
+of the current file including icons and ids, lets you filter and quickly jump to specific ids.</li>
+ <li>Updated the resource chooser to shows the resolved value for resources. For example,
+when selecting {@code @string/hello} the chooser displays a resolved value such as "Hello World").
+The resource chooser also now allows you to edit the chosen value directly.</li>
+ <li>Updated Layout Editor so that it does not assign default ids to layouts, includes and
+merge tags. This behavior tended to pollute the namespace with a lot of unused resources since
+layouts are not usually manipulated via code, or referenced from XML. (The RelativeLayout editor
+automatically assigns ids to views without ids when pointing to them.)</li>
+ <li>Added ability to export screenshots from the Layout Editor</li>
+ </ul>
+ </dd>
+
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed problem using Layout Editor with {@link android.widget.SlidingDrawer} which could
+ not be dragged into the layout on some platforms.</li>
+ <li>Fixed preview rendering for {@link android.widget.SlidingDrawer} and
+ {@link android.widget.TabHost}.
+ (<a href="http://code.google.com/p/android/issues/detail?id=23022">Issue 23022</a>).</li>
+ <li>Fixed issues that could prevent layout rendering due to unresolvable resources.
+ (<a href="http://code.google.com/p/android/issues/detail?id=21046">Issue 21046</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=21051">Issue 21051</a>)</li>
+ <li>Fixed a bug in resource chooser which made some types of framework resources impossible to
+select. (<a href="http://code.google.com/p/android/issues/detail?id=20589">Issue 20589</a>)</li>
+ <li>Fixed a bug in the formatter where a certain whitespace pattern could result in a
+ non-space character getting deleted.
+ (<a href="http://code.google.com/p/android/issues/detail?id=23940">Issue 23940</a>)</li>
+ <li>Fixed a locale bug affecting Turkish locales in particular.
+ (<a href="http://code.google.com/p/android/issues/detail?id=23747">Issue 23747</a>)</li>
+ <li>Fixed issue where dex complains about duplicate classes in cases where a Library
+ Project depends on the same jar files or Java-only projects.</li>
+ <li>Fixed issue where test projects had to independently reference the library projects used
+ by an app project. Now referencing only the app project is enough.</li>
+ </ul>
+ </dd>
+
+</dl>
+
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 16.0.1</a> <em>(December 2011)</em>
+ <div class="toggleme">
+<dl>
+ <dt>Dependencies:</dt>
+
+ <dd>
+ <ul>
+ <li>Eclipse Helios (Version 3.6) or higher is required for ADT 16.0.1.</li>
+ <li>ADT 16.0.1 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools
+ r16</a>. If you haven't already installed SDK Tools r16 into your SDK, use the Android SDK
+ Manager to do so.</li>
+ </ul>
+ </dd>
+
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed build issue where the 9-patch could be packaged as normal bitmap in some cases.</li>
+ <li>Fixed minor issues in the <a href="http://tools.android.com/recent/lint">Lint</a>
+ tool.</li>
+ <li>Fixed minor issues in the SDK Manager.</li>
+ </ul>
+ </dd>
+</dl>
+
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 16.0.0</a> <em>(December 2011)</em>
+ <div class="toggleme">
+<dl>
+ <dt>Dependencies:</dt>
+
+ <dd>
+ <ul>
+ <li>Eclipse Helios (Version 3.6) or higher is required for ADT
+16.0.0.</li>
+ <li>ADT 16.0.0 is designed for use with <a
+href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r16</a>. If you haven't already installed SDK Tools
+r16 into your SDK, use the Android SDK Manager to do so.</li>
+ </ul>
+ </dd>
+
+ <dt>General improvements:</dt>
+ <dd>
+ <ul>
+ <li>Added Lint tool to detect common errors in Android projects. (<a
+href="http://tools.android.com/recent/lint">more info</a>)</li>
+ </ul>
+ </dd>
+</dl>
+
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 15.0.1</a> <em>(November 2011)</em>
+ <div class="toggleme">
+<dl>
+ <dt>Dependencies:</dt>
+
+ <dd>ADT 15.0.1 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r15</a>.
+ If you haven't already installed SDK Tools r15 into your SDK, use the Android SDK Manager to
+ do so.</dd>
+
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed how source files are attached to library project <code>.jar</code> files.</li>
+ <li>Fixed how the <code>bin/</code> folder for library projects are refreshed. This ensures that parent projects pick up changes in library projects.</li>
+ <li>Fixed how a parent project's library container is updated when a library project is recompiled. This ensures that parent projects are
+ recompiled when code in a library project changes.</li>
+ <li>Fixed how <code>res/</code> folders are checked in library projects. This ensures that all <code>res</code> folders are properly included
+ even if Eclipse is not aware of them due to refresh issues.</li>
+ <li>Fixed issue that prevented <code>aapt</code> from running when editing certain XML files.</li>
+ <li>Fixed minor XML formatting issues.</li>
+ </ul>
+ </dd>
+</dl>
+
+</div>
+</div>
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 15.0.0</a> <em>(October 2011)</em>
+ <div class="toggleme">
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 15.0.0 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r15</a>.
+If you haven't already installed SDK Tools r15 into your SDK, use the Android SDK Manager to
+do so.</dd>
+
+<dt>Bug fixes:</dt>
+<dd>
+<ul>
+ <li>Fixed build issue when using Renderscript in projects that target API levels 11-13
+ (<a href="http://code.google.com/p/android/issues/detail?id=21006">Issue 21006</a>).</li>
+ <li>Fixed issue when creating projects from existing source code.</li>
+ <li>Fixed issues in the SDK Manager
+ (<a href="http://code.google.com/p/android/issues/detail?id=20939">Issue 20939</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=20607">Issue 20607</a>).</li>
+ <li>Fixed scrolling issue in the new Logcat panel of DDMS.</li>
+</ul>
+</dd>
+</dl>
+
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 14.0.0</a> <em>(October 2011)</em>
+ <div class="toggleme">
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 14.0.0 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r14</a>.
+If you haven't already installed SDK Tools r14 into your SDK, use the Android SDK Manager to
+do so.</dd>
+
+<dt>Build system:</dt>
+<dd>
+ <ul>
+ <li>Changed <code>default.properties</code> to <code>project.properties</code> and
+ <code>build.properties</code> to <code>ant.properties</code>. ADT automatically
+ renames these files, if necessary, when you open a project in Eclipse.</li>
+ <li>Changed how library projects are built in Eclipse.</a></li>
+ <li>Changed output of <code>javac</code> from <code>bin/</code> to <code>bin/classes</code>
+ in Eclipse.</li>
+ <li>Improved incremental builds so that resource compilation runs less frequently. Builds no
+ longer run when you edit strings or layouts (unless you add a new <code>id</code>) and no longer
+ run once for each library project.</li>
+ <li>Introduced a "PNG crunch cache" that only runs on modified PNG files, instead of
+ crunching all existing PNG files, all the time.</li>
+ <li>Modified resource compilation so it no longer happens for normal save operations. It only
+ happens when running or debugging (the build option that lets you disable the packaging
+ step, which was introduced in ADT 12, is now on by default.)</li>
+ </ul>
+<p>For a complete overview of the build system changes and what you need to do to support them,
+see the <a href="http://tools.android.com/recent/buildchangesinrevision14">Android Tools Project
+site</a>.</p>
+</dd>
+
+<dt>General improvements:</dt>
+<dd>
+ <ul>
+
+
+<li>Added a Welcome Wizard to help with the initial setup of the Android
+development environment (<a href="http://tools.android.com/recent/welcomewizard">more
+info</a>).</li>
+<li>Integrated the Android Asset Studio, which helps you create icons for things
+like the launcher, menus, and tabs. (<a
+href="http://tools.android.com/recent/assetstudiointegration">more
+info</a>).</li>
+<li>Revamped the Logcat view and added support to display and filter logs by
+ application names as well as PIDs (<a
+ href="http://tools.android.com/recent/updatedlogcatviewer">more info</a>).</li>
+<li>Revamped the SDK Manager UI (<a href="http://tools.android.com/recent/newsdkmanager">more
+info</a>).</li>
+<li>Revamped the New Project and the New XML File wizards to have
+multiple pages. Sample projects are now copied into the workspace such that they can be modified
+and deleted without affecting the master copy
+(<a href="http://tools.android.com/recent/revampedwizards">more info</a>).</li>
+<li>Removed the dependency on Eclipse GEF.</li>
+</ul>
+</dd>
+
+<dt>XML and Java editors:</dt>
+<dd>
+ <ul>
+ <li>Added a new XML formatter that formats all XML files according to the
+ standard Android coding style. The formatter can also reorder
+ attributes to follow a recommended order and processes any changes made in the Layout editor.
+(<a href="http://tools.android.com/recent/xmlformatter">more info</a>).</li>
+ <li>Added the "Go to Matching" (Ctrl-Shift-P) feature, which lets you jump
+between opening and closing tags in XML files.</li>
+ <li>Added support for the "Select Enclosing Element" feature on Mac.</li>
+ <li>Added a Quickfix for extracting Strings when the caret is inside a String (<a href="">see
+more</a>).</li>
+ <li>Improved "smart indent", which allows automatic indentation and un-indentation
+ when pressing the Return key in XML editors (<a
+href="http://tools.android.com/recent/xmleditingimprovements">more info</a>).</li>
+
+ </ul>
+</dd>
+
+<dt>Layout editor:</dt>
+<dd>
+ <ul>
+ <li>Added tooltip feedback for dragging and resizing operations. For
+ example, when dragging in a relative layout, the proposed
+ constraints are shown. When resizing, the new dimensions are
+ shown (<a href="http://tools.android.com/recent/layouteditorfeedbacktooltips">more
+info</a>).</li>
+ <li>Added the ability to suppress rendering fidelity warnings (<a
+href="http://tools.android.com/recent/suppressrenderwarnings">more info</a>).</li>
+ <li>Added "Remove Container" visual refactoring that removes the
+ children of a container up to the top level and transfers
+ namespace and layout attributes if necessary (<a
+href="http://tools.android.com/recent/removecontainervisualrefactoring">more info</a>).</li>
+ <li>Added pull-right menus to the context menu for accessing
+ properties of the parents, which is useful when the children fully
+ cover the parent and make it hard to select on their own.</li>
+ <li>Improved access to properties in the context menu. The most
+ frequently set attributes for each view are listed at the top of
+ the menu. The Properties menu offers access to the most
+ recently set attributes, attributes organized by their defining
+ view, and layout attributes only or all attributes alphabetically (<a
+href="http://tools.android.com/recent/layouteditorcontextmenuimprovements">more info</a>).</li>
+ </ul>
+</dd>
+
+<dt>Bug fixes:</dt>
+<dd>Fixed many bugs and added <a
+href="http://tools.android.com/recent/miscellaneousrecentfixes">minor improvements</a>, in
+particular some <a href="http://tools.android.com/recent/linuxfixes">critical bug fixes on
+Linux</a>.</dd>
+
+</div>
+</div>
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 12.0.0</a> <em>(July 2011)</em>
+ <div class="toggleme">
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 12.0.0 is designed for use with <a href="{@docRoot}tools/sdk/tools-notes.html">SDK Tools r12</a>. If you haven't
+already installed SDK Tools r12 into your SDK, use
+the Android SDK Manager to do so.</dd>
+
+<dt>Visual Layout Editor:</dt>
+<dd>
+<ul>
+ <li>New RelativeLayout drop support with guideline suggestions for
+ attachments and cycle prevention
+ (<a href="http://tools.android.com/recent/revampedrelativelayoutsupport">more info</a>).</li>
+ <li>Resize support in most layouts along with
+ guideline snapping to the sizes dictated by <code>wrap_content</code> and <code>match_parent</code>.
+ In LinearLayout, sizes are mapped to weights instead of pixel widths.
+ (<a href="http://tools.android.com/recent/resizesupport">more info</a>).</li>
+ <li>Previews of drawables and colors in the resource chooser dialogs
+ (<a href="http://tools.android.com/recent/imageandcolorpreviews">more info</a>).</li>
+ <li>Improved error messages and links for rendering errors including
+ detection of misspelled class names
+ (<a href="http://tools.android.com/recent/improvedrenderingerrordiagnostics">more info</a>).</li>
+</ul>
+</dd>
+
+<dt>Build system:</dt>
+<dd>
+<ul>
+ <li id="build-option">A new option lets you disable the packaging step in the automatic
+ builders. This improves performance when saving files by not
+ performing a full build, which can take a long time for large projects.
+ If the option is enabled, the APK is packaged when the
+ application is deployed to a device or emulator or when the
+ release APK is exported (<a href="http://tools.android.com/recent/finercontroloveradtbuildprocess">more info</a>).</li>
+</ul>
+</dd>
+
+<dt>Bug fixes:</dt>
+<dd>Many bug fixes are part of this release
+(<a href="http://tools.android.com/recent/adt12bugfixroundup">more info</a>).</dd>
+
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 11.0.0</a> <em>(June 2011)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 11.0.0 is designed for use with SDK Tools r11. If you haven't
+already installed SDK Tools r11 into your SDK, use the Android SDK Manager to do
+so.</dd>
+
+<dt>Visual Refactoring:</dt>
+<dd>
+ <ul>
+ <li>"Extract Style" feature pulls out style-related attributes from your layout and extracts
+them as a new style defined in {@code styles.xml} (<a
+href="http://tools.android.com/recent/extractstylerefactoring">more info</a>).</li>
+ <li>"Wrap in Container" feature lets you select a group of views then surround them
+ in a new layout (a new view group, such as a LinearLayout), and transfers namespace and layout
+ parameters to the new parent (<a
+href="http://tools.android.com/recent/newrefactoringswrapinchangelayoutchangewidget">more
+info</a>).</li>
+ <li>"Change Layout" feature changes layouts from one type
+ to another, and can also flatten a layout hierarchy (<a
+href="http://tools.android.com/recent/newrefactoringswrapinchangelayoutchangewidget">more
+info</a>).</li>
+ <li>"Change Widget Type" feature changes the type of the
+ selected views to a new type. Also, a new selection context menu
+ in the visual layout editor makes it easy to select siblings as
+ well as views anywhere in the layout that have the same type (<a
+href="http://tools.android.com/recent/newrefactoringswrapinchangelayoutchangewidget">more
+info</a>).</li>
+ <li>"Extract as Include" feature finds identical collections of views
+ in other layouts and offers to combine them into a single layout that you can then include in
+ each layout (<a
+href="http://tools.android.com/recent/extractasincludeimprovements">more info</a>).</li>
+ <li>Quick Assistant in Eclipse can be invoked
+ from the XML editor (with Ctrl-1) to apply any of the above
+ refactorings (and Extract String) to the current selection (<a
+href="http://tools.android.com/recent/refactoringquickassistant">more info</a>).</li>
+ </ul>
+</dd>
+
+<dt>Visual Layout Editor:</dt>
+<dd>
+ <ul>
+ <li>This is the update to the layout editor you've been waiting for! It includes (almost) all
+the goodies demonstrated at Google I/O. <a href="http://www.youtube.com/watch?v=Oq05KqjXTvs">Watch
+the video</a> on YouTube.</li>
+ <li>The palette now supports different configurations for supported widgets. That is, a single
+view is presented in various different configurations that you can drag into your layout. For
+example, there is a <em>Text Fields</em> palette category where you can drag an {@link
+android.widget.EditText} widget in as a password field, an e-mail field, a phone field, or other
+types of text boxes. Similarly, {@link android.widget.TextView} widgets are preconfigured
+with large, normal and small theme sizes, and {@link android.widget.LinearLayout} elements are
+preconfigured in horizontal and vertical configurations (<a
+href="http://tools.android.com/recent/multipletextfieldandlayouttypes">more info</a>).</li>
+ <li>The palette supports custom views. You can pick up any custom
+ implementations of the View class you've created in your project or from included libraries and
+drag them into your layout (<a
+href="http://tools.android.com/recent/customviewsinthepalette">more info</a>).</li>
+ <li>Fragments are available in the palette for placement in your layout. In the tool, you can
+choose which layout to show rendered for a given fragment tag. Go to declaration works for fragment
+classes (<a href="http://tools.android.com/recent/fragmentsupport">more info</a>).</li>
+ <li>The layout editor automatically applies a "zoom to fit" for newly
+ opened files as well as on device size and orientation changes to
+ ensure that large layouts are always fully visible unless you
+ manually zoom in.</li>
+ <li>You can drop in an {@code <include>} element from the palette, which will pop up
+ a layout chooser. When you select the layout to include, it is added with an {@code
+<include>}. Similarly, dropping images or image buttons will pop up image
+ resource choosers (<a
+href="http://tools.android.com/recent/includetagdropsupport">more info</a>).</li>
+ <li>The configuration chooser now applies the "Render Target" and
+ "Locale" settings project wide, making it trivial to check the
+ layouts for different languages or render targets without having
+ to configure these individually for each layout.</li>
+ <li>The layout editor is smarter about picking a default theme to
+ render a layout with, consulting factors like theme registrations
+ in the manifest, the SDK version, and other factors.</li>
+ <li>The layout editor is smarter about picking a default configuration to render a layout
+with, defaulting to the currently visible configuration in the previous file. It also considers the
+SDK target to determine whether to default to a tablet or phone screen size.</li>
+ <li>Basic focus support. The first text field dropped in a layout is assigned focus, and there
+are <strong>Request Focus</strong> and <strong>Clear Focus</strong> context menu items on text
+fields to change the focus.</li>
+ </ul>
+</dd>
+
+<dt>XML editors:</dt>
+<dd>
+<ul>
+ <li>Code completion has been significantly improved. It now works
+ with {@code <style>} elements, completes dimensional units,
+ sorts resource paths in values based on the attribute name, and more. There are also many fixes to
+handle text replacement (<a
+href="http://tools.android.com/recent/xmlcodecompletionimprovements">more info</a>).</li>
+ <li>AAPT errors are handled better. They are now underlined for the
+ relevant range in the editor, and a new quickfix makes it trivial
+ to create missing resources.</li>
+ <li>Code completion for drawable, animation and color XML files (<a
+href="http://tools.android.com/recent/codecompletionfordrawablescolorsandanimationfiles">more
+info</a>).</li>
+</ul>
+</dd>
+
+<dt>DDMS:</dt>
+<dd>
+<ul>
+ <li>"New Folder" action in the File Explorer.</li>
+ <li>The screenshot dialog will add timestamps to the filenames and preserve the orientation on
+snapshot refresh.</li>
+</ul>
+</dd>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>TraceView supports zooming with the mouse-wheel in the timeline.</li>
+ <li>The New Android Project wizard now supports Eclipse working sets.</li>
+ </ul>
+</dd>
+</dl>
+<p>More information about tool changes are available on the <a
+href="http://tools.android.com/recent">Android Tools Project Site</a>.</p>
+</div>
+</div>
+
+
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 10.0.1</a> <em>(March 2011)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 10.0.1 is designed for use with SDK Tools r10. If you haven't
+already installed SDK Tools r10 into your SDK, use the Android SDK Manager to do
+so.</dd>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>Temporary work-around to resolve the rare cases in which the layout editor will
+not open.</li>
+ <li>Fix issue in which ADT 10.0.0 would install on Eclipse 3.4 and lower, even though ADT
+requires Eclipse 3.5 or higher (as of 10.0.0).</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 10.0.0</a> <em>(February 2011)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 10.0.0 is designed for use with SDK Tools r10. If you haven't
+already installed SDK Tools r10 into your SDK, use the Android SDK Manager to do
+so.</dd>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>The tools now automatically generate Java Programming Language source files (in the <code>gen/</code> directory) and
+ bytecode (in the <code>res/raw/</code> directory) from your <code>.rs</code> files.</li>
+ <li>A Binary XML editor has been added (<a href="http://tools.android.com/recent/binaryxmleditor">details</a>).</li>
+ <li>Traceview is now integrated into the Eclipse UI (<a href="http://tools.android.com/recent/traceviewineclipse">details</a>).</li>
+ <li>The "Go To Declaration" feature for XML and <code>.java</code> files quickly show all the matches in the project
+ and allows you jump to specific items such as string translations or <code>onClick</code> handlers
+ (<a href="http://tools.android.com/recent/gotodeclarationimprovements">details</a>).</li>
+ <li>The Resource Chooser can create items such as dimensions, integers, ids, and booleans
+ (<a href="http://tools.android.com/recent/resourcechoosercannowcreatearbitraryvalues">details</a>).</li>
+ <li>Improvements to the Visual Layout Editor:
+ <ul>
+ <li>A new Palette with categories and rendering previews
+ (<a href="http://tools.android.com/recent/newpalette">details</a>).</li>
+ <li>A Layout Actions bar that provides quick access to common layout operations
+ (<a href="http://tools.android.com/recent/layoutactionsbar">details</a>).</li>
+ <li>When the Android 3.0 rendering library is selected, layouts render more like they do on devices.
+ This includes rendering of status and title bars to more accurately reflect the actual
+ screen space available to applications
+ (<a href="http://tools.android.com/recent/systembarandactionbar">details</a>).</li>
+ <li>Zoom improvements such as fit to view, persistent scale, and keyboard access.
+ (<a href="http://tools.android.com/recent/zoomimprovements">details</a>).</li>
+ <li>Further improvements to <code><merge></code> layouts, as well as layouts with gesture overlays
+ (<a href="http://tools.android.com/recent/improvedsupportformergetags">details</a>).</li>
+ <li>Improved rendering error diagnostics.</li>
+ </ul>
+ </li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 9.0.0</a> <em>(January 2011)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd>ADT 9.0.0 is designed for use with SDK Tools r9. If you haven't
+already installed SDK Tools r9 into your SDK, use the Android SDK Manager to do
+so.</dd>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>"Go To Declaration" hyperlink support: You can jump directly from code references (such as
+ <code>R.id.main</code>) to the corresponding XML declaration, or from XML attributes (such as
+ <code>@string</code>) to the corresponding resource definition, or from manifest XML
+ registrations to activities and services.</li>
+ <li>Improvements were made to name refactoring.</li>
+ <li>AVDs now automatically save their state, so they can restart almost instantly. You can enable this feature when
+ creating an AVD or by editing an AVD with the AVD Manager.</li>
+ <li>Improvements to the Visual Layout Editor:
+ <ul>
+ <li>Support for rendering targets: You can now choose an arbitrary Android platform to
+ render the current page, regardless of the project's minimum platform. This makes it
+ easy to verify the layout and appearance of your activity on different versions of
+ the platform.
+ </li>
+ <li>Improved support for empty and nested layouts: Dragging items over nested and
+ invisible layouts automatically enlarges and highlights these layouts, so that they
+ can receive drops.
+ </li>
+ <li>XML formatting improvements: The editor generates cleaner XML and you can now enable
+ XML auto-formatting in the <strong>Preferences</strong> menu.</li>
+ <li>Improved Outline labels: The Outline tab now displays additional information about each
+ View. Textual Views display a snippet of the actual text. Views with a source
+ (such as ImageView) displays the resource name. Included Views display the name of the View.
+ </li>
+ <li>When you right click a View in the Layout Editor,
+ the context menu now contains <strong>Edit ID...</strong> and <strong>Edit Text...</strong>
+ items. The <strong>Properties...</strong> context menus now list all of the properties and
+ provide a way to edit them
+ (<a href="http://tools.android.com/recent/editidtextandotherpropertiesviamenu">Details</a>).
+ </li>
+ <li>The layout editor now properly handles
+ <a href="{@docRoot}guide/topics/resources/layout-resource.html#include-element"><code><include></code></a>
+ and <a href="{@docRoot}guide/topics/resources/layout-resource.html#merge-element"><code><merge></code></a>
+ tags (<a href="http://tools.android.com/recent/supportforincludeandmerge">Details</a>).</li>
+ <li>"Extract as Include" refactoring: The Layout Editor has a new refactoring that allows
+ you to select one or more views in a layout, and extract it into a separate layout
+ (<a href="http://tools.android.com/recent/extractasincluderefactoring">Details</a>).</li>
+ <li>Improved diagnostics for class loading and rendering errors: Class loading and rendering
+ error messages are more useful and provide better information about the root cause of the
+ error.</li>
+ <li>Improved error handling to prevent drag and reordering operations from adding children
+ into an {@link android.widget.AdapterView}.</li>
+ <li>Outline reordering: Reordering your views in the Outline tab is much easier
+ (<a href="http://tools.android.com/recent/outlineimprovements">Details</a>).</li>
+ <li>Fix for keybinding bug where keyboard shortcuts did not work (Issues
+ <a href="http://code.google.com/p/android/issues/detail?id=13231">13231</a> and
+ <a href="http://code.google.com/p/android/issues/detail?id=13134">13134</a>).</li>
+ <li>Fix for problems with Custom layout attribute menu (Issue
+ <a href="http://code.google.com/p/android/issues/detail?id=13134">13134</a>).</li>
+ <li>Automatic configuration for various view types: Certain views have properties configured
+ by default. For example, the width of an {@link android.widget.EditText} object is set to
+ <code>match_parent</code> when added to a vertical {@link android.widget.LinearLayout}
+ or a default image is added to an {@link android.widget.ImageButton}.</li>
+ <li>Previews during dragging: Dragging from the palette or dragging within the layout editor
+ now shows live previews of the dragged item.</li>
+ <li>Navigation improvements: In the Layout Editor, double-clicking Views jumps to the
+ corresponding XML element. In the Outline view, double-clicking opens the Properties view.</li>
+ <li>The editor has Honeycomb style animation preview support.</li>
+ <li>Improved rendering support for various Views (such as TabHosts and SlidingDrawers) in
+ Honeycomb (Issues <a href="http://code.google.com/p/android/issues/detail?id=3162">3162</a>
+ and <a href="http://code.google.com/p/android/issues/detail?id=13092">13092</a>).</li>
+ <li>Included layouts can be rendered and edited in the context of the layouts that include
+ them. From a layout using an <a href="{@docRoot}guide/topics/resources/layout-resource.html#include-element">
+ <code><include></code></a> tag, double-clicking on the
+ <a href="{@docRoot}guide/topics/resources/layout-resource.html#include-element">
+ <code><include></code></a> element edits the referenced layout in the context of the
+ current layout. Additionally, when editing a layout that is included by other layouts,
+ you can quickly change between context layouts, by right clicking in the editor and choosing
+ <strong>Show included in...</strong>. This feature is only available in Honeycomb.</li>
+ </ul>
+ </li>
+ <li>This release fixes many other bugs, but the most important ones are listed below:
+ <ul>
+ <li>Fixed issue that prevented launching debug builds on productions devices when
+ <code>debuggable=true</code> was not set in the Android manifest.</li>
+ <li>The LogCat view in DDMS properly handles UTF-8 characters.</li>
+ <li>The SDK Manager is more reliable on Windows
+ (<a href="http://tools.android.com/recent/sdkmanagerfixes">Details</a>).</li>
+ <li>A JUnit initialization bug that prevented you from working with JUnit tests was fixed
+ (Issue <a href="http://code.google.com/p/android/issues/detail?id=12411">12411</a>).</li>
+ </ul>
+</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 8.0.1</a> <em>(December 2010)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<p><p>ADT 8.0.1 is designed for use with SDK Tools r8. If you haven't
+already installed SDK Tools r8 into your SDK, use the Android SDK Manager to do
+so.</p></dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+ <li>This is a quick follow-up to ADT 8.0.0 to fix some bugs.</li>
+ <li>Fixes an issue in which projects failed to compile, citing a dex error.</li>
+ <li>Better ProGuard error reporting when exporting applications for release.</li>
+</ul>
+<p>Also see the recent release notes for 8.0.0, below.</p>
+</dd>
+</dl>
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ADT 8.0.0</a> <em>(December 2010)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<p><p>ADT 8.0.0 is designed for use with SDK Tools r8. If you haven't
+already installed SDK Tools r8 into your SDK, use the Android SDK Manager to do
+so.</p></dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+ <li>New version number scheme that follows the SDK Tools revision number. The major version
+number for your ADT plugin should now always match the revision number of your SDK Tools. For
+example, ADT 8.x is for SDK Tools r8.</li>
+ <li>Support for true debug build. You no longer need to change the value of the
+ <code>debuggable</code> attribute in the Android Manifest.
+ <p>Incremental builds automatically insert <code>debuggable="true"</code>, but if you perform
+ "export signed/unsigned application package", ADT does <em>not</em> insert it.
+ If you manually set <code>debuggable="true"</code> in the manifest file, then release builds will
+ actually create a debug build (it does not remove it if you placed it there).</p></li>
+ <li>Automatic <a href="{@docRoot}tools/help/proguard.html">ProGuard</a> support in
+ release builds. For it to work, you need to have a <code>proguard.config</code>
+ property in the <code>default.properties</code> file that points to a ProGuard config file.</li>
+ <li>Completely rewritten Visual Layout Editor. (This is still a work in progress.) Now includes:
+ <ul>
+ <li>Full drag and drop from palette to layout for all Layout classes.</li>
+ <li>Move widgets inside a Layout view, from one Layout view to another and from one layout file to another.</li>
+ <li>Contextual menu with enum/flag type properties.</li>
+ <li>New zoom controls.</li>
+ </ul></li>
+ <li>New HierarchyViewer plug-in integrated in Eclipse.</li>
+ <li>Android launch configurations don't recompile the whole workspace on launch anymore.</li>
+ <li><code>android.jar</code> source and javadoc location can now be configured.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.9</a> <em>(September 2010)</em>
+ <div class="toggleme">
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd><p>ADT 0.9.9 replaces ADT 0.9.8 and is designed for use with SDK Tools r7
+and later. ADT 0.9.9 includes the ADT 0.9.8 features as well as an important
+bugfix, so we recommend that you upgrade as soon as possible. If you haven't
+already installed SDK Tools r7 into your SDK, use the Android SDK Manager to do
+so.</p></dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>Fixes a problem in project import, in which source files were deleted in some cases.</li>
+<li>Includes all other ADT 0.9.8 features (see below).</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.8</a> <em>(September 2010)</em>
+ <div class="toggleme">
+
+
+</ul>
+</dd>
+
+<dl>
+
+<dt>Dependencies:</dt>
+
+<dd><p>ADT 0.9.8 is now deprecated. Please use ADT 0.9.9 instead.</p></dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>Adds a new Action, "Rename Application Package", to the Android Tools
+contextual menu. The Action does a full application package refactoring.
+<li>Adds support for library projects that don't have a source folder
+called <code>src/</code>. There is now support for any number of source folders,
+with no name restriction. They can even be in subfolder such as
+<code>src/java</code>. If you are already working with library projects created
+in ADT 0.9.7, see <a
+href="{@docRoot}tools/projects/index.html#libraryMigrating">Migrating
+library projects to ADT 0.9.8</a> for important information about moving
+to the new ADT environment.</li>
+<li>Adds support for library projects that depend on other library
+projects.</li>
+<li>Adds support for additional resource qualifiers:
+<code>car</code>/<code>desk</code>, <code>night</code>/<code>notnight</code> and
+<code>navexposed</code>/<code>navhidden</code>.</li>
+<li>Adds more device screen types in the layout editor. All screen
+resolution/density combinations listed in the <a
+href="{@docRoot}guide/practices/screens_support.html#range">Supporting
+Multiple Screens</a> are now available.</li>
+<li>Fixes problems with handling of library project names that
+contain characters that are incompatible with the Eclipse path variable.
+Now properly sets up the link between the main project and the library
+project.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.7</a> <em>(May 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Library projects:</dt>
+<dd>
+<p>The ADT Plugin now supports the use of <em>library projects</em> during
+development, a capability that lets you store shared Android application
+code and resources in a separate development project. You can then reference the
+library project from other Android projects and, at build time, the tools
+compile the shared code and resources as part of the dependent applications.
+More information about this feature is available in the <a
+href="{@docRoot}tools/projects/index.html#LibraryProjects">Creating and Managing Projects</a> document. </p>
+<p>If you are not developing in Eclipse, <a
+href="tools-notes.html">SDK Tools r6</a> provides the equivalent library
+project support through the Ant build system.</p>
+</dd>
+</dl>
+ </div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.6</a> <em>(March 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+
+<dd><p>ADT 0.9.6 is designed for use with SDK Tools r5 and later. Before
+updating to ADT 0.9.6, we highly recommend that you use the Android SDK Manager to install SDK
+Tools r5 into your SDK.</p></dd>
+
+<dt>General Notes:</dt>
+<dd>
+<ul>
+<li>Editing <code>default.properties</code> outside of Eclipse will now
+automatically update the project.</li>
+<li>Loads the SDK content only when a project requires it. This will make
+Eclipse use less resources when the SDK contains many versions of Android.</li>
+<li>Resolves potential deadlock between modal dialogs, when launching ADT the
+first time with the SDK Usage panel.</li>
+<li>Fixes issues with the New Project Wizard when selecting samples.</li>
+</ul>
+</dd>
+<dt>AVD/SDK Manager:</dt>
+<dd>
+<ul>
+<li>Adds support for platform samples packages.</li>
+<li>Improves support for dependency between packages.</li>
+<li>AVDs now sorted by API level.</li>
+<li>The AVD creation dialog now enforces a minimum SD card size of 9MB.</li>
+<li>Prevents deletion of running AVDs.</li>
+</ul>
+</dd>
+<dt>DDMS:</dt>
+<dd>
+<ul>
+<li>DDMS plug-in now contains the Allocation Tracker view.</li>
+<li>New action in the Logcat view: "Go to problem" lets you go directly from an
+exception trace output to the code.</li>
+</ul>
+</dd>
+<dt>Editors:</dt>
+<dd>
+<ul>
+<li>Explode mode in the Visual Layout Editor adds a margin to all layout objects
+so that it's easier to see embedded or empty layouts.</li>
+<li>Outline mode in the Visual Layout Editor draws layout outline to make it
+easier to see layout objects.</li>
+<li>Several fixes in the configuration selector of the Visual Layout
+Editor.</li>
+</ul>
+</dd>
+<dt>Application launching:</dt>
+<dd>
+<ul>
+<li>Applications launched from ADT now behave as if they were clicked from the
+Home screen.</li>
+<li>Fixes issue where add-on with no optional library would not show up as valid
+targets for application launches.</li>
+<li>Resolves possible crash when launching applications.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.5</a> <em>(December 2009)</em>
+ <div class="toggleme">
+<dl>
+<dt>Dependencies:</dt>
+
+<dd><p>ADT 0.9.5 requires features provided in SDK Tools r4 or higher. If you install
+ADT 0.9.5, which is highly recommended, you should use the Android SDK
+Manager to download the latest SDK Tools into your SDK. For more information,
+see <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</p>
+</dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>AVD Launch dialog now shows scale value.</li>
+<li>Fixes potential NPE in SDK Manager on AVD launch, for older AVD with no skin name specified.</li>
+<li>Fixes XML validation issue in on older Java versions.</li>
+<li>.apk packaging now properly ignores vi swap files as well as hidden files.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+ADT 0.9.4</a> <em>(October 2009)</em>
+ <div class="toggleme">
+<dl>
+<dt>Dependencies:</dt>
+
+<dd><p>ADT 0.9.4 requires features provided in SDK Tools r3 or higher. If you install
+ADT 0.9.4, which is highly recommended, you should use the Android SDK
+Manager to download the latest SDK Tools into your SDK. For more information,
+see <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</p>
+</dd>
+
+<dt>Project Creation Wizard:</dt>
+<dd>
+<ul>
+<li>New option to create a project from a sample by choosing it from a list.</li>
+</ul>
+</dd>
+
+<dt>Layout Editor:</dt>
+<dd>
+<ul>
+<li>Improved Configuration selector that lets you see how your layout will
+render on different devices. Default device descriptions include ADP1
+and Google Ion, while SDK add-ons can also provide new descriptions.
+A new UI allows you to create custom descriptions.</li>
+<li>Adds a new clipping toggle, to let you see your full layout even if it's
+bigger than the screen.</li>
+</ul>
+</dd>
+
+<dt>DDMS integration:</dt>
+<dd>
+<ul>
+<li>Includes the improvements from the standlone DDMS, revision 3.</li>
+<li>Adds an option to open HPROF files into eclipse instead of writing them on
+disk. If a profiler such as MAT (<a href="http://eclipse.org/mat">Memory Analyzer
+Tool</a>) is installed, it'll open the file.</li>
+</ul>
+</dd>
+
+<dt>Android SDK and AVD Manager integration:</dt>
+<dd>
+<ul>
+<li>Includes the improvements from the standalone Android SDK and AVD Manager,
+revision 3.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
diff --git a/docs/html/tools/sdk/images/2.0/camera-modes.png b/docs/html/tools/sdk/images/2.0/camera-modes.png
new file mode 100644
index 0000000..ac4c1da
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.0/camera-modes.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.0/email-inbox.png b/docs/html/tools/sdk/images/2.0/email-inbox.png
new file mode 100644
index 0000000..50d1c19
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.0/email-inbox.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.0/mms-search.png b/docs/html/tools/sdk/images/2.0/mms-search.png
new file mode 100644
index 0000000..22c7dca
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.0/mms-search.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.0/multiple-accounts.png b/docs/html/tools/sdk/images/2.0/multiple-accounts.png
new file mode 100644
index 0000000..aa4cb15
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.0/multiple-accounts.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.0/quick-connect.png b/docs/html/tools/sdk/images/2.0/quick-connect.png
new file mode 100644
index 0000000..0bbf7dd
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.0/quick-connect.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22browser.png b/docs/html/tools/sdk/images/2.2/22browser.png
new file mode 100644
index 0000000..817439d
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22browser.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22exchange.png b/docs/html/tools/sdk/images/2.2/22exchange.png
new file mode 100644
index 0000000..1fa1f59
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22exchange.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22gallery.png b/docs/html/tools/sdk/images/2.2/22gallery.png
new file mode 100644
index 0000000..0cb74ad
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22gallery.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22home.png b/docs/html/tools/sdk/images/2.2/22home.png
new file mode 100644
index 0000000..a11ea30
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22home.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22hotspot.png b/docs/html/tools/sdk/images/2.2/22hotspot.png
new file mode 100644
index 0000000..0951439
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22hotspot.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/22keyboard.png b/docs/html/tools/sdk/images/2.2/22keyboard.png
new file mode 100644
index 0000000..69f95ca
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/22keyboard.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.2/jit-graph.png b/docs/html/tools/sdk/images/2.2/jit-graph.png
new file mode 100644
index 0000000..52b8d60
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.2/jit-graph.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/ffc.png b/docs/html/tools/sdk/images/2.3/ffc.png
new file mode 100644
index 0000000..136a395f
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/ffc.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/home-menu.png b/docs/html/tools/sdk/images/2.3/home-menu.png
new file mode 100644
index 0000000..e9c8620
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/home-menu.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/home-plain.png b/docs/html/tools/sdk/images/2.3/home-plain.png
new file mode 100644
index 0000000..a6255f6
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/home-plain.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/nfc.png b/docs/html/tools/sdk/images/2.3/nfc.png
new file mode 100644
index 0000000..a21b6ab
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/nfc.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/onetouch.png b/docs/html/tools/sdk/images/2.3/onetouch.png
new file mode 100644
index 0000000..2789612
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/onetouch.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/power.png b/docs/html/tools/sdk/images/2.3/power.png
new file mode 100644
index 0000000..7b0785d
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/power.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/running.png b/docs/html/tools/sdk/images/2.3/running.png
new file mode 100644
index 0000000..fe9a1a0
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/running.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/selection.png b/docs/html/tools/sdk/images/2.3/selection.png
new file mode 100644
index 0000000..46ff28c
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/selection.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/2.3/sipcall.png b/docs/html/tools/sdk/images/2.3/sipcall.png
new file mode 100644
index 0000000..48a5a1d
--- /dev/null
+++ b/docs/html/tools/sdk/images/2.3/sipcall.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/browser.png b/docs/html/tools/sdk/images/3.0/browser.png
new file mode 100644
index 0000000..0f16b27
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/browser.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/browser_full.png b/docs/html/tools/sdk/images/3.0/browser_full.png
new file mode 100644
index 0000000..08a329d6
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/browser_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/camera.png b/docs/html/tools/sdk/images/3.0/camera.png
new file mode 100644
index 0000000..7dabdfc
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/camera.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/camera_full.png b/docs/html/tools/sdk/images/3.0/camera_full.png
new file mode 100644
index 0000000..3ee95c9
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/camera_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/contacts.png b/docs/html/tools/sdk/images/3.0/contacts.png
new file mode 100644
index 0000000..9304701
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/contacts.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/contacts_full.png b/docs/html/tools/sdk/images/3.0/contacts_full.png
new file mode 100644
index 0000000..b5eaf5b
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/contacts_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/copy.png b/docs/html/tools/sdk/images/3.0/copy.png
new file mode 100644
index 0000000..d5a4c3e
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/copy.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/copy_full.png b/docs/html/tools/sdk/images/3.0/copy_full.png
new file mode 100644
index 0000000..124cf52
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/copy_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/home_hero1.png b/docs/html/tools/sdk/images/3.0/home_hero1.png
new file mode 100644
index 0000000..c00391f
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/home_hero1.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/home_hero1_full.png b/docs/html/tools/sdk/images/3.0/home_hero1_full.png
new file mode 100644
index 0000000..1910ed2
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/home_hero1_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/homescreen_cust_port.png b/docs/html/tools/sdk/images/3.0/homescreen_cust_port.png
new file mode 100644
index 0000000..b003a30
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/homescreen_cust_port.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/homescreen_cust_port_full.png b/docs/html/tools/sdk/images/3.0/homescreen_cust_port_full.png
new file mode 100644
index 0000000..9c64edd
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/homescreen_cust_port_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/mail_drag.png b/docs/html/tools/sdk/images/3.0/mail_drag.png
new file mode 100644
index 0000000..1f09a7a
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/mail_drag.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/mail_drag_full.png b/docs/html/tools/sdk/images/3.0/mail_drag_full.png
new file mode 100644
index 0000000..be4472f
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/mail_drag_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/tasks.png b/docs/html/tools/sdk/images/3.0/tasks.png
new file mode 100644
index 0000000..a4ba1ba
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/tasks.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/tasks_full.png b/docs/html/tools/sdk/images/3.0/tasks_full.png
new file mode 100644
index 0000000..d2a2241
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/tasks_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.0/widgets.png b/docs/html/tools/sdk/images/3.0/widgets.png
new file mode 100644
index 0000000..d847666
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.0/widgets.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.1/controls.png b/docs/html/tools/sdk/images/3.1/controls.png
new file mode 100644
index 0000000..e0ca1f8
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.1/controls.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.1/home.png b/docs/html/tools/sdk/images/3.1/home.png
new file mode 100644
index 0000000..ea0a75a
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.1/home.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.1/home_full.png b/docs/html/tools/sdk/images/3.1/home_full.png
new file mode 100644
index 0000000..2b8e85e
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.1/home_full.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.1/resizeable.png b/docs/html/tools/sdk/images/3.1/resizeable.png
new file mode 100644
index 0000000..c9f5e8e
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.1/resizeable.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/3.1/tasks.png b/docs/html/tools/sdk/images/3.1/tasks.png
new file mode 100644
index 0000000..89d69e5
--- /dev/null
+++ b/docs/html/tools/sdk/images/3.1/tasks.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/allapps-lg.png b/docs/html/tools/sdk/images/4.0/allapps-lg.png
new file mode 100644
index 0000000..f5eba3c
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/allapps-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/allapps.png b/docs/html/tools/sdk/images/4.0/allapps.png
new file mode 100644
index 0000000..317a49a
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/allapps.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/bbench.png b/docs/html/tools/sdk/images/4.0/bbench.png
new file mode 100644
index 0000000..f113092
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/bbench.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/beam-lg.png b/docs/html/tools/sdk/images/4.0/beam-lg.png
new file mode 100644
index 0000000..608fc94
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/beam-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/beam-maps-lg.png b/docs/html/tools/sdk/images/4.0/beam-maps-lg.png
new file mode 100644
index 0000000..96ac235
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/beam-maps-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/beam-maps.png b/docs/html/tools/sdk/images/4.0/beam-maps.png
new file mode 100644
index 0000000..63b6756
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/beam-maps.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/beam.png b/docs/html/tools/sdk/images/4.0/beam.png
new file mode 100644
index 0000000..0eb7d26
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/beam.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/browser-lg.png b/docs/html/tools/sdk/images/4.0/browser-lg.png
new file mode 100644
index 0000000..fe3fe81
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/browser-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/browser-tabs-lg.png b/docs/html/tools/sdk/images/4.0/browser-tabs-lg.png
new file mode 100644
index 0000000..0ea8f10
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/browser-tabs-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/browser-tabs.png b/docs/html/tools/sdk/images/4.0/browser-tabs.png
new file mode 100644
index 0000000..413b0c6
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/browser-tabs.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/browser.png b/docs/html/tools/sdk/images/4.0/browser.png
new file mode 100644
index 0000000..4bc8179
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/browser.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/calendar-widget-lg.png b/docs/html/tools/sdk/images/4.0/calendar-widget-lg.png
new file mode 100644
index 0000000..39fc986
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/calendar-widget-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/calendar-widget.png b/docs/html/tools/sdk/images/4.0/calendar-widget.png
new file mode 100644
index 0000000..80a57f7
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/calendar-widget.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/camera-lg.png b/docs/html/tools/sdk/images/4.0/camera-lg.png
new file mode 100644
index 0000000..7d96a4f
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/camera-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/camera.png b/docs/html/tools/sdk/images/4.0/camera.png
new file mode 100644
index 0000000..7454549
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/camera.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-call-lg.png b/docs/html/tools/sdk/images/4.0/contact-call-lg.png
new file mode 100644
index 0000000..40b1f40
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-call-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-call.png b/docs/html/tools/sdk/images/4.0/contact-call.png
new file mode 100644
index 0000000..5550b57
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-call.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-call.xcf b/docs/html/tools/sdk/images/4.0/contact-call.xcf
new file mode 100644
index 0000000..3046e92
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-call.xcf
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-connect-lg.png b/docs/html/tools/sdk/images/4.0/contact-connect-lg.png
new file mode 100644
index 0000000..ad0d04c
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-connect-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-connect.png b/docs/html/tools/sdk/images/4.0/contact-connect.png
new file mode 100644
index 0000000..d958206
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-connect.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-email-lg.png b/docs/html/tools/sdk/images/4.0/contact-email-lg.png
new file mode 100644
index 0000000..db75a46
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-email-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-email.png b/docs/html/tools/sdk/images/4.0/contact-email.png
new file mode 100644
index 0000000..9e5460d
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-email.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-faves-lg.png b/docs/html/tools/sdk/images/4.0/contact-faves-lg.png
new file mode 100644
index 0000000..1ec3fd0
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-faves-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/contact-faves.png b/docs/html/tools/sdk/images/4.0/contact-faves.png
new file mode 100644
index 0000000..57e4ca6
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/contact-faves.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/face-unlock-lg.png b/docs/html/tools/sdk/images/4.0/face-unlock-lg.png
new file mode 100644
index 0000000..3fd1695
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/face-unlock-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/face-unlock.png b/docs/html/tools/sdk/images/4.0/face-unlock.png
new file mode 100644
index 0000000..00afb83
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/face-unlock.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/folders.xcf b/docs/html/tools/sdk/images/4.0/folders.xcf
new file mode 100644
index 0000000..66cc02c
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/folders.xcf
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/gallery-edit-lg.png b/docs/html/tools/sdk/images/4.0/gallery-edit-lg.png
new file mode 100644
index 0000000..3d6688f
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/gallery-edit-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/gallery-edit.png b/docs/html/tools/sdk/images/4.0/gallery-edit.png
new file mode 100644
index 0000000..69744ec
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/gallery-edit.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/gallery-share-lg.png b/docs/html/tools/sdk/images/4.0/gallery-share-lg.png
new file mode 100644
index 0000000..749f51e
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/gallery-share-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/gallery-share.png b/docs/html/tools/sdk/images/4.0/gallery-share.png
new file mode 100644
index 0000000..443a70c
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/gallery-share.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/gallery-widget.png b/docs/html/tools/sdk/images/4.0/gallery-widget.png
new file mode 100644
index 0000000..e72fd0d
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/gallery-widget.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/home-lg.png b/docs/html/tools/sdk/images/4.0/home-lg.png
new file mode 100644
index 0000000..5b9021d
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/home-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/home.png b/docs/html/tools/sdk/images/4.0/home.png
new file mode 100644
index 0000000..cd24732
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/home.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/live-effects.png b/docs/html/tools/sdk/images/4.0/live-effects.png
new file mode 100644
index 0000000..11a0122
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/live-effects.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/lock-camera-lg.png b/docs/html/tools/sdk/images/4.0/lock-camera-lg.png
new file mode 100644
index 0000000..c82cec6
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/lock-camera-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/lock-camera.png b/docs/html/tools/sdk/images/4.0/lock-camera.png
new file mode 100644
index 0000000..d3cc153
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/lock-camera.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/lock-lg.png b/docs/html/tools/sdk/images/4.0/lock-lg.png
new file mode 100644
index 0000000..b859e11
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/lock-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/lock.png b/docs/html/tools/sdk/images/4.0/lock.png
new file mode 100644
index 0000000..d168826
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/lock.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/quick-responses-lg.png b/docs/html/tools/sdk/images/4.0/quick-responses-lg.png
new file mode 100644
index 0000000..39cea9a
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/quick-responses-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/quick-responses.png b/docs/html/tools/sdk/images/4.0/quick-responses.png
new file mode 100644
index 0000000..d43f348
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/quick-responses.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/screenshot-lg.png b/docs/html/tools/sdk/images/4.0/screenshot-lg.png
new file mode 100644
index 0000000..30ac339
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/screenshot-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/screenshot.png b/docs/html/tools/sdk/images/4.0/screenshot.png
new file mode 100644
index 0000000..b23c913
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/screenshot.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/tasks-lg.png b/docs/html/tools/sdk/images/4.0/tasks-lg.png
new file mode 100644
index 0000000..58b5c5d
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/tasks-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/tasks.png b/docs/html/tools/sdk/images/4.0/tasks.png
new file mode 100644
index 0000000..34a9d4a
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/tasks.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/text-replace-lg.png b/docs/html/tools/sdk/images/4.0/text-replace-lg.png
new file mode 100644
index 0000000..047d802
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/text-replace-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/text-replace.png b/docs/html/tools/sdk/images/4.0/text-replace.png
new file mode 100644
index 0000000..d2bda3e
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/text-replace.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/tts-lg.png b/docs/html/tools/sdk/images/4.0/tts-lg.png
new file mode 100644
index 0000000..2f49051
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/tts-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/tts.png b/docs/html/tools/sdk/images/4.0/tts.png
new file mode 100644
index 0000000..3eae634
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/tts.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/usage-all-lg.png b/docs/html/tools/sdk/images/4.0/usage-all-lg.png
new file mode 100644
index 0000000..fd7eeba
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/usage-all-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/usage-all.png b/docs/html/tools/sdk/images/4.0/usage-all.png
new file mode 100644
index 0000000..048db83
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/usage-all.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/usage-maps-lg.png b/docs/html/tools/sdk/images/4.0/usage-maps-lg.png
new file mode 100644
index 0000000..b144370
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/usage-maps-lg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/4.0/usage-maps.png b/docs/html/tools/sdk/images/4.0/usage-maps.png
new file mode 100644
index 0000000..a6dcd21
--- /dev/null
+++ b/docs/html/tools/sdk/images/4.0/usage-maps.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/battery.png b/docs/html/tools/sdk/images/battery.png
new file mode 100644
index 0000000..10fd16b
--- /dev/null
+++ b/docs/html/tools/sdk/images/battery.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/camera.png b/docs/html/tools/sdk/images/camera.png
new file mode 100644
index 0000000..6078388
--- /dev/null
+++ b/docs/html/tools/sdk/images/camera.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/donut_small_bg.png b/docs/html/tools/sdk/images/donut_small_bg.png
new file mode 100644
index 0000000..f514b50
--- /dev/null
+++ b/docs/html/tools/sdk/images/donut_small_bg.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/market.png b/docs/html/tools/sdk/images/market.png
new file mode 100644
index 0000000..8d11134
--- /dev/null
+++ b/docs/html/tools/sdk/images/market.png
Binary files differ
diff --git a/docs/html/tools/sdk/images/search.png b/docs/html/tools/sdk/images/search.png
new file mode 100644
index 0000000..10ab910
--- /dev/null
+++ b/docs/html/tools/sdk/images/search.png
Binary files differ
diff --git a/docs/html/tools/sdk/index.jd b/docs/html/tools/sdk/index.jd
new file mode 100644
index 0000000..fb71065
--- /dev/null
+++ b/docs/html/tools/sdk/index.jd
@@ -0,0 +1,10 @@
+page.title=Android SDK
+header.hide=1
+
+@jd:body
+
+<p>This page should not exist.</p>
+
+
+
+
diff --git a/docs/html/tools/sdk/installing.jd b/docs/html/tools/sdk/installing.jd
new file mode 100644
index 0000000..4837ab7
--- /dev/null
+++ b/docs/html/tools/sdk/installing.jd
@@ -0,0 +1,590 @@
+page.title=Installing the SDK
+
+@jd:body
+
+
+<script type="text/javascript">
+function toggleDiv(link) {
+ var toggleable = $(link).parent();
+ if (toggleable.hasClass("closed")) {
+ //$(".toggleme", toggleable).slideDown("fast");
+ toggleable.removeClass("closed");
+ toggleable.addClass("open");
+ $(".toggle-img", toggleable).attr("title", "hide").attr("src", (toRoot +
+"assets/images/triangle-opened.png"));
+ } else {
+ //$(".toggleme", toggleable).slideUp("fast");
+ toggleable.removeClass("open");
+ toggleable.addClass("closed");
+ $(".toggle-img", toggleable).attr("title", "show").attr("src", (toRoot +
+"assets/images/triangle-closed.png"));
+ }
+ return false;
+}
+</script>
+<style>
+.toggleable {
+ padding: .25em 1em 0em 1em;
+ margin-bottom: 0;
+}
+.toggleme {
+ padding: 1em 1em 0 2em;
+ line-height:1em;
+}
+.toggleable a {
+ text-decoration:none;
+}
+.toggleme a {
+ text-decoration:underline;
+}
+.toggleable.closed .toggleme {
+ display:none;
+}
+#jd-content .toggle-img {
+ margin:0;
+}
+</style>
+
+<div id="qv-wrapper">
+<div id="qv">
+
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#Preparing">1. Preparing Your Development Computer</a></li>
+ <li><a href="#Installing">2. Downloading the SDK Starter Package</a></li>
+ <li><a href="#InstallingADT">3. Installing the ADT Plugin for Eclipse</a></li>
+ <li><a href="#AddingComponents">4. Adding Platforms and Other Packages</a>
+ <ol>
+ <li><a href="#components">Available Packages</a></li>
+ <li><a href="#which">Recommended Packages</a></li>
+ </ol></li>
+ <li><a href="#sdkContents">5. Exploring the SDK (Optional)</a></li>
+ <li><a href="#NextSteps">Next Steps</a></li>
+ <li><a href="#troubleshooting">Troubleshooting</a></li>
+ </ol>
+
+<h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin for Eclipse</a></li>
+ <li><a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a></li>
+ </ol>
+
+</div>
+</div>
+
+<p>This page describes how to install the Android SDK
+and set up your development environment for the first time.</p>
+
+<p>If you encounter any problems during installation, see the
+<a href="#troubleshooting">Troubleshooting</a> section at the bottom of
+this page.</p>
+
+<h4>Updating?</h4>
+
+<p>If you already have an Android SDK, use the Android SDK Manager tool to install
+updated tools and new Android platforms into your existing environment. For information about how to
+do that, see <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</p>
+
+
+<h2 id="Preparing">Step 1. Preparing Your Development Computer</h2>
+
+<p>Before getting started with the Android SDK, take a moment to confirm that
+your development computer meets the <a href="requirements.html">System
+Requirements</a>. In particular, you might need to install the <a
+href="http://java.sun.com/javase/downloads/index.jsp">JDK</a>, if you don't have it already. </p>
+
+<p>If you will be developing in Eclipse with the Android Development
+Tools (ADT) Plugin—the recommended path if you are new to
+Android—make sure that you have a suitable version of Eclipse
+installed on your computer as described in the
+<a href="requirements.html">System Requirements</a> document.
+If you need to install Eclipse, you can download it from this location: </p>
+
+<p style="margin-left:2em;"><a href=
+"http://www.eclipse.org/downloads/">http://www.eclipse.org/downloads/</a></p>
+
+<p>The "Eclipse Classic" version is recommended. Otherwise, a Java or
+RCP version of Eclipse is recommended.</p>
+
+
+<h2 id="Installing">Step 2. Downloading the SDK Starter Package</h2>
+
+<p>The SDK starter package is not a full
+development environment—it includes only the core SDK Tools, which you can
+use to download the rest of the SDK packages (such as the latest Android platform).</p>
+
+<p>If you haven't already, get the latest version of the SDK starter package from the <a
+href="{@docRoot}sdk/index.html">SDK download page</a>.</p>
+
+<p>If you downloaded a {@code .zip} or {@code .tgz} package (instead of the SDK installer), unpack
+it to a safe location on your machine. By default, the SDK files are unpacked
+into a directory named <code>android-sdk-<machine-platform></code>.</p>
+
+<p>If you downloaded the Windows installer ({@code .exe} file), run it now and it will check
+whether the proper Java SE Development Kit (JDK) is installed (installing it, if necessary), then
+install the SDK Tools into a default location (which you can modify).</p>
+
+<p>Make a note of the name and location of the SDK directory on your system—you will need to
+refer to the SDK directory later, when setting up the ADT plugin and when using
+the SDK tools from the command line.</p>
+
+
+<h2 id="InstallingADT">Step 3. Installing the ADT Plugin for Eclipse</h2>
+
+<p>Android offers a custom plugin for the Eclipse IDE, called Android
+Development Tools (ADT), that is designed to give you a powerful, integrated
+environment in which to build Android applications. It extends the capabilites
+of Eclipse to let you quickly set up new Android projects, create an application
+UI, debug your applications
+using the Android SDK tools, and even export signed (or unsigned) APKs in order
+to distribute your application. In general, developing in Eclipse with ADT is a
+highly recommended approach and is the fastest way to get started with Android.
+</p>
+
+<p>If you'd like to use ADT for developing Android applications, install it now.
+Read <a href="{@docRoot}tools/sdk/eclipse-adt.html#installing">Installing the ADT Plugin</a> for
+step-by-step installation instructions, then return here to continue the
+last step in setting up your Android SDK.</p>
+
+<p>If you prefer to work in a different IDE, you do not need to
+install Eclipse or ADT. Instead, you can directly use the SDK tools to build and
+debug your application. The <a href="{@docRoot}tools/workflow/index.html">Introduction</a>
+to Android application development outlines the major steps that you need to complete when
+developing in Eclipse or other IDEs.</p>
+
+
+
+<h2 id="AddingComponents">Step 4. Adding Platforms and Other Packages</h2>
+
+<p>The last step in setting up your SDK is using the Android SDK Manager (a
+tool included in the SDK starter package) to download essential SDK packages into your development
+environment.</p>
+
+<p>The SDK uses a modular structure that separates the major parts of the SDK—Android platform
+versions, add-ons, tools, samples, and documentation—into a set of separately installable
+packages. The SDK starter package, which you've already downloaded, includes only a single
+package: the latest version of the SDK Tools. To develop an Android application, you also need to
+download at least one Android platform and the associated platform tools. You can add other
+packages and platforms as well, which is highly recommended.</p>
+
+<p>If you used the Windows installer, when you complete the installation wizard, it will launch the
+Android SDK Manager with a default set of platforms and other packages selected
+for you to install. Simply click <strong>Install</strong> to accept the recommended set of
+packages and install them. You can then skip to <a href="#sdkContents">Step 5</a>, but we
+recommend you first read the section about the <a href="#components">Available Packages</a> to
+better understand the packages available from the Android SDK Manager.</p>
+
+<p>You can launch the Android SDK Manager in one of the following ways:</p>
+<ul>
+ <li>From within Eclipse, select <strong>Window > Android SDK Manager</strong>.</li>
+ <li>On Windows, double-click the <code>SDK Manager.exe</code> file at the root of the Android
+SDK directory.</li>
+ <li>On Mac or Linux, open a terminal and navigate to the <code>tools/</code> directory in the
+Android SDK, then execute: <pre>android</pre> </li>
+</ul>
+
+<p>To download packages, use the graphical UI of the Android SDK
+Manager to browse the SDK repository and select new or updated
+packages (see figure 1). The Android SDK Manager installs the selected packages in
+your SDK environment. For information about which packages you should download, see <a
+href="#which">Recommended Packages</a>.</p>
+
+<img src="/images/sdk_manager_packages.png" />
+<p class="img-caption"><strong>Figure 1.</strong> The Android SDK Manager's
+<strong>Available Packages</strong> panel, which shows the SDK packages that are
+available for you to download into your environment.</p>
+
+
+<h3 id="components">Available Packages</h3>
+
+<p>By default, there are two repositories of packages for your SDK: <em>Android
+Repository</em> and <em>Third party Add-ons</em>.</p>
+
+<p>The <em>Android Repository</em> offers these types of packages:</p>
+
+<ul>
+<li><strong>SDK Tools</strong> — Contains tools for debugging and testing your application
+and other utility tools. These tools are installed with the Android SDK starter package and receive
+periodic updates. You can access these tools in the <code><sdk>/tools/</code> directory of
+your SDK. To learn more about
+them, see <a href="{@docRoot}tools/index.html#tools-sdk">SDK Tools</a> in the
+developer guide.</li>
+
+<li><strong>SDK Platform-tools</strong> — Contains platform-dependent tools for developing
+and debugging your application. These tools support the latest features of the Android platform and
+are typically updated only when a new platform becomes available. You can access these tools in the
+<code><sdk>/platform-tools/</code> directory. To learn more about them, see <a
+href="{@docRoot}tools/index.html#tools-platform">Platform Tools</a> in the
+developer guide.</li>
+
+<li><strong>Android platforms</strong> — An SDK platform is
+available for every production Android platform deployable to Android-powered devices. Each
+SDK platform package includes a fully compliant Android library, system image, sample code,
+and emulator skins. To learn more about a specific platform, see the list of platforms that appears
+under the section "Downloadable SDK Packages" on the left part of this page.</li>
+
+<li><strong>USB Driver for Windows</strong> (Windows only) — Contains driver files
+that you can install on your Windows computer, so that you can run and debug
+your applications on an actual device. You <em>do not</em> need the USB driver unless
+you plan to debug your application on an actual Android-powered device. If you
+develop on Mac OS X or Linux, you do not need a special driver to debug
+your application on an Android-powered device. See <a
+href="{@docRoot}tools/device.html">Using Hardware Devices</a> for more information
+about developing on a real device.</li>
+
+<li><strong>Samples</strong> — Contains the sample code and apps available
+for each Android development platform. If you are just getting started with
+Android development, make sure to download the samples to your SDK. <!--The download
+includes not only a set of very useful sample apps, but also the source for <a
+href="{@docRoot}training/basics/firstapp/index.html">Building Your First App</a> and other
+tutorials. --></li>
+
+<li><strong>Documentation</strong> — Contains a local copy of the latest
+multiversion documentation for the Android framework API. </li>
+</ul>
+
+<p>The <em>Third party Add-ons</em> provide packages that allow you to create a development
+environment using a specific Android external library (such as the Google Maps library) or a
+customized (but fully compliant) Android system image. You can add additional Add-on repositories by
+clicking <strong>Add Add-on Site</strong>.</p>
+
+
+<h3 id="which">Recommended Packages</h3>
+
+<p>The SDK repository contains a range of packages that you can download.
+Use the table below to determine which packages you need, based on whether you
+want to set up a basic, recommended, or full development environment:
+</p>
+
+<table style="width:95%">
+
+<tr>
+<th>Environment</th>
+<th>SDK Package</th>
+<th>Comments</th>
+</tr>
+
+<tr>
+<td rowspan="3" style="font-size:.9em;background-color:#FFE;">Basic</td>
+<td style="font-size:.9em;background-color:#FFE;">SDK Tools</td>
+<td style="font-size:.9em;background-color:#FFE;">If you've just installed
+the SDK starter package, then you already have the latest version of this package. The
+SDK Tools package is required to develop an Android application. Make sure you keep this up to
+date.</td>
+</tr>
+
+<tr>
+<td style="font-size:.9em;background-color:#FFE;">SDK Platform-tools</td>
+<td style="font-size:.9em;background-color:#FFE;">This includes more tools that are required
+for application development. These tools are platform-dependent and typically update only when
+a new SDK platform is made available, in order to support new features in the platform. These
+tools are always backward compatible with older platforms, but you must be sure that you have
+the latest version of these tools when you install a new SDK platform.</td>
+</tr>
+
+<tr>
+<td style="font-size:.9em;background-color:#FFE;">SDK platform</td>
+<td style="font-size:.9em;background-color:#FFE;">You need to download <strong
+style="color:red">at least one platform</strong> into your environment, so that
+you will be able to compile your application and set up an Android Virtual
+Device (AVD) to run it on (in the emulator). To start with, just download the
+latest version of the platform. Later, if you plan to publish your application,
+you will want to download other platforms as well, so that you can test your
+application on the full range of Android platform versions that your application supports.</td>
+</tr>
+<tr>
+<td colspan="2"
+style="border:none;text-align:center;font-size:1.5em;font-weight:bold;">+</td><td
+style="border:none"></td>
+</tr>
+<tr>
+<td rowspan="3">Recommended<br/>(plus Basic)</td>
+<td>Documentation</td>
+<td>The Documentation package is useful because it lets you work offline and
+also look up API reference information from inside Eclipse.</td>
+</tr>
+
+<tr>
+<td>Samples</td>
+<td>The Samples packages give you source code that you can use to learn about
+Android, load as a project and run, or reuse in your own app. Note that multiple
+samples packages are available — one for each Android platform version. When
+you are choosing a samples package to download, select the one whose API Level
+matches the API Level of the Android platform that you plan to use.</td>
+</tr>
+<tr>
+<td>Usb Driver</td>
+<td>The Usb Driver package is needed only if you are developing on Windows and
+have an Android-powered device on which you want to install your application for
+debugging and testing. For Mac OS X and Linux platforms, no
+special driver is needed.</td>
+</tr>
+<tr>
+<td colspan="2"
+style="border:none;text-align:center;font-size:1.5em;font-weight:bold;">+</td><td
+style="border:none"></td>
+</tr>
+<tr>
+<td rowspan="3">Full<br/>(plus Recommended)</td>
+<td>Google APIs</td>
+<td>The Google APIs add-on gives your application access to the Maps external
+library, which makes it easy to display and manipulate Maps data in your
+application. </td>
+</tr>
+<tr>
+<td>Additional SDK Platforms</td>
+<td>If you plan to publish your application, you will want to download
+additional platforms corresponding to the Android platform versions on which you
+want the application to run. The recommended approach is to compile your
+application against the lowest version you want to support, but test it against
+higher versions that you intend the application to run on. You can test your
+applications on different platforms by running in an Android Virtual Device
+(AVD) on the Android emulator.</td>
+</tr>
+
+</table>
+
+<p>Once you've installed at least the basic configuration of SDK packages, you're ready to start
+developing Android apps. The next section describes the contents of the Android SDK to familiarize
+you with the packages you've just installed.</p>
+
+<p>For more information about using the Android SDK Manager, see the <a
+href="{@docRoot}sdk/exploring.html">Exploring the SDK</a> document. </p>
+
+
+<h2 id="sdkContents">Step 5. Exploring the SDK (Optional)</h2>
+
+<p>Once you've installed the SDK and downloaded the platforms, documentation,
+and add-ons that you need, we suggest that you open the SDK directory and take a look at what's
+inside.</p>
+
+<p>The table below describes the full SDK directory contents, with packages
+installed. </p>
+
+<table>
+<tr>
+<th colspan="3">Name</th><th>Description</th>
+</tr>
+<tr>
+<td colspan="3"><code>add-ons/</code></td>
+<td>Contains add-ons to the Android SDK development
+environment, which let you develop against external libraries that are available on some
+devices. </td>
+</tr>
+<tr>
+<td colspan="3"><code>docs/</code></td>
+<td>A full set of documentation in HTML format, including the Developer's Guide,
+API Reference, and other information. To read the documentation, load the
+file <code>offline.html</code> in a web browser.</td>
+</tr>
+<tr>
+<td colspan="3"><code>platform-tools/</code></td>
+<td>Contains platform-dependent development tools that may be updated with each platform release.
+The platform tools include the Android Debug Bridge ({@code adb}) as well as other tools that you
+don't typically use directly. These tools are separate from the development tools in the {@code
+tools/} directory because these tools may be updated in order to support new
+features in the latest Android platform.</td>
+</tr>
+<tr>
+<td colspan="3"><code>platforms/</code></td>
+<td>Contains a set of Android platform versions that you can develop
+applications against, each in a separate directory. </td>
+</tr>
+<tr>
+<td style="width:2em;"></td>
+<td colspan="2"><code><em><platform></em>/</code></td>
+<td>Platform version directory, for example "android-11". All platform version directories contain
+a similar set of files and subdirectory structure. Each platform directory also includes the
+Android library (<code>android.jar</code>) that is used to compile applications against the
+platform version.</td>
+</tr>
+<tr>
+<td colspan="3"><code>samples/</code></td>
+<td>Sample code and apps that are specific to platform version.</td>
+</tr>
+<tr>
+<td colspan="3"><code>tools/</code></td>
+<td>Contains the set of development and profiling tools that are platform-independent, such
+as the emulator, the Android SDK Manager, the AVD Manager, <code>ddms</code>,
+<code>hierarchyviewer</code>
+and more. The tools in this directory may be updated at any time using the Android SDK
+Manager and are independent of platform releases.</td>
+</tr>
+<tr>
+<td colspan="3"><code>SDK Readme.txt</code></td>
+<td>A file that explains how to perform the initial setup of your SDK,
+including how to launch the Android SDK Manager tool on all
+platforms.</td>
+</tr>
+<tr>
+<td colspan="3"><code>SDK Manager.exe</code></td>
+<td>Windows SDK only. A shortcut that launches the Android SDK
+Manager tool, which you use to add packages to your SDK.</td>
+</tr>
+<!--<tr>
+<td colspan="3"><code>documentation.html</code></td>
+<td>A file that loads the entry page for the local Android SDK
+documentation.</td>
+</tr>-->
+
+</table>
+
+
+<p>Optionally, you might want to add the location of the SDK's <code>tools/</code> and
+<code>platform-tools</code> to your <code>PATH</code> environment variable, to provide easy
+access to the tools.</p>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+ How to update your PATH</a>
+ <div class="toggleme">
+
+<p>Adding both <code>tools/</code> and <code>platform-tools/</code> to your PATH lets you run
+command line <a href="{@docRoot}tools/index.html">tools</a> without needing to
+supply the full path to the tool directories. Depending on your operating system, you can
+include these directories in your PATH in the following way:</p>
+
+<ul>
+
+ <li>On Windows, right-click on My Computer, and select Properties.
+ Under the Advanced tab, hit the Environment Variables button, and in the
+ dialog that comes up, double-click on Path (under System Variables). Add the full path to the
+ <code>tools/</code> and <code>platform-tools/</code> directories to the path. </li>
+
+ <li>On Linux, edit your <code>~/.bash_profile</code> or <code>~/.bashrc</code> file. Look
+ for a line that sets the PATH environment variable and add the
+ full path to the <code>tools/</code> and <code>platform-tools/</code> directories to it. If you
+ don't see a line setting the path, you can add one:
+ <pre>export PATH=${PATH}:<sdk>/tools:<sdk>/platform-tools</pre>
+ </li>
+
+ <li>On a Mac OS X, look in your home directory for <code>.bash_profile</code> and
+ proceed as for Linux. You can create the <code>.bash_profile</code> if
+ you don't already have one. </li>
+</ul>
+
+</div><!-- end toggleme -->
+</div><!-- end toggleable -->
+
+
+<h2 id="NextSteps">Next Steps</h2>
+<p>Once you have completed installation, you are ready to
+begin developing applications. Here are a few ways you can get started: </p>
+
+<p><strong>Set up the Hello World application</strong></p>
+<ul>
+ <li>If you have just installed the SDK for the first time, go to the <a
+ href="{@docRoot}training/basics/firstapp/index.html">Hello
+ World tutorial</a>. The tutorial takes you step-by-step through the process
+ of setting up your first Android project, including setting up an Android
+ Virtual Device (AVD) on which to run the application.
+</li>
+</ul>
+
+<p class="note">Following the Hello World tutorial is an essential
+first step in getting started with Android development. </p>
+
+<p><strong>Learn about Android</strong></p>
+<ul>
+ <li>Take a look at the <a href="{@docRoot}guide/index.html">Dev
+ Guide</a> and the types of information it provides.</li>
+ <li>Read an introduction to Android as a platform in <a
+ href="{@docRoot}guide/basics/what-is-android.html">What is
+ Android?</a></li>
+ <li>Learn about the Android framework and how applications run on it in
+ <a href="{@docRoot}guide/components/fundamentals.html">Application
+ Fundamentals</a>.</li>
+ <li>Take a look at the Android framework API specification in the <a
+ href="{@docRoot}reference/packages.html">Reference</a> tab.</li>
+</ul>
+
+<p><strong>Explore the development tools</strong></p>
+<ul>
+ <li>Get an overview of the <a
+ href="{@docRoot}tools/index.html">development
+ tools</a> that are available to you.</li>
+ <li>Read the <a href="{@docRoot}tools/workflow/index.html">Introduction</a> to Android
+application development.
+ </li>
+ <li>Read <a href="{@docRoot}tools/device.html">Using Hardware Devices</a> to learn
+how to set up an Android-powered device so you can run and test your application.</li>
+</ul>
+
+<p><strong>Follow the Notepad tutorial</strong></p>
+
+<ul>
+ <li>The <a href="{@docRoot}resources/tutorials/notepad/index.html">
+ Notepad Tutorial</a> shows you how to build a full Android application
+ and provides helpful commentary on the Android system and API. The
+ Notepad tutorial helps you bring together the important design
+ and architectural concepts in a moderately complex application.
+ </li>
+</ul>
+<p class="note">Following the Notepad tutorial is an excellent
+second step in getting started with Android development. </p>
+
+<p><strong>Explore some code</strong></p>
+
+<ul>
+ <li>The Android SDK includes sample code and applications for each platform
+version. You can browse the samples in the <a
+href="{@docRoot}resources/index.html">Resources</a> tab or download them
+into your SDK using the Android SDK Manager. Once you've downloaded the
+samples, you'll find them in
+<code><em><sdk></em>/samples/<em><platform>/</em></code>. </li>
+</ul>
+
+<p><strong>Visit the Android developer groups</strong></p>
+<ul>
+ <li>Take a look at the <a
+ href="{@docRoot}resources/community-groups.html">Community</a> pages to see a list of
+ Android developers groups. In particular, you might want to look at the
+ <a href="http://groups.google.com/group/android-developers">Android
+ Developers</a> group to get a sense for what the Android developer
+ community is like.</li>
+</ul>
+
+<h2 id="troubleshooting">Troubleshooting</h2>
+
+<h3>Ubuntu Linux Notes</h3>
+
+<ul>
+ <li>If you need help installing and configuring Java on your
+ development machine, you might find these resources helpful:
+ <ul>
+ <li><a href="https://help.ubuntu.com/community/Java">https://help.ubuntu.com/community/Java </a></li>
+ <li><a href="https://help.ubuntu.com/community/Java">https://help.ubuntu.com/community/JavaInstallation</a></li>
+ </ul>
+ </li>
+ <li>Here are the steps to install Java and Eclipse, prior to installing
+ the Android SDK and ADT Plugin.
+ <ol>
+ <li>If you are running a 64-bit distribution on your development
+ machine, you need to install the <code>ia32-libs</code> package using
+ <code>apt-get:</code>:
+ <pre>apt-get install ia32-libs</pre>
+ </li>
+ <li>Next, install Java: <pre>apt-get install sun-java6-jdk</pre></li>
+ <li>The Ubuntu package manager does not currently offer an Eclipse 3.3
+ version for download, so we recommend that you download Eclipse from
+ eclipse.org (<a
+ href="http://www.eclipse.org/downloads/">http://www.eclipse.org/
+ downloads/</a>). A Java or RCP version of Eclipse is recommended.</li>
+ <li>Follow the steps given in previous sections to install the SDK
+ and the ADT plugin. </li>
+ </ol>
+ </li>
+</ul>
+
+<h3>Other Linux Notes</h3>
+
+<ul>
+ <li>If JDK is already installed on your development computer, please
+ take a moment to make sure that it meets the version requirements listed
+ in the <a href="requirements.html">System Requirements</a>.
+ In particular, note that some Linux distributions may include JDK 1.4 or Gnu
+ Compiler for Java, both of which are not supported for Android development.</li>
+</ul>
diff --git a/docs/html/tools/sdk/libraries.jd b/docs/html/tools/sdk/libraries.jd
new file mode 100644
index 0000000..9e47c4a
--- /dev/null
+++ b/docs/html/tools/sdk/libraries.jd
@@ -0,0 +1,9 @@
+page.title=Libraries
+
+@jd:body
+
+
+
+<p>A page that lists libraries and links to release notes. Links to dashboards etc.</p>
+
+
diff --git a/docs/html/tools/sdk/ndk/1.5_r1/index.jd b/docs/html/tools/sdk/ndk/1.5_r1/index.jd
new file mode 100644
index 0000000..4c70a8a
--- /dev/null
+++ b/docs/html/tools/sdk/ndk/1.5_r1/index.jd
@@ -0,0 +1,6 @@
+page.title=Android 1.5 NDK, Release 1
+sdk.redirect=true
+sdk.redirect.path=ndk/index.html
+
+@jd:body
+
diff --git a/docs/html/tools/sdk/ndk/1.6_r1/index.jd b/docs/html/tools/sdk/ndk/1.6_r1/index.jd
new file mode 100644
index 0000000..090dcdc
--- /dev/null
+++ b/docs/html/tools/sdk/ndk/1.6_r1/index.jd
@@ -0,0 +1,5 @@
+page.title=Android 1.6 NDK, Release 1
+sdk.redirect=true
+sdk.redirect.path=ndk/index.html
+
+@jd:body
diff --git a/docs/html/tools/sdk/ndk/index.jd b/docs/html/tools/sdk/ndk/index.jd
new file mode 100644
index 0000000..956d939
--- /dev/null
+++ b/docs/html/tools/sdk/ndk/index.jd
@@ -0,0 +1,1128 @@
+ndk=true
+
+ndk.win_download=android-ndk-r8-windows.zip
+ndk.win_bytes=109928336
+ndk.win_checksum=37b1a2576f28752fcc09e1b9c07e3f14
+
+ndk.mac_download=android-ndk-r8-darwin-x86.tar.bz2
+ndk.mac_bytes=96650992
+ndk.mac_checksum=81ce5de731f945692123b377afe0bad9
+
+ndk.linux_download=android-ndk-r8-linux-x86.tar.bz2
+ndk.linux_bytes=88310791
+ndk.linux_checksum=5c9afc9695ad67c61f82fbf896803c05
+
+page.title=Android NDK
+
+@jd:body
+
+<h2 id="notes">Revisions</h2>
+
+<p>The sections below provide information and notes about successive releases of
+the NDK, as denoted by revision number. </p>
+
+<script type="text/javascript">
+function toggleDiv(link) {
+ var toggleable = $(link).parent();
+ if (toggleable.hasClass("closed")) {
+ //$(".toggleme", toggleable).slideDown("fast");
+ toggleable.removeClass("closed");
+ toggleable.addClass("open");
+ $(".toggle-img", toggleable).attr("title", "hide").attr("src", "{@docRoot}assets/images/triangle-opened.png");
+ } else {
+ //$(".toggleme", toggleable).slideUp("fast");
+ toggleable.removeClass("open");
+ toggleable.addClass("closed");
+ $(".toggle-img", toggleable).attr("title", "show").attr("src", "/assets/images/triangle-closed.png");
+ }
+ return false;
+}
+</script>
+
+<style>
+.toggleable {
+padding: 5px 0 0;
+}
+.toggleme {
+ padding: 10px 0 0 20px;
+}
+.toggleable a {
+ text-decoration:none;
+}
+.toggleme a {
+ text-decoration:underline;
+}
+.toggleable.closed .toggleme {
+ display:none;
+}
+#jd-content .toggle-img {
+ margin:0 5px 3px 0;
+}
+</style>
+
+<div class="toggleable open">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 8</a> <em>(May 2012)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes support for MIPS ABI and a few additional fixes.</p>
+
+ </dl>
+ <dt>New features:</dt>
+
+ <dd>
+ <ul>
+ <li>Added support for the MIPS ABI, which allows you to generate machine code that runs on
+ compatible MIPS-based Android devices. Major features for MIPS include MIPS-specific
+ toolchains, system headers, libraries and debugging support. For more details regarding
+ MIPS support, see {@code docs/CPU-MIPS.html} in the NDK package.
+
+ <p>By default, code is generated for ARM-based devices. You can add {@code mips} to
+ your {@code APP_ABI} definition in your {@code Application.mk} file to build
+ for MIPS platforms. For example, the following line instructs {@code ndk-build}
+ to build your code for three distinct ABIs:</p>
+
+ <pre>APP_ABI := armeabi armeabi-v7a <strong>mips</strong></pre>
+
+ <p>Unless you rely on architecture-specific assembly sources, such as ARM assembly
+ code, you should not need to touch your {@code Android.mk} files to build MIPS
+ machine code.</p>
+ </li>
+
+ <li>You can build a standalone MIPS toolchain using the {@code --arch=mips}
+ option when calling <code>make-standalone-toolchain.sh</code>. See
+ {@code docs/STANDALONE-TOOLCHAIN.html} for more details.
+ </li>
+ </ul>
+
+ <p class="note"><strong>Note:</strong> To ensure that your applications are available
+to users only if their devices are capable of running them, Google Play filters applications based
+on the instruction set information included in your application — no action is needed on your part
+to enable the filtering. Additionally, the Android system itself also checks your application at
+install time and allows the installation to continue only if the application provides a library that
+is compiled for the device's CPU architecture.</p>
+ </dd>
+
+ <dt>Important bug fixes:</dt>
+
+ <dd>
+ <ul>
+ <li>Fixed a typo in GAbi++ implementation where the result of {@code
+ dynamic_cast<D>(b)} of base class object {@code b} to derived class {@code D} is
+ incorrectly adjusted in the opposite direction from the base class.
+ (<a href="http://code.google.com/p/android/issues/detail?id=28721">Issue 28721</a>)
+ </li>
+ <li>Fixed an issue in which {@code make-standalone-toolchain.sh} fails to copy
+ {@code libsupc++.*}.</li>
+ </ul>
+ </dd>
+
+ <dt>Other bug fixes:</dt>
+
+ <dd>
+ <ul>
+ <li>Fixed {@code ndk-build.cmd} to ensure that {@code ndk-build.cmd} works correctly even
+ if the user has redefined the {@code SHELL} environment variable, which may be changed
+ when installing a variety of development tools in Windows environments.
+ </li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 7c</a> <em>(April 2012)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes an important fix for Tegra2-based devices, and a few
+additional fixes and improvements:</p>
+
+ <dl>
+ <dt>Important bug fixes:</dt>
+
+ <dd>
+ <ul>
+ <li>Fixed GNU STL armeabi-v7a binaries to not crash on non-NEON
+ devices. The files provided with NDK r7b were not configured properly,
+ resulting in crashes on Tegra2-based devices and others when trying to use
+ certain floating-point functions (e.g., {@code cosf}, {@code sinf}, {@code expf}).</li>
+ </ul>
+ </dd>
+
+ <dt>Important changes:</dt>
+
+ <dd>
+ <ul>
+ <li>Added support for custom output directories through the {@code NDK_OUT}
+ environment variable. When defined, this variable is used to store all
+ intermediate generated files, instead of {@code $PROJECT_PATH/obj}. The variable is
+ also recognized by {@code ndk-gdb}. </li>
+ <li>Added support for building modules with hundreds or even thousands of source
+ files by defining {@code LOCAL_SHORT_COMMANDS} to {@code true} in your {@code Android.mk}.
+ <p>This change forces the NDK build system to put most linker or archiver options
+ into list files, as a work-around for command-line length limitations.
+ See {@code docs/ANDROID-MK.html} for details.</p>
+ </li>
+ </ul>
+ </dd>
+
+ <dt>Other bug fixes:</dt>
+
+ <dd>
+ <ul>
+ <li>Fixed {@code android_getCpuCount()} implementation in the {@code cpufeatures}
+helper library. On certain devices, where cores are enabled dynamically by the system, the previous
+implementation would report the total number of <em>active</em> cores the first time the function
+was called, rather than the total number of <em>physically available</em> cores.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 7b</a> <em>(February 2012)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes fixes for native Windows builds, Cygwin and many other
+ improvements:</p>
+
+ <dl>
+ <dt>Important bug fixes:</dt>
+
+ <dd>
+ <ul>
+ <li>Updated {@code sys/atomics.h} to avoid correctness issues
+ on some multi-core ARM-based devices. Rebuild your unmodified sources with this
+ version of the NDK and this problem should be completely eliminated.
+ For more details, read {@code docs/ANDROID-ATOMICS.html}.</li>
+ <li>Reverted to {@code binutils} 2.19 to fix debugging issues that
+ appeared in NDK r7 (which switched to {@code binutils} 2.20.1).</li>
+ <li>Fixed {@code ndk-build} on 32-bit Linux. A packaging error put a 64-bit version
+ of the {@code awk} executable under {@code prebuilt/linux-x86/bin} in NDK r7.</li>
+ <li>Fixed native Windows build ({@code ndk-build.cmd}). Other build modes were not
+ affected. The fixes include:
+ <ul>
+ <li>Removed an infinite loop / stack overflow bug that happened when trying
+ to call {@code ndk-build.cmd} from a directory that was <em>not</em> the top of
+ your project path (e.g., in any sub-directory of it).</li>
+ <li>Fixed a problem where the auto-generated dependency files were ignored. This
+ meant that updating a header didn't trigger recompilation of sources that included
+ it.</li>
+ <li>Fixed a problem where special characters in files or paths, other than spaces and
+ quotes, were not correctly handled.</li>
+ </ul>
+ </li>
+ <li>Fixed the standalone toolchain to generate proper binaries when using
+ {@code -lstdc++} (i.e., linking against the GNU {@code libstdc++} C++ runtime). You
+ should use {@code -lgnustl_shared} if you want to link against the shared library
+ version or {@code -lstdc++} for the static version.
+
+ <p>See {@code docs/STANDALONE-TOOLCHAIN.html} for more details about this fix.</p>
+ </li>
+ <li>Fixed {@code gnustl_shared} on Cygwin. The linker complained that it couldn't find
+ {@code libsupc++.a} even though the file was at the right location.</li>
+ <li>Fixed Cygwin C++ link when not using any specific C++ runtime through
+ {@code APP_STL}.</li>
+ </ul>
+ </dd>
+ </dl>
+
+ <dl>
+ <dt>Other changes:</dt>
+
+ <dd>
+ <ul>
+ <li>When your application uses the GNU {@code libstdc++} runtime, the compiler will
+ no longer forcibly enable exceptions and RTTI. This change results in smaller code.
+ <p>If you need these features, you must do one of the following:</p>
+ <ul>
+ <li>Enable exceptions and/or RTTI explicitly in your modules or
+ {@code Application.mk}. (recommended)</li>
+ <li>Define {@code APP_GNUSTL_FORCE_CPP_FEATURES} to {@code 'exceptions'},
+ {@code 'rtti'} or both in your {@code Application.mk}. See
+ {@code docs/APPLICATION-MK.html} for more details.</li>
+ </ul>
+ </li>
+ <li>{@code ndk-gdb} now works properly when your application has private services
+ running in independent processes. It debugs the main application process, instead of the
+ first process listed by {@code ps}, which is usually a service process.</li>
+ <li>Fixed a rare bug where NDK r7 would fail to honor the {@code LOCAL_ARM_MODE} value
+ and always compile certain source files (but not all) to 32-bit instructions.</li>
+ <li>{@code stlport}: Refresh the sources to match the Android platform version. This
+ update fixes a few minor bugs:
+ <ul>
+ <li>Fixed instantiation of an incomplete type</li>
+ <li>Fixed minor "==" versus "=" typo</li>
+ <li>Used {@code memmove} instead of {@code memcpy} in {@code string::assign}</li>
+ <li>Added better handling of {@code IsNANorINF}, {@code IsINF}, {@code IsNegNAN},
+ etc.</li>
+ </ul>
+ <p>For complete details, see the commit log.</p>
+ </li>
+ <li>{@code stlport}: Removed 5 unnecessary static initializers from the library.</li>
+ <li>The GNU libstdc++ libraries for armeabi-v7a were mistakenly compiled for
+ armeabi instead. This change had no impact on correctness, but using the right
+ ABI should provide slightly better performance.</li>
+ <li>The {@code cpu-features} helper library was updated to report three optional
+ x86 CPU features ({@code SSSE3}, {@code MOVBE} and {@code POPCNT}). See
+ {@code docs/CPU-FEATURES.html} for more details.</li>
+ <li>{@code docs/NDK-BUILD.html} was updated to mention {@code NDK_APPLICATION_MK} instead
+ of {@code NDK_APP_APPLICATION_MK} to select a custom {@code Application.mk} file.</li>
+ <li>Cygwin: {@code ndk-build} no longer creates an empty "NUL" file in the current
+ directory when invoked.</li>
+ <li>Cygwin: Added better automatic dependency detection. In the previous version, it
+ didn't work properly in the following cases:
+ <ul>
+ <li>When the Cygwin drive prefix was not {@code /cygdrive}.</li>
+ <li>When using drive-less mounts, for example, when Cygwin would translate
+ {@code /home} to {@code \\server\subdir} instead of {@code C:\Some\Dir}.</li>
+ </ul>
+ </li>
+ <li>Cygwin: {@code ndk-build} does not try to use the native Windows tools under
+ {@code $NDK/prebuilt/windows/bin} with certain versions of Cygwin and/or GNU Make.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 7</a> <em>(November 2011)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes new features to support the Android 4.0 platform as well
+ as many other additions and improvements:</p>
+
+ <dl>
+ <dt>New features</dt>
+
+ <dd>
+ <ul>
+ <li>Added official NDK APIs for Android 4.0 (API level 14), which adds the following
+ native features to the platform:
+
+ <ul>
+ <li>Added native multimedia API based on the Khronos Group OpenMAX AL™ 1.0.1
+ standard. The new <code><OMXAL/OpenMAXAL.h></code> and
+ <code><OMXAL/OpenMAXAL_Android.h></code> headers allow applications targeting
+ API level 14 to perform multimedia output directly from native code by using a new
+ Android-specific buffer queue interface. For more details, see
+ <code>docs/openmaxal/index.html</code> and <a href=
+ "http://www.khronos.org/openmax/">http://www.khronos.org/openmax/</a>.</li>
+
+ <li>Updated the native audio API based on the Khronos Group OpenSL ES 1.0.1™
+ standard. With API Level 14, you can now decode compressed audio (e.g. MP3, AAC,
+ Vorbis) to PCM. For more details, see <code>docs/opensles/index.html</code> and
+ <a href=
+ "http://www.khronos.org/opensles">http://www.khronos.org/opensles/</a>.</li>
+ </ul>
+ </li>
+
+ <li>Added CCache support. To speed up large rebuilds, define the
+ <code>NDK_CCACHE</code> environment variable to <code>ccache</code> (or the path to
+ your <code>ccache</code> binary). When declared, the NDK build system automatically
+ uses CCache when compiling any source file. For example:
+ <pre>
+export NDK_CCACHE=ccache
+</pre>
+ <p class="note"><strong>Note:</strong> CCache is not included in the NDK release
+ so you must have it installed prior to using it. For more information about CCache, see
+ <a href="http://ccache.samba.org">http://ccache.samba.org</a>.</p>
+ </li>
+
+ <li>Added support for setting <code>APP_ABI</code> to <code>all</code> to indicate that
+ you want to build your NDK modules for all the ABIs supported by your given NDK
+ release. This means that either one of the following two lines in your
+ <code>Application.mk</code> are equivalent with this release:
+ <pre>
+APP_ABI := all
+APP_ABI := armeabi armeabi-v7a x86
+</pre>
+
+ <p>This also works if you define <code>APP_ABI</code> when calling
+ <code>ndk-build</code> from the command-line, which is a quick way to check that your
+ project builds for all supported ABIs without changing the project's
+ <code>Application.mk file</code>. For example:</p>
+ <pre>
+ndk-build APP_ABI=all
+</pre>
+ </li>
+
+ <li>Added a <code>LOCAL_CPP_FEATURES</code> variable in <code>Android.mk</code> that
+ allows you to declare which C++ features (RTTI or Exceptions) your module uses. This
+ ensures that the final linking works correctly if you have prebuilt modules that depend
+ on these features. See <code>docs/ANDROID-MK.html</code> and
+ <code>docs/CPLUSPLUS-SUPPORT.html</code> for more details.</li>
+
+ <li>Shortened paths to source and object files that are used in build commands. When
+ invoking <code>$NDK/ndk-build</code> from your project path, the paths to the source,
+ object, and binary files that are passed to the build commands are significantly
+ shorter now, because they are passed relative to the current directory. This is useful
+ when building projects with a lot of source files, to avoid limits on the maximum
+ command line length supported by your host operating system. The behavior is unchanged
+ if you invoke <code>ndk-build</code> from a sub-directory of your project tree, or if
+ you define <code>NDK_PROJECT_PATH</code> to point to a specific directory.</li>
+ </ul>
+ </dd>
+
+ <dt>Experimental features</dt>
+
+ <dd>
+ You can now build your NDK source files on Windows <em>without</em> Cygwin by calling the
+ <code>ndk-build.cmd</code> script from the command line from your project path. The
+ script takes exactly the same arguments as the original <code>ndk-build</code> script.
+ The Windows NDK package comes with its own prebuilt binaries for GNU Make, Awk and other
+ tools required by the build. You should not need to install anything else to get a
+ working build system.
+
+ <p class="caution"><strong>Important:</strong> <code>ndk-gdb</code> does not work on
+ Windows, so you still need Cygwin to debug.</p>
+
+ <p>This feature is still experimental, so feel free to try it and report issues on the
+ <a href="http://b.android.com">public bug database</a> or <a href=
+ "http://groups.google.com/group/android-ndk">public forum</a>. All samples and unit tests
+ shipped with the NDK succesfully compile with this feature.</p>
+ </dd>
+
+ <dt>Important bug fixes</dt>
+
+ <dd>
+ <ul>
+ <li>Imported shared libraries are now installed by default to the target installation
+ location (<code>libs/<abi></code>) if <code>APP_MODULES</code> is not defined in
+ your <code>Application.mk</code>. For example, if a top-level module <code>foo</code>
+ imports a module <code>bar</code>, then both <code>libfoo.so</code> and
+ <code>libbar.so</code> are copied to the install location. Previously, only
+ <code>libfoo.so</code> was copied, unless you listed <code>bar</code> in your
+ <code>APP_MODULES</code> too. If you define <code>APP_MODULES</code> explicitly, the
+ behavior is unchanged.</li>
+
+ <li><code>ndk-gdb</code> now works correctly for activities with multiple categories in
+ their MAIN intent filters.</li>
+
+ <li>Static library imports are now properly transitive. For example, if a top-level
+ module <code>foo</code> imports static library <code>bar</code> that imports static
+ library <code>zoo</code>, the <code>libfoo.so</code> will now be linked against both
+ <code>libbar.a</code> and <code>libzoo.a</code>.</li>
+ </ul>
+ </dd>
+
+ <dt>Other changes</dt>
+
+ <dd>
+ <ul>
+ <li><code>docs/NATIVE-ACTIVITY.HTML</code>: Fixed typo. The minimum API level should be
+ 9, not 8 for native activities.</li>
+
+ <li><code>docs/STABLE-APIS.html</code>: Added missing documentation listing EGL as a
+ supported stable API, starting from API level 9.</li>
+
+ <li><code>download-toolchain-sources.sh</code>: Updated to download the toolchain
+ sources from <a href="http://android.googlesource.com">android.googlesource.com</a>,
+ which is the new location for the AOSP servers.</li>
+
+ <li>Added a new C++ support runtime named <code>gabi++</code>. More details about it
+ are available in the updated <code>docs/CPLUSPLUS-SUPPORT.html</code>.</li>
+
+ <li>Added a new C++ support runtime named <code>gnustl_shared</code> that corresponds
+ to the shared library version of GNU libstdc++ v3 (GPLv3 license). See more info at
+ <code>docs/CPLUSPLUS-SUPPORT.html</code></li>
+
+ <li>Added support for RTTI in the STLport C++ runtimes (no support for
+ exceptions).</li>
+
+ <li>Added support for multiple file extensions in <code>LOCAL_CPP_EXTENSION</code>. For
+ example, to compile both <code>foo.cpp</code> and <code>bar.cxx</code> as C++ sources,
+ declare the following:
+ <pre>
+LOCAL_CPP_EXTENSION := .cpp .cxx
+</pre>
+ </li>
+
+ <li>Removed many unwanted exported symbols from the link-time shared system libraries
+ provided by the NDK. This ensures that code generated with the standalone toolchain
+ doesn't risk to accidentally depend on a non-stable ABI symbol (e.g. any libgcc.a
+ symbol that changes each time the toolchain used to build the platform is changed)</li>
+
+ <li>Refreshed the EGL and OpenGLES Khronos headers to support more extensions. Note
+ that this does <em>not</em> change the NDK ABIs for the corresponding libraries,
+ because each extension must be probed at runtime by the client application.
+
+ <p>The extensions that are available depend on your actual device and GPU drivers,
+ not the platform version the device runs on. The header changes simply add new
+ constants and types to make it easier to use the extensions when they have been
+ probed with <code>eglGetProcAddress()</code> or <code>glGetProcAddress()</code>. The
+ following list describes the newly supported extensions:</p>
+
+ <dl>
+ <dt>GLES 1.x</dt>
+
+ <dd>
+ <ul>
+ <li><code>GL_OES_vertex_array_object</code></li>
+
+ <li><code>GL_OES_EGL_image_external</code></li>
+
+ <li><code>GL_APPLE_texture_2D_limited_npot</code></li>
+
+ <li><code>GL_EXT_blend_minmax</code></li>
+
+ <li><code>GL_EXT_discard_framebuffer</code></li>
+
+ <li><code>GL_EXT_multi_draw_arrays</code></li>
+
+ <li><code>GL_EXT_read_format_bgra</code></li>
+
+ <li><code>GL_EXT_texture_filter_anisotropic</code></li>
+
+ <li><code>GL_EXT_texture_format_BGRA8888</code></li>
+
+ <li><code>GL_EXT_texture_lod_bias</code></li>
+
+ <li><code>GL_IMG_read_format</code></li>
+
+ <li><code>GL_IMG_texture_compression_pvrtc</code></li>
+
+ <li><code>GL_IMG_texture_env_enhanced_fixed_function</code></li>
+
+ <li><code>GL_IMG_user_clip_plane</code></li>
+
+ <li><code>GL_IMG_multisampled_render_to_texture</code></li>
+
+ <li><code>GL_NV_fence</code></li>
+
+ <li><code>GL_QCOM_driver_control</code></li>
+
+ <li><code>GL_QCOM_extended_get</code></li>
+
+ <li><code>GL_QCOM_extended_get2</code></li>
+
+ <li><code>GL_QCOM_perfmon_global_mode</code></li>
+
+ <li><code>GL_QCOM_writeonly_rendering</code></li>
+
+ <li><code>GL_QCOM_tiled_rendering</code></li>
+ </ul>
+ </dd>
+
+ <dt>GLES 2.0</dt>
+
+ <dd>
+ <ul>
+ <li><code>GL_OES_element_index_uint</code></li>
+
+ <li><code>GL_OES_get_program_binary</code></li>
+
+ <li><code>GL_OES_mapbuffer</code></li>
+
+ <li><code>GL_OES_packed_depth_stencil</code></li>
+
+ <li><code>GL_OES_texture_3D</code></li>
+
+ <li><code>GL_OES_texture_float</code></li>
+
+ <li><code>GL_OES_texture_float_linear</code></li>
+
+ <li><code>GL_OES_texture_half_float_linear</code></li>
+
+ <li><code>GL_OES_texture_npot</code></li>
+
+ <li><code>GL_OES_vertex_array_object</code></li>
+
+ <li><code>GL_OES_EGL_image_external</code></li>
+
+ <li><code>GL_AMD_program_binary_Z400</code></li>
+
+ <li><code>GL_EXT_blend_minmax</code></li>
+
+ <li><code>GL_EXT_discard_framebuffer</code></li>
+
+ <li><code>GL_EXT_multi_draw_arrays</code></li>
+
+ <li><code>GL_EXT_read_format_bgra</code></li>
+
+ <li><code>GL_EXT_texture_format_BGRA8888</code></li>
+
+ <li><code>GL_EXT_texture_compression_dxt1</code></li>
+
+ <li><code>GL_IMG_program_binary</code></li>
+
+ <li><code>GL_IMG_read_format</code></li>
+
+ <li><code>GL_IMG_shader_binary</code></li>
+
+ <li><code>GL_IMG_texture_compression_pvrtc</code></li>
+
+ <li><code>GL_IMG_multisampled_render_to_texture</code></li>
+
+ <li><code>GL_NV_coverage_sample</code></li>
+
+ <li><code>GL_NV_depth_nonlinear</code></li>
+
+ <li><code>GL_QCOM_extended_get</code></li>
+
+ <li><code>GL_QCOM_extended_get2</code></li>
+
+ <li><code>GL_QCOM_writeonly_rendering</code></li>
+
+ <li><code>GL_QCOM_tiled_rendering</code></li>
+ </ul>
+ </dd>
+
+ <dt>EGL</dt>
+
+ <dd>
+ <ul>
+ <li><code>EGL_ANDROID_recordable</code></li>
+
+ <li><code>EGL_NV_system_time</code></li>
+ </ul>
+ </dd>
+ </dl>
+ </li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 6b</a> <em>(August 2011)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK does not include any new features compared to r6. The r6b release
+ addresses the following issues in the r6 release:</p>
+ <dl>
+ <dt>Important bug fixes</dt>
+ <dd>
+ <ul>
+ <li>Fixed the build when <code>APP_ABI="armeabi x86"</code> is used for
+ multi-architecture builds.</li>
+ <li>Fixed the location of prebuilt STLport binaries in the NDK release package.
+ A bug in the packaging script placed them in the wrong location.</li>
+ <li>Fixed <code>atexit()</code> usage in shared libraries with the x86standalone
+ toolchain.</li>
+ <li>Fixed <code>make-standalone-toolchain.sh --arch=x86</code>. It used to fail
+ to copy the proper GNU libstdc++ binaries to the right location.</li>
+ <li>Fixed the standalone toolchain linker warnings about missing the definition and
+ size for the <code>__dso_handle</code> symbol (ARM only).</li>
+ <li>Fixed the inclusion order of <code>$(SYSROOT)/usr/include</code> for x86 builds.
+ See the <a href="http://code.google.com/p/android/issues/detail?id=18540">bug</a> for
+ more information.</li>
+ <li>Fixed the definitions of <code>ptrdiff_t</code> and <code>size_t</code> in
+ x86-specific systems when they are used with the x86 standalone toolchain.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 6</a> <em>(July 2011)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes support for the x86 ABI and other minor changes.
+ For detailed information describing the changes in this release, read the
+ <code>CHANGES.HTML</code> document included in the NDK package.
+ </p>
+ <dl>
+ <dt>General notes:</dt>
+ <dd>
+ <ul>
+ <li>Adds support for the x86 ABI, which allows you to generate machine code
+ that runs on compatible x86-based Android devices. Major features for x86
+ include x86-specific toolchains, system headers, libraries and
+ debugging support. For all of the details regarding x86 support,
+ see <code>docs/CPU-X86.html</code> in the NDK package.
+
+ <p>By default, code is generated for ARM-based devices, but you can add x86 to your
+ <code>APP_ABI</code> definition in your <code>Application.mk</code> file to build
+ for x86 platforms. For example, the following line instructs <code>ndk-build</code>
+ to build your code for three distinct ABIs:</p>
+
+ <pre>APP_ABI := armeabi armeabi-v7a x86</pre>
+
+ <p>Unless you rely on ARM-based assembly sources, you shouldn't need to touch
+ your <code>Android.mk</code> files to build x86 machine code.</p>
+
+ </li>
+
+ <li>You can build a standalone x86 toolchain using the <code>--toolchain=x86-4.4.3</code>
+ option when calling <code>make-standalone-toolchain.sh</code>. See
+ <code>docs/STANDALONE-TOOLCHAIN.html</code> for more details.
+ </li>
+ <li>The new <code>ndk-stack</code> tool lets you translate stack traces in
+ <code>logcat</code> that are generated by native code. The tool translates
+ instruction addresses into a readable format that contains things such
+ as the function, source file, and line number corresponding to each stack frame.
+ For more information and a usage example, see <code>docs/NDK-STACK.html</code>.
+ </li>
+ </ul>
+ </dd>
+ <dt>Other changes:</dt>
+ <dd><code>arm-eabi-4.4.0</code>, which had been deprecated since NDK r5, has been
+ removed from the NDK distribution.</dd>
+
+ </dl>
+ </div>
+ </div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)"><img src=
+ "{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px">
+ Android NDK, Revision 5c</a> <em>(June 2011)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK does not include any new features compared to r5b. The r5c release
+ addresses the following problems in the r5b release:</p>
+ <dl>
+ <dt>Important bug fixes:</dt>
+ <dd>
+ <ul>
+ <li><code>ndk-build</code>: Fixed a rare bug that appeared when trying to perform parallel
+ builds of debuggable projects.</li>
+
+ <li>Fixed a typo that prevented <code>LOCAL_WHOLE_STATIC_LIBRARIES</code> to work
+ correctly with the new toolchain and added documentation for this in
+ <code>docs/ANDROID-MK.html</code>.</li>
+
+ <li>Fixed a bug where code linked against <code>gnustl_static</code> crashed when run on
+ platform releases older than API level 8 (Android 2.2).</li>
+
+ <li><code>ndk-gdb</code>: Fixed a bug that caused a segmentation fault when debugging Android 3.0
+ or newer devices.</li>
+
+ <li><code><android/input.h></code>: Two functions that were introduced in API level
+ 9 (Android 2.3) were incorrect and are fixed. While this breaks the source API, the
+ binary interface to the system is unchanged. The incorrect functions were missing a
+ <code>history_index</code> parameter, and the correct definitions are shown below:
+<pre>
+float AMotionEvent_getHistoricalRawX(const AInputEvent* motion_event,
+ size_t pointer_index,
+ size_t history_index);
+
+float AMotionEvent_getHistoricalRawY(const AInputEvent* motion_event,
+ size_t pointer_index,
+ size_t history_index);
+</pre>
+ </li>
+
+ <li>Updated the C library ARM binary for API level 9 (Android 2.3) to correctly expose at
+ link time new functions that were added in that API level (for example,
+ <code>pthread_rwlock_init</code>).</li>
+
+ </ul>
+ </dd>
+
+ <dt>Minor improvements and fixes:</dt>
+ <dd>
+ <ul>
+ <li>Object files are now always linked in the order they appear in
+ <code>LOCAL_SRC_FILES</code>. This was not the case previously because the files were
+ grouped by source extensions instead.</li>
+
+ <li>When <code>import-module</code> fails, it now prints the list of directories that
+ were searched. This is useful to check that the <code>NDK_MODULE_PATH</code> definition
+ used by the build system is correct.</li>
+
+ <li>When <code>import-module</code> succeeds, it now prints the directory where the
+ module was found to the log (visible with <code>NDK_LOG=1</code>).</li>
+
+ <li>Increased the build speed of debuggable applications when there is a very large number
+ of include directories in the project.</li>
+
+ <li><code>ndk-gdb</code>: Better detection of <code>adb shell</code> failures and improved
+ error messages.</li>
+
+ <li><code><pthread.h></code>: Fixed the definition of
+ <code>PTHREAD_RWLOCK_INITIALIZER</code> for API level 9 (Android 2.3) and higher.</li>
+
+ <li>Fixed an issue where a module could import itself, resulting in an infinite loop in
+ GNU Make.</li>
+
+ <li>Fixed a bug that caused the build to fail if <code>LOCAL_ARM_NEON</code> was set to
+ true (typo in <code>build/core/build-binary.mk</code>).</li>
+
+ <li>Fixed a bug that prevented the compilation of </code>.s</code> assembly files
+ (<code>.S</code> files were okay).</li>
+ </ul>
+ </dd>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 5b</a> <em>(January 2011)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK does not include any new features compared to r5. The r5b release addresses the
+ following problems in the r5 release:
+ </p>
+ <ul>
+ <li>The r5 binaries required glibc 2.11, but the r5b binaries are generated with a special
+ toolchain that targets glibc 2.7 or higher instead. The Linux toolchain binaries now run on Ubuntu 8.04 or higher. </li>
+ <li>Fixes a compiler bug in the arm-linux-androideabi-4.4.3 toolchain.
+ The previous binary generated invalid thumb instruction sequences when
+ dealing with signed chars.</li>
+ <li>Adds missing documentation for the
+ "gnustl_static" value for APP_STL, that allows you to link against
+ a static library version of GNU libstdc++. </li>
+ <li>The following <code>ndk-build</code> issues are fixed:
+ <ul>
+ <li>A bug that created inconsistent dependency files when a
+ compilation error occured on Windows. This prevented a proper build after
+ the error was fixed in the source code.</li>
+ <li>A Cygwin-specific bug where using very short paths for
+ the Android NDK installation or the project path led to the
+ generation of invalid dependency files. This made incremental builds
+ impossible.</li>
+ <li>A typo that prevented the cpufeatures library from working correctly
+ with the new NDK toolchain.</li>
+ <li>Builds in Cygwin are faster by avoiding calls to <code>cygpath -m</code>
+ from GNU Make for every source or object file, which caused problems
+ with very large source trees. In case this doesn't work properly, define <code>NDK_USE_CYGPATH=1</code> in your
+ environment to use <code>cygpath -m</code> again.</li>
+ <li>The Cygwin installation now notifies the user of invalid installation paths that contain spaces. Previously, an invalid path
+ would output an error that complained about an incorrect version of GNU Make, even if the right one was installed.
+ </ul>
+ </li>
+ <li>Fixed a typo that prevented the <code>NDK_MODULE_PATH</code> environment variable from working properly when
+ it contained multiple directories separated with a colon. </li>
+ <li>The <code>prebuilt-common.sh</code> script contains fixes to check the compiler for 64-bit
+ generated machine code, instead of relying on the host tag, which
+ allows the 32-bit toolchain to rebuild properly on Snow Leopard. The toolchain rebuild scripts now also support
+ using a 32-bit host toolchain.</li>
+ <li>A missing declaration for <code>INET_ADDRSTRLEN</code> was added to <code><netinet/in.h></code>.</li>
+ <li>Missing declarations for <code>IN6_IS_ADDR_MC_NODELOCAL</code> and <code>IN6_IS_ADDR_MC_GLOBAL</code> were added to <code><netinet/in6.h></code>.</li>
+ <li>'asm' was replaced with '__asm__' in <code><asm/byteorder.h></code> to allow compilation with <code>-std=c99</code>.</li>
+ </ul>
+ </div>
+ </div>
+
+<div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 5</a> <em>(December 2010)</em>
+
+ <div class="toggleme">
+ <p>This release of the NDK includes many new APIs, most of which are introduced to
+ support the development of games and similar applications that make extensive use
+ of native code. Using the APIs, developers have direct native access to events, audio,
+ graphics and window management, assets, and storage. Developers can also implement the
+ Android application lifecycle in native code with help from the new
+ {@link android.app.NativeActivity} class. For detailed information describing the changes in this
+ release, read the <code>CHANGES.HTML</code> document included in the downloaded NDK package.
+ </p>
+ <dl>
+ <dt>General notes:</dt>
+ <dd>
+ <ul>
+ <li>Adds support for native activities, which allows you to implement the
+ Android application lifecycle in native code.</li>
+
+ <li>Adds native support for the following:
+
+ <ul>
+
+ <li>Input subsystem (such as the keyboard and touch screen)</li>
+
+ <li>Access to sensor data (accelerometer, compass, gyroscope, etc).</li>
+
+ <li>Event loop APIs to wait for things such as input and sensor events.</li>
+
+ <li>Window and surface subsystem</li>
+
+ <li>Audio APIs based on the OpenSL ES standard that support playback and recording
+ as well as control over platform audio effects</li>
+
+ <li>Access to assets packaged in an <code>.apk</code> file.</li>
+
+ </ul>
+ </li>
+
+ <li>Includes a new toolchain (based on GCC 4.4.3), which generates better code, and can also now
+ be used as a standalone cross-compiler, for people who want to build their stuff with
+ <code>./configure && make</code>. See
+ docs/STANDALONE-TOOLCHAIN.html for the details. The binaries for GCC 4.4.0 are still provided,
+ but the 4.2.1 binaries were removed.</li>
+
+ <li>Adds support for prebuilt static and shared libraries (docs/PREBUILTS.html) and module
+ exports and imports to make sharing and reuse of third-party modules much easier
+ (docs/IMPORT-MODULE.html explains why).</li>
+
+ <li>Provides a default C++ STL implementation (based on STLport) as a helper module. It can be used either
+ as a static or shared library (details and usage examples are in sources/android/stlport/README). Prebuilt
+ binaries for STLport (static or shared) and GNU libstdc++ (static only) are also provided if you choose to
+ compile against those libraries instead of the default C++ STL implementation.
+ C++ Exceptions and RTTI are not supported in the default STL implementation. For more information, see
+ docs/CPLUSPLUS-SUPPORT.HTML.</li>
+
+ <li>Includes improvements to the <code>cpufeatures</code> helper library that improves reporting
+ of the CPU type (some devices previously reported ARMv7 CPU when the device really was an ARMv6). We
+ recommend developers that use this library to rebuild their applications then
+ upload to Google Play to benefit from the improvements.</li>
+
+ <li>Adds an EGL library that lets you create and manage OpenGL ES textures and
+ services.</li>
+
+ <li>Adds new sample applications, <code>native-plasma</code> and <code>native-activity</code>,
+ to demonstrate how to write a native activity.</li>
+
+ <li>Includes many bugfixes and other small improvements; see docs/CHANGES.html for a more
+ detailed list of changes.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+ </div>
+
+ <div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 4b</a> <em>(June 2010)</em>
+
+ <div class="toggleme">
+ <dl>
+ <dt>NDK r4b notes:</dt>
+
+ <dd>
+ <p>Includes fixes for several issues in the NDK build and debugging scripts — if
+ you are using NDK r4, we recommend downloading the NDK r4b build. For detailed
+ information describing the changes in this release, read the CHANGES.TXT document
+ included in the downloaded NDK package.</p>
+ </dd>
+ </dl>
+
+ <dl>
+ <dt>General notes:</dt>
+
+ <dd>
+ <ul>
+ <li>Provides a simplified build system through the new <code>ndk-build</code> build
+ command.</li>
+
+ <li>Adds support for easy native debugging of generated machine code on production
+ devices through the new <code>ndk-gdb</code> command.</li>
+
+ <li>Adds a new Android-specific ABI for ARM-based CPU architectures,
+ <code>armeabi-v7a</code>. The new ABI extends the existing <code>armeabi</code> ABI to
+ include these CPU instruction set extensions:
+
+ <ul>
+ <li>Thumb-2 instructions</li>
+
+ <li>VFP hardware FPU instructions (VFPv3-D16)</li>
+
+ <li>Optional support for ARM Advanced SIMD (NEON) GCC intrinsics and VFPv3-D32.
+ Supported by devices such as Verizon Droid by Motorola, Google Nexus One, and
+ others.</li>
+ </ul>
+ </li>
+
+ <li>Adds a new <code>cpufeatures</code> static library (with sources) that lets your
+ app detect the host device's CPU features at runtime. Specifically, applications can
+ check for ARMv7-A support, as well as VFPv3-D32 and NEON support, then provide separate
+ code paths as needed.</li>
+
+ <li>Adds a sample application, <code>hello-neon</code>, that illustrates how to use the
+ <code>cpufeatures</code> library to check CPU features and then provide an optimized
+ code path using NEON instrinsics, if supported by the CPU.</li>
+
+ <li>Lets you generate machine code for either or both of the instruction sets supported
+ by the NDK. For example, you can build for both ARMv5 and ARMv7-A architectures at the
+ same time and have everything stored to your application's final
+ <code>.apk</code>.</li>
+
+ <li>To ensure that your applications are available to users only if their devices are
+ capable of running them, Google Play now filters applications based on the
+ instruction set information included in your application — no action is needed on
+ your part to enable the filtering. Additionally, the Android system itself also checks
+ your application at install time and allows the installation to continue only if the
+ application provides a library that is compiled for the device's CPU architecture.</li>
+
+ <li>Adds support for Android 2.2, including a new stable API for accessing the pixel
+ buffers of {@link android.graphics.Bitmap} objects from native code.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+ </div>
+
+ <div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 3</a> <em>(March 2010)</em>
+
+ <div class="toggleme">
+ <dl>
+ <dt>General notes:</dt>
+
+ <dd>
+ <ul>
+ <li>Adds OpenGL ES 2.0 native library support.</li>
+
+ <li>Adds a sample application,<code>hello-gl2</code>, that illustrates the use of
+ OpenGL ES 2.0 vertex and fragment shaders.</li>
+
+ <li>The toolchain binaries have been refreshed for this release with GCC 4.4.0, which
+ should generate slightly more compact and efficient machine code than the previous one
+ (4.2.1). The NDK also still provides the 4.2.1 binaries, which you can optionally use
+ to build your machine code.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+ </div>
+
+ <div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 2</a> <em>(September 2009)</em>
+
+ <div class="toggleme">
+ <p>Originally released as "Android 1.6 NDK, Release 1".</p>
+
+ <dl>
+ <dt>General notes:</dt>
+
+ <dd>
+ <ul>
+ <li>Adds OpenGL ES 1.1 native library support.</li>
+
+ <li>Adds a sample application, <code>san-angeles</code>, that renders 3D graphics
+ through the native OpenGL ES APIs, while managing activity lifecycle with a {@link
+ android.opengl.GLSurfaceView} object.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+ </div>
+
+ <div class="toggleable closed">
+ <a href="#"
+ onclick="return toggleDiv(this)"><img src="{@docRoot}assets/images/triangle-closed.png"
+ class="toggle-img"
+ height="9px"
+ width="9px" /> Android NDK, Revision 1</a> <em>(June 2009)</em>
+
+ <div class="toggleme">
+ <p>Originally released as "Android 1.5 NDK, Release 1".</p>
+
+ <dl>
+ <dt>General notes:</dt>
+
+ <dd>
+ <ul>
+ <li>Includes compiler support (GCC) for ARMv5TE instructions, including Thumb-1
+ instructions.</li>
+
+ <li>Includes system headers for stable native APIs, documentation, and sample
+ applications.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+ </div>
+
+ <h2 id="installing">Installing the NDK</h2>
+ <p>Installing the NDK on your development computer is straightforward and involves extracting the
+ NDK from its download package.</p>
+
+ <p>Before you get started make sure that you have downloaded the latest <a href=
+ "{@docRoot}sdk/index.html">Android SDK</a> and upgraded your applications and environment as
+ needed. The NDK is compatible with older platform versions but not older versions of the SDK tools.
+ Also, take a moment to review the <a href="{@docRoot}tools/sdk/ndk/overview.html#reqs">System and
+Software Requirements</a>
+ for the NDK, if you haven't already.</p>
+
+ <p>To install the NDK, follow these steps:</p>
+
+ <ol>
+ <li>From the table at the top of this page, select the NDK package that is appropriate for your
+ development computer and download the package.</li>
+
+ <li>Uncompress the NDK download package using tools available on your computer. When
+ uncompressed, the NDK files are contained in a directory called
+ <code>android-ndk-<version></code>. You can rename the NDK directory if necessary and you
+ can move it to any location on your computer. This documentation refers to the NDK directory as
+ <code><ndk></code>.</li>
+ </ol>
+
+ <p>You are now ready to start working with the NDK.</p>
+
+ <h2 id="gettingstarted">Getting Started with the NDK</h2>
+
+ <p>Once you've installed the NDK successfully, take a few minutes to read the documentation
+ included in the NDK. You can find the documentation in the <code><ndk>/docs/</code>
+ directory. In particular, please read the OVERVIEW.HTML document completely, so that you
+ understand the intent of the NDK and how to use it.</p>
+
+ <p>If you used a previous version of the NDK, take a moment to review the list of NDK changes in
+ the CHANGES.HTML document.</p>
+
+ <p>Here's the general outline of how you work with the NDK tools:</p>
+
+ <ol>
+ <li>Place your native sources under <code><project>/jni/...</code></li>
+
+ <li>Create <code><project>/jni/Android.mk</code> to describe your native sources to the
+ NDK build system</li>
+
+ <li>Optional: Create <code><project>/jni/Application.mk</code>.</li>
+
+ <li>Build your native code by running the 'ndk-build' script from your project's directory. It
+ is located in the top-level NDK directory:
+ <pre class="no-pretty-print">cd <project>
+<ndk>/ndk-build
+</pre>
+
+ <p>The build tools copy the stripped, shared libraries needed by your application to the
+ proper location in the application's project directory.</p>
+ </li>
+
+ <li>Finally, compile your application using the SDK tools in the usual way. The SDK build tools
+ will package the shared libraries in the application's deployable <code>.apk</code> file.</li>
+ </ol>
+
+ <p>For complete information on all of the steps listed above, please see the documentation
+ included with the NDK package.</p>
+
+ <h2 id="samples">Sample Applications</h2>
+
+ <p>The NDK includes sample Android applications that illustrate how to use native code in your
+ Android applications. For more information, see <a href=
+ "{@docRoot}tools/sdk/ndk/overview.html#samples">Sample Applications</a>.</p>
+
+ <h2 id="forum">Discussion Forum and Mailing List</h2>
+
+ <p>If you have questions about the NDK or would like to read or contribute to discussions about
+ it, please visit the <a href="http://groups.google.com/group/android-ndk">android-ndk</a> group
+ and mailing list.</p>
diff --git a/docs/html/tools/sdk/ndk/overview.jd b/docs/html/tools/sdk/ndk/overview.jd
new file mode 100644
index 0000000..98ef1fc
--- /dev/null
+++ b/docs/html/tools/sdk/ndk/overview.jd
@@ -0,0 +1,588 @@
+page.title=What is the NDK?
+@jd:body
+
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+
+ <ol>
+ <li><a href="#choosing">When to Develop in Native Code</a></li>
+ <li>
+ <a href="#contents">Contents of the NDK</a>
+ <ol>
+ <li><a href="#tools">Development tools</a></li>
+
+ <li><a href="#docs">Documentation</a></li>
+
+ <li><a href="#samples">Sample applications</a></li>
+ </ol>
+ </li>
+ <li><a href="#reqs">System and Software Requirements</a></li>
+ </ol>
+ </div>
+ </div>
+
+ <p>The Android NDK is a toolset that lets you embed components that make use of native code in
+ your Android applications.</p>
+
+ <p>Android applications run in the Dalvik virtual machine. The NDK allows you to implement parts
+ of your applications using native-code languages such as C and C++. This can provide benefits to
+ certain classes of applications, in the form of reuse of existing code and in some cases
+ increased speed.</p>
+
+ <p>The NDK provides:</p>
+
+ <ul>
+ <li>A set of tools and build files used to generate native code libraries from C and C++
+ sources</li>
+
+ <li>A way to embed the corresponding native libraries into an application package file
+ (<code>.apk</code>) that can be deployed on Android devices</li>
+
+ <li>A set of native system headers and libraries that will be supported in all future versions
+ of the Android platform, starting from Android 1.5. Applications that use native activities
+ must be run on Android 2.3 or later.</li>
+
+ <li>Documentation, samples, and tutorials</li>
+ </ul>
+
+ <p>The latest release of the NDK supports the following instruction sets:</p>
+
+ <ul>
+ <li>ARMv5TE, including Thumb-1 instructions (see {@code docs/CPU-ARCH-ABIS.html} for more
+information)</li>
+
+ <li>ARMv7-A, including Thumb-2 and VFPv3-D16 instructions, with optional support for
+ NEON/VFPv3-D32 instructions (see {@code docs/CPU-ARM-NEON.html} for more information)</li>
+
+ <li>x86 instructions (see {@code docs/CPU-X86.html} for more information)</li>
+
+ <li>MIPS instructions (see {@code docs/CPU-MIPS.html} for more information)</li>
+ </ul>
+
+ <p>ARMv5TE machine code will run on all ARM-based Android devices. ARMv7-A will run only on
+ devices such as the Verizon Droid or Google Nexus One that have a compatible CPU. The main
+ difference between the two instruction sets is that ARMv7-A supports hardware FPU, Thumb-2, and
+ NEON instructions. You can target either or both of the instruction sets — ARMv5TE is the
+ default, but switching to ARMv7-A is as easy as adding a single line to the application's
+ <code>Application.mk</code> file, without needing to change anything else in the file. You can also build for
+ both architectures at the same time and have everything stored in the final <code>.apk</code>.
+ Complete information is provided in the CPU-ARCH-ABIS.HTML in the NDK package.</p>
+
+ <p>The NDK provides stable headers for libc (the C library), libm (the Math library), OpenGL ES
+ (3D graphics library), the JNI interface, and other libraries, as listed in the <a href=
+ "#tools">Development Tools</a> section.</p>
+
+ <h2 id="choosing">When to Develop in Native Code</h2>
+
+ <p>The NDK will not benefit most applications. As a developer, you need to balance its benefits
+ against its drawbacks; notably, using native code does not result in an automatic performance
+ increase, but always increases application complexity. In general, you should only use native
+ code if it is essential to your application, not just because you prefer to program in C/C++.</p>
+
+ <p>Typical good candidates for the NDK are self-contained, CPU-intensive operations that don't
+ allocate much memory, such as signal processing, physics simulation, and so on. Simply re-coding
+ a method to run in C usually does not result in a large performance increase. When examining
+ whether or not you should develop in native code, think about your requirements and see if the
+ Android framework APIs provide the functionality that you need. The NDK can, however, can be an
+ effective way to reuse a large corpus of existing C/C++ code.</p>
+
+ <p>The Android framework provides two ways to use native code:</p>
+
+ <ul>
+ <li>Write your application using the Android framework and use JNI to access the APIs provided
+ by the Android NDK. This technique allows you to take advantage of the convenience of the
+ Android framework, but still allows you to write native code when necessary. If you use this
+ approach, your application must target specific, minimum Android platform levels, see <a
+ href="#platform-compat">Android platform compatibility</a> for more information.</li>
+
+ <li>
+ <p>Write a native activity, which allows you to implement the lifecycle callbacks in native
+ code. The Android SDK provides the {@link android.app.NativeActivity} class, which is a
+ convenience class that notifies your
+ native code of any activity lifecycle callbacks (<code>onCreate()</code>, <code>onPause()</code>,
+ <code>onResume()</code>, etc). You can implement the callbacks in your native code to handle
+ these events when they occur. Applications that use native activities must be run on Android
+ 2.3 (API Level 9) or later.</p>
+
+ <p>You cannot access features such as Services and Content Providers natively, so if you want
+ to use them or any other framework API, you can still write JNI code to do so.</p>
+ </li>
+ </ul>
+
+ <h2 id="contents">Contents of the NDK</h2>The NDK contains the APIs, documentation, and sample
+ applications that help you write your native code.
+
+ <h3 id="tools">Development tools</h3>
+
+ <p>The NDK includes a set of cross-toolchains (compilers, linkers, etc..) that can generate
+ native ARM binaries on Linux, OS X, and Windows (with Cygwin) platforms.</p>
+
+ <p>It provides a set of system headers for stable native APIs that are guaranteed to be supported
+ in all later releases of the platform:</p>
+
+ <ul>
+ <li>libc (C library) headers</li>
+
+ <li>libm (math library) headers</li>
+
+ <li>JNI interface headers</li>
+
+ <li>libz (Zlib compression) headers</li>
+
+ <li>liblog (Android logging) header</li>
+
+ <li>OpenGL ES 1.1 and OpenGL ES 2.0 (3D graphics libraries) headers</li>
+
+ <li>libjnigraphics (Pixel buffer access) header (for Android 2.2 and above).</li>
+
+ <li>A Minimal set of headers for C++ support</li>
+
+ <li>OpenSL ES native audio libraries</li>
+
+ <li>Android native application APIS</li>
+ </ul>
+
+ <p>The NDK also provides a build system that lets you work efficiently with your sources, without
+ having to handle the toolchain/platform/CPU/ABI details. You create very short build files to
+ describe which sources to compile and which Android application will use them — the build
+ system compiles the sources and places the shared libraries directly in your application
+ project.</p>
+
+ <p class="caution"><strong>Important:</strong> With the exception of the libraries listed above,
+ native system libraries in the Android platform are <em>not</em> stable and may change in future
+ platform versions. Your applications should <em>only</em> make use of the stable native system
+ libraries provided in this NDK.</p>
+
+ <h3 id="docs">Documentation</h3>
+
+ <p>The NDK package includes a set of documentation that describes the capabilities of the NDK and
+ how to use it to create shared libraries for your Android applications. In this release, the
+ documentation is provided only in the downloadable NDK package. You can find the documentation in
+ the <code><ndk>/docs/</code> directory. Included are these files (partial listing):</p>
+
+ <ul>
+ <li>
+ INSTALL.HTML — describes how to install the NDK and configure it for your host
+ system</li>
+
+ <li>OVERVIEW.HTML — provides an overview of the NDK capabilities and usage</li>
+
+ <li>ANDROID-MK.HTML — describes the use of the Android.mk file, which defines the native
+ sources you want to compile</li>
+
+ <li>APPLICATION-MK.HTML — describes the use of the Application.mk file, which describes
+ the native sources required by your Android application</li>
+ <li>CPLUSPLUS-SUPPORT.HTML — describes the C++ support provided in the Android NDK</li>
+ <li>CPU-ARCH-ABIS.HTML — a description of supported CPU architectures and how to target
+ them.</li>
+
+ <li>CPU-FEATURES.HTML — a description of the <code>cpufeatures</code> static library that
+ lets your application code detect the target device's CPU family and the optional features at
+ runtime.</li>
+
+ <li>CHANGES.HTML — a complete list of changes to the NDK across all releases.</li>
+
+ <li>DEVELOPMENT.HTML — describes how to modify the NDK and generate release packages for it</li>
+
+ <li>HOWTO.HTML — information about common tasks associated with NDK development</li>
+
+ <li>IMPORT-MODULE.HTML — describes how to share and reuse modules</li>
+
+ <li>LICENSES.HTML — information about the various open source licenses that govern the Android NDK</li>
+
+ <li>NATIVE-ACTIVITY.HTML — describes how to implement native activities</li>
+
+ <li>NDK-BUILD.HTML — describes the usage of the ndk-build script</li>
+
+ <li>NDK-GDB.HTML — describes how to use the native code debugger</li>
+
+ <li>PREBUILTS.HTML — information about how shared and static prebuilt libraries work </li>
+
+ <li>STANDALONE-TOOLCHAIN.HTML — describes how to use Android NDK toolchain as a standalone
+ compiler (still in beta).</li>
+
+ <li>SYSTEM-ISSUES.HTML — known issues in the Android system images that you should be
+ aware of, if you are developing using the NDK.</li>
+
+ <li>STABLE-APIS.HTML — a complete list of the stable APIs exposed by headers in the
+ NDK.</li>
+
+ </ul>
+
+ <p>Additionally, the package includes detailed information about the "bionic" C library provided
+ with the Android platform that you should be aware of, if you are developing using the NDK. You
+ can find the documentation in the <code><ndk>/docs/system/libc/</code> directory:</p>
+
+ <ul>
+ <li>OVERVIEW.HTML — provides an overview of the "bionic" C library and the features it
+ offers.</li>
+ </ul>
+
+ <h3 id="samples">Sample applications</h3>
+
+<p>The NDK includes sample applications that illustrate how to use native code in your Android
+ applications:</p>
+
+ <ul>
+ <li><code>hello-jni</code> — a simple application that loads a string from a native
+ method implemented in a shared library and then displays it in the application UI.</li>
+
+ <li><code>two-libs</code> — a simple application that loads a shared library dynamically
+ and calls a native method provided by the library. In this case, the method is implemented in a
+ static library imported by the shared library.</li>
+
+ <li><code>san-angeles</code> — a simple application that renders 3D graphics through the
+ native OpenGL ES APIs, while managing activity lifecycle with a {@link
+ android.opengl.GLSurfaceView} object.</li>
+
+ <li><code>hello-gl2</code> — a simple application that renders a triangle using OpenGL ES
+ 2.0 vertex and fragment shaders.</li>
+
+ <li><code>hello-neon</code> — a simple application that shows how to use the
+ <code>cpufeatures</code> library to check CPU capabilities at runtime, then use NEON intrinsics
+ if supported by the CPU. Specifically, the application implements two versions of a tiny
+ benchmark for a FIR filter loop, a C version and a NEON-optimized version for devices that
+ support it.</li>
+
+ <li><code>bitmap-plasma</code> — a simple application that demonstrates how to access the
+ pixel buffers of Android {@link android.graphics.Bitmap} objects from native code, and uses
+ this to generate an old-school "plasma" effect.</li>
+
+ <li><code>native-activity</code> — a simple application that demonstrates how to use the
+ native-app-glue static library to create a native activity</li>
+
+ <li><code>native-plasma</code> — a version of bitmap-plasma implemented with a native
+ activity.</li>
+ </ul>
+
+ <p>For each sample, the NDK includes the corresponding C source code and the necessary Android.mk
+ and Application.mk files. There are located under <code><ndk>/samples/<name>/</code>
+ and their source code can be found under <code><ndk>/samples/<name>/jni/</code>.</p>
+
+ <p>You can build the shared libraries for the sample apps by going into
+ <code><ndk>/samples/<name>/</code> then calling the <code>ndk-build</code> command.
+ The generated shared libraries will be located under
+ <code><ndk>/samples/<name>/libs/armeabi/</code> for (ARMv5TE machine code) and/or
+ <code><ndk>/samples/<name>/libs/armeabi-v7a/</code> for (ARMv7 machine code).</p>
+
+ <p>Next, build the sample Android applications that use the shared libraries:</p>
+
+ <ul>
+ <li>If you are developing in Eclipse with ADT, use the New Project Wizard to create a new
+ Android project for each sample, using the "Import from Existing Source" option and importing
+ the source from <code><ndk>/samples/<name>/</code>. Then, set up an AVD,
+ if necessary, and build/run the application in the emulator.</li>
+
+ <li>If you are developing with Ant, use the <code>android</code> tool to create the build file
+ for each of the sample projects at <code><ndk>/samples/<name>/</code>.
+ Then set up an AVD, if necessary, build your project in the usual way, and run it in the
+ emulator.</li>
+
+ </ul>
+
+ <p>For more information about developing with the Android SDK tools and what
+ you need to do to create, build, and run your applications, see
+ the <a href="{@docRoot}tools/workflow/index.html">Overview</a>
+ section for developing on Android.</p>
+
+ <h4 id="hello-jni">Exploring the hello-jni Sample</h4>
+
+ <p>The hello-jni sample is a simple demonstration on how to use JNI from an Android application.
+ The HelloJni activity receives a string from a simple C function and displays it in a
+ TextView.</p>
+
+ <p>The main components of the sample include:</p>
+
+ <ul>
+ <li>The familiar basic structure of an Android application (an <code>AndroidManifest.xml</code>
+ file, a <code>src/</code> and <code>res</code> directories, and a main activity)</li>
+
+ <li>A <code>jni/</code> directory that includes the implemented source file for the native code
+ as well as the Android.mk file</li>
+
+ <li>A <code>tests/</code> directory that contains unit test code.</li>
+ </ul>
+
+ <ol>
+ <li>Create a new project in Eclipse from the existing sample source or use the
+ <code>android</code> tool to update the project so it generates a build.xml file that you can
+ use to build the sample.
+
+ <ul>
+ <li>In Eclipse:
+
+ <ol type="a">
+ <li>Click <strong>File > New Android Project...</strong></li>
+
+ <li>Select the <strong>Create project from existing source</strong> radio button.</li>
+
+ <li>Select any API level above Android 1.5.</li>
+
+ <li>In the <strong>Location</strong> field, click <strong>Browse...</strong> and select
+ the <code><ndk-root>/samples/hello-jni</code> directory.</li>
+
+ <li>Click <strong>Finish</strong>.</li>
+ </ol>
+ </li>
+
+ <li>On the command line:
+
+ <ol type="a">
+ <li>Change to the <code><ndk-root>/samples/hello-jni</code> directory.</li>
+
+ <li>Run the following command to generate a build.xml file:
+ <pre class="no-pretty-print">android update project -p . -s</pre>
+ </li>
+ </ol>
+ </li>
+ </ul>
+ </li>
+
+ <li>Compile the native code using the <code>ndk-build</code> command.
+ <pre class="no-pretty-print">
+cd <ndk-root>/samples/hello-jni
+<ndk_root>/ndk-build
+</pre>
+ </li>
+
+ <li>Build and install the application as you would a normal Android application. If you are
+ using Eclipse, run the application to build and install it on a device. If you are using Ant,
+ run the following commands from the project directory:
+ <pre class="no-pretty-print">
+ant debug
+adb install bin/HelloJni-debug.apk
+</pre>
+ </li>
+ </ol>
+
+ <p>When you run the application on the device, the string <code>Hello JNI</code> should appear on
+ your device. You can explore the rest of the samples that are located in the
+ <code><ndk-root>/samples</code> directory for more examples on how to use the JNI.</p>
+
+ <h4 id="native-activity">Exploring the native-activity Sample Application</h4>
+
+ <p>The native-activity sample provided with the Android NDK demonstrates how to use the
+ android_native_app_glue static library. This static library makes creating a native activity
+ easier by providing you with an implementation that handles your callbacks in another thread, so
+ you do not have to worry about them blocking your main UI thread. The main parts of the sample
+ are described below:</p>
+
+ <ul>
+ <li>The familiar basic structure of an Android application (an <code>AndroidManifest.xml</code>
+ file, a <code>src/</code> and <code>res</code> directories). The AndroidManifest.xml declares
+ that the application is native and specifies the .so file of the native activity. See {@link
+ android.app.NativeActivity} for the source or see the
+ <code><ndk_root>/platforms/samples/native-activity/AndroidManifest.xml</code> file.</li>
+
+ <li>A <code>jni/</code> directory contains the native activity, main.c, which uses the
+ <code>android_native_app_glue.h</code> interface to implement the activity. The Android.mk that
+ describes the native module to the build system also exists here.</li>
+ </ul>
+
+ <p>To build this sample application:</p>
+
+ <ol>
+ <li>Create a new project in Eclipse from the existing sample source or use the
+ <code>android</code> tool to update the project so it generates a build.xml file that you can
+ use to build the sample.
+
+ <ul>
+ <li>In Eclipse:
+
+ <ol type="a">
+ <li>Click <strong>File > New Android Project...</strong></li>
+
+ <li>Select the <strong>Create project from existing source</strong> radio button.</li>
+
+ <li>Select any API level above Android 2.3.</li>
+
+ <li>In the <strong>Location</strong> field, click <strong>Browse...</strong> and select
+ the <code><ndk-root>/samples/native-activity</code> directory.</li>
+
+ <li>Click <strong>Finish</strong>.</li>
+ </ol>
+ </li>
+
+ <li>On the command line:
+
+ <ol type="a">
+ <li>Change to the <code><ndk-root>/samples/native-activity</code> directory.</li>
+
+ <li>Run the following command to generate a build.xml file:
+ <pre class="no-pretty-print">
+android update project -p . -s
+</pre>
+ </li>
+ </ol>
+ </li>
+ </ul>
+ </li>
+
+ <li>Compile the native code using the <code>ndk-build</code> command.
+ <pre class="no-pretty-print">
+cd <ndk-root>/platforms/samples/android-9/samples/native-activity
+<ndk_root>/ndk-build
+</pre>
+ </li>
+
+ <li>Build and install the application as you would a normal Android application. If you are
+ using Eclipse, run the application to build and install it on a device. If you are using Ant,
+ run the following commands in the project directory, then run the application on the device:
+ <pre class="no-pretty-print">
+ant debug
+adb install bin/NativeActivity-debug.apk
+</pre>
+ </li>
+ </ol>
+
+
+ <h2 id="reqs">System and Software Requirements</h2>
+
+ <p>The sections below describe the system and software requirements for using the Android NDK, as
+ well as platform compatibility considerations that affect appplications using libraries produced
+ with the NDK.</p>
+
+ <h4>The Android SDK</h4>
+
+ <ul>
+ <li>A complete Android SDK installation (including all dependencies) is required.</li>
+
+ <li>Android 1.5 SDK or later version is required.</li>
+ </ul>
+
+ <h4>Supported operating systems</h4>
+
+ <ul>
+ <li>Windows XP (32-bit) or Vista (32- or 64-bit)</li>
+
+ <li>Mac OS X 10.4.8 or later (x86 only)</li>
+
+ <li>Linux (32 or 64-bit; Ubuntu 8.04, or other Linux distributions using GLibc 2.7 or
+later)</li>
+ </ul>
+
+ <h4>Required development tools</h4>
+
+ <ul>
+ <li>For all development platforms, GNU Make 3.81 or later is required. Earlier versions of GNU
+ Make might work but have not been tested.</li>
+
+ <li>A recent version of awk (either GNU Awk or Nawk) is also required.</li>
+
+ <li>For Windows, <a href="http://www.cygwin.com">Cygwin</a> 1.7 or higher is required. The NDK
+ will <em>not</em> work with Cygwin 1.5 installations.</li>
+ </ul>
+
+ <h4 id="platform-compat">Android platform compatibility</h4>
+
+ <ul>
+ <li>The native libraries created by the Android NDK can only be used on devices running
+ specific minimum Android platform versions. The minimum required platform version depends on
+ the CPU architecture of the devices you are targeting. The following table details which
+ Android platform versions are compatible with native code developed for specific CPU
+ architectures.
+
+ <table style="margin:1em;">
+ <tr>
+ <th>Native Code CPU Architecture Used</th>
+ <th>Compatible Android Platform(s)</th>
+ </tr>
+
+ <tr>
+ <td>ARM, ARM-NEON</td>
+ <td>Android 1.5 (API Level 3) and higher</td>
+ </tr>
+
+ <tr>
+ <td>x86</td>
+ <td>Android 2.3 (API Level 9) and higher</td>
+ </tr>
+
+ <tr>
+ <td>MIPS</td>
+ <td>Android 2.3 (API Level 9) and higher</td>
+ </tr>
+ </table>
+
+ <p>These requirements mean you can use native libraries produced with the NDK in
+ applications that are deployable to ARM-based devices running Android 1.5 or later. If you are
+ deploying native libraries to x86 and MIPS-based devices, your application must target Android
+ 2.3 or later.</p>
+ </li>
+
+ <li>To ensure compatibility, an application using a native library produced with the NDK
+ <em>must</em> declare a <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code>
+ <uses-sdk></code></a> element in its manifest file, with an
+ <code>android:minSdkVersion</code> attribute value of "3" or higher. For example:
+
+<pre style="margin:1em;">
+<manifest>
+ <uses-sdk android:minSdkVersion="3" />
+ ...
+</manifest>
+</pre>
+ </li>
+
+ <li>If you use this NDK to create a native library that uses the OpenGL ES APIs, the
+ application containing the library can be deployed only to devices running the minimum platform
+ versions described in the table below. To ensure compatibility, make sure that your application
+ declares the proper <code>android:minSdkVersion</code> attribute value, as shown in the
+ following table.</li>
+
+ <li style="list-style: none; display: inline">
+ <table style="margin:1em;">
+ <tr>
+ <th>OpenGL ES Version Used</th>
+
+ <th>Compatible Android Platform(s)</th>
+
+ <th>Required uses-sdk Attribute</th>
+ </tr>
+
+ <tr>
+ <td>OpenGL ES 1.1</td>
+
+ <td>Android 1.6 (API Level 4) and higher</td>
+
+ <td><code>android:minSdkVersion="4"</code></td>
+ </tr>
+
+ <tr>
+ <td>OpenGL ES 2.0</td>
+
+ <td>Android 2.0 (API Level 5) and higher</td>
+
+ <td><code>android:minSdkVersion="5"</code></td>
+ </tr>
+ </table>
+
+ <p>For more information about API Level and its relationship to Android platform versions,
+ see <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">Android API Levels</a>.</p>
+ </li>
+
+ <li>Additionally, an application using the OpenGL ES APIs should declare a
+ <code><uses-feature></code> element in its manifest, with an
+ <code>android:glEsVersion</code> attribute that specifies the minimum OpenGl ES version
+ required by the application. This ensures that Google Play will show your application only
+ to users whose devices are capable of supporting your application. For example:
+ <pre style="margin:1em;">
+<manifest>
+<!-- Declare that the application uses the OpenGL ES 2.0 API and is designed
+ to run only on devices that support OpenGL ES 2.0 or higher. -->
+ <uses-feature android:glEsVersion="0x00020000" />
+ ...
+</manifest>
+</pre>
+
+ <p>For more information, see the <a href=
+ "{@docRoot}guide/topics/manifest/uses-feature-element.html"><code><uses-feature></code></a>
+ documentation.</p>
+ </li>
+
+ <li>If you use this NDK to create a native library that uses the API to access Android {@link
+ android.graphics.Bitmap} pixel buffers or utilizes native activities, the application
+ containing the library can be deployed only to devices running Android 2.2 (API level 8) or
+ higher. To ensure compatibility, make sure that your application declares <code><uses-sdk
+ android:minSdkVersion="8" /></code> attribute value in its manifest.</li>
+ </ul>
diff --git a/docs/html/tools/sdk/older_releases.jd b/docs/html/tools/sdk/older_releases.jd
new file mode 100644
index 0000000..bb274b6
--- /dev/null
+++ b/docs/html/tools/sdk/older_releases.jd
@@ -0,0 +1,613 @@
+page.title=SDK Archives
+@jd:body
+
+<p>This page provides a full list of archived and obsolete SDK releases,
+including non-current versions of active releases and "early look" versions that
+were released before Android 1.0. <strong>These are provided for
+informational and archival purposes only</strong>.</p>
+
+<div class="special">
+<p>If you are just starting to develop applications for Android, please
+download the current <a href="{@docRoot}sdk/index.html">Android
+SDK</a>. With the current Android SDK, you can add any current and previous
+version of the Android platform as a component and use it for
+development and testing.</p>
+<p>If you already have an Android SDK for platform version 1.6 or newer, then
+you do not need to install a new SDK—especially not one from this page.
+You should install older platforms as components of your existing SDK.
+See <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.</p>
+</div>
+
+
+<h2>Archived SDKs</h2>
+
+<p>The tables below provides Android SDKs that are current in terms of their
+platform version, but do not provide the latest Android development
+environment and tools. Instead of downloading one of these, as a separate
+SDK for each version of the platform, you should instead use the new
+version-neutral Android SDK to download each version of
+the Android platfrom as an individual component.</p>
+
+<p>Please download the current <a
+href="http://developer.android.com/sdk/index.html">Android SDK</a>.</p>
+
+
+<h3>Release 1.6 r1</h3>
+ <p><em>September 2009 - <a href="RELEASENOTES.html#1.6_r1">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.6_r1.zip">android-sdk-
+windows-1 .6_r1.zip</a>
+ </td>
+ <td>260529085 bytes</td>
+ <td>2bcbacbc7af0363058ca1cac6abad848</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.6_r1.zip">android-sdk-
+mac_x86-1 .6_r1.zip</a>
+ </td>
+ <td>247412515 bytes</td>
+ <td>eb13cc79602d492e89103efcf48ac1f6</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.6_r1.tgz">android-
+sdk- linux_x86-1.6_r1.tgz</a>
+ </td>
+ <td>238224860 bytes</td>
+ <td>b4bf0e610ff6db2fb6fb09c49cba1e79</td>
+ </tr>
+
+ </table>
+
+
+<h3>Release 1.5 r3</h3>
+ <p><em>July 2009 - <a href="RELEASENOTES.html#1.5_r3">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.5_r3.zip">android-sdk-
+windows-1 .5_r3.zip</a>
+ </td>
+ <td>191477853 bytes</td>
+ <td>1725fd6963ce69102ba7192568dfc711</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.5_r3.zip">android-sdk-
+mac_x86-1 .5_r3.zip</a>
+ </td>
+ <td>183024673 bytes</td>
+ <td>b1bafdaefdcec89a14b604b504e7daec</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.5_r3.zip">android-
+sdk- linux_x86-1.5_r3.zip</a>
+ </td>
+ <td>178117561 bytes</td>
+ <td>350d0211678ced38da926b8c9ffa4fac</td>
+ </tr>
+
+ </table>
+
+
+<h3>Release 1.1 r1</h3>
+ <p><em>February 2009 - <a href="RELEASENOTES.html#1.1_r1">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.1_r1.zip">android-sdk-
+windows-1
+.1_r1.zip</a>
+ </td>
+ <td>86038515 bytes</td>
+ <td>8c4b9080b430025370689e03d20842f3</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.1_r1.zip">android-sdk-
+mac_x86-1
+.1_r1.zip</a>
+ </td>
+ <td>79046151 bytes</td>
+ <td>becf0f1763d61eedce15d2a903d6c1dd</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.1_r1.zip">android-
+sdk-
+linux_x86-1.1_r1.zip</a>
+ </td>
+ <td>79345522 bytes</td>
+ <td>ebcb16b0cd4aef198b4dd9a1418efbf1</td>
+ </tr>
+
+ </table>
+
+
+<h3>Release 1.0 r2</h3>
+ <p><em>November 2008 - <a href="RELEASENOTES.html#1.0_r2">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.0_r2.zip">android-sdk-
+windows-1
+.0_r2.zip</a>
+ </td>
+ <td>98360564 bytes</td>
+ <td>a5e1af8ac145946b4a9627516ad4a711</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.0_r2.zip">android-sdk-
+mac_x86-1
+.0_r2.zip</a>
+ </td>
+ <td>93771410 bytes</td>
+ <td>87b99d5e9f59b78363a63200c11498e8</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.0_r2.zip">android-
+sdk-
+linux_x86-1.0_r2.zip</a>
+ </td>
+ <td>94186463 bytes</td>
+ <td>a1f3b6d854596f850f5008856d0f380e</td>
+ </tr>
+
+ </table>
+
+
+
+
+<h2>Obsolete SDK Releases</h2>
+
+<p>These tables provide Android SDK releases that have been superceded by
+an active release (shown above) and that are now obsolete.</p>
+
+
+<h3>Release 1.5 r2</h3>
+ <p><em>May 2009 - <a href="RELEASENOTES.html#1.5_r2">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.5_r2.zip">android-sdk-
+windows-1 .5_r2.zip</a>
+ </td>
+ <td>178346828 bytes</td>
+ <td>ba54ac6bda45921d442b74b6de6ff6a9</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.5_r2.zip">android-sdk-
+mac_x86-1 .5_r2.zip</a>
+ </td>
+ <td>169945128 bytes</td>
+ <td>f4e06a5194410243f213d0177713d6c9</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.5_r2.zip">android-
+sdk- linux_x86-1.5_r2.zip</a>
+ </td>
+ <td>165035130 bytes</td>
+ <td>1d3c3d099e95a31c43a7b3e6ae307ed3</td>
+ </tr>
+
+ </table>
+
+
+<h3>Release 1.5 r1</h3>
+ <p><em>April 2009 - <a href="RELEASENOTES.html#1.5_r1">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.5_r1.zip">android-sdk-
+windows-1 .5_r1.zip</a>
+ </td>
+ <td>176263368 bytes</td>
+ <td>42be980eb2d3efaced01ea6c32c0045f</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.5_r1.zip">android-sdk-
+mac_x86-1 .5_r1.zip</a>
+ </td>
+ <td>167848675 bytes</td>
+ <td>5b2a8d9f096032db4a75bfa0d689a51b</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.5_r1.zip">android-
+sdk- linux_x86-1.5_r1.zip</a>
+ </td>
+ <td>162938845 bytes</td>
+ <td>2addfd315da0ad8b5bde6b09d5ff3b06</td>
+ </tr>
+
+ </table>
+
+
+<h3>Release 1.0 r1</h3>
+ <p><em>September 23, 2008 - <a href="RELEASENOTES.html#1.0_r1">Release
+Notes</a></em></p>
+
+ <table class="download">
+ <tr>
+ <th>Platform</th>
+ <th>Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-1.0_r1.zip">android-sdk-
+windows-1 .0_r1.zip</a>
+ </td>
+ <td>89.7 MB bytes</td>
+ <td>d69f4ee93d4010f726c04302662fd999</td>
+ </tr>
+ <tr class="alt-color">
+ <td>Mac OS X (intel)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-1.0_r1.zip">android-sdk-
+mac_x86-1 .0_r1.zip</a>
+ </td>
+ <td>87.5 MB bytes</td>
+ <td>564876ada22872e50c2866806de9fc5c</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+ <a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-1.0_r1.zip">android-
+sdk- linux_x86-1.0_r1.zip</a>
+ </td>
+ <td>87.8 MB bytes</td>
+ <td>2660b4029039b7d714e59827e9a9a11d</td>
+ </tr>
+
+ </table>
+
+
+
+
+<h2>Non-Compatible SDK Releases</h2>
+
+<!-- <div class="special"> -->
+<p>The SDKs listed below are "early-look" versions that were released in
+ the year preceding the full release of Android 1.0 in September 2008. Because
+ these early-look SDKs were released before the Android 1.0 API specification was
+ finalized, they do not provide a compliant Android execution environment.
+ Consequently, applications that you develop in these SDKs will not be able to
+ run on any Android-powered devices.</p>
+
+<p>If you have an older application that you built in one of the early-look
+SDKs, you must migrate it to the Android 1.0 SDK (or later release) before you
+will be able to deploy it to an Android-powered device. To help with this
+migration, each SDK package below provides information about API changes from
+the previous version. You can find the migration information in the
+documentation included in each SDK package.</p>
+<!-- </div> -->
+
+<h4>Version 0.9 Beta</h4>
+<p><em>August 18, 2008 - <a href="OLD_RELEASENOTES.html#0.9_beta">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-windows-0.9_beta.zip">
+android-sdk-windows-0.9_beta.zip</a></td>
+ <td>93,126,573 bytes</td>
+ <td>305031ad8335d1b6040bdd5a65349d6d</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-mac_x86-0.9_beta.zip">
+android-sdk-mac_x86-0.9_beta.zip</a></td>
+ <td>91,374,464 bytes</td>
+ <td>9a6969159091cede46302e11049fe3ca</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk-linux_x86-0.9_beta.zip"
+>android-sdk-linux_x86-0.9_beta.zip</a></td>
+ <td>91,821,068 bytes</td>
+ <td>077e5ef549dd9c5be54bd88e6a8e196c</td>
+ </tr>
+ </table>
+
+<h4>Version m5-rc15</h4>
+ <p><em>March 3, 2008 - <a href="OLD_RELEASENOTES.html#m5-rc15">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc15_windows.zip">
+android-sdk_m5-rc15_windows.zip</a></td>
+ <td>79 MB</td>
+ <td>ecce40bc50201886d95ba2690cdbc5ce</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc15_mac-x86.zip">
+android-sdk_m5-rc15_mac-x86.zip</a></td>
+ <td>76 MB</td>
+ <td>45a6385bbc1b2cb295409cfc81fb04b4</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc15_linux-x86.zip">
+android-sdk_m5-rc15_linux-x86.zip</a></td>
+ <td>76 MB</td>
+ <td>e913f785afecdeed34c30639fd8c5862</td>
+ </tr>
+ </table>
+
+ <h4>Version m5-rc14</h4>
+ <p><em>February 12, 2008 - <a href="OLD_RELEASENOTES.html#m5-rc14">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc14_windows.zip">
+android-sdk_m5-rc14_windows.zip</a></td>
+ <td>79 MB</td>
+ <td>ecc75c1e69588350634ca25867ce05a0</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc14_mac-x86.zip">
+android-sdk_m5-rc14_mac-x86.zip</a></td>
+ <td>76 MB</td>
+ <td>844c80d0adb1a326f5a9fff262c61efc</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android-sdk_m5-rc14_linux-x86.zip">
+android-sdk_m5-rc14_linux-x86.zip</a></td>
+ <td>76 MB</td>
+ <td>f8b863c8a880afe9bb84124f5976aab1</td>
+ </tr>
+ </table>
+
+
+
+
+ <h4>Version m3-rc37a</h4>
+ <p><em>December 14, 2007 - <a href="OLD_RELEASENOTES.html#m3-rc37a">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_windows_m3-rc37a.zip">
+android_sdk_windows_m3-rc37a.zip</a></td>
+ <td>58 MB</td>
+ <td>5db5aea20a2c2f010baefc4b1091a575</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_darwin_m3-rc37a.zip">
+android_sdk_darwin_m3-rc37a.zip</a></td>
+ <td>54 MB</td>
+ <td>0b22e73fbd07b4af4009387afce3a37f</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_linux_m3-rc37a.zip">
+android_sdk_linux_m3-rc37a.zip</a></td>
+ <td>54 MB</td>
+ <td>41285beecc4f9926e6ecf5f12610b356</td>
+ </tr>
+ </table>
+
+
+
+
+ <h4>Version m3-rc22a</h4>
+ <p><em>November 16, 2007 - <a href="OLD_RELEASENOTES.html#m3-rc22a">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_windows_m3-rc22a.zip">
+android_sdk_windows_m3-rc22a.zip</a></td>
+ <td>59 MB</td>
+ <td>aa3dee05a9872752a3bc4efd0f93e98b</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_darwin_m3-rc22a.zip">
+android_sdk_darwin_m3-rc22a.zip</a></td>
+ <td>55 MB</td>
+ <td>0547f45614ad94c3af22c3c0aa6f709f</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_linux_m3-rc22a.zip">
+android_sdk_linux_m3-rc22a.zip</a></td>
+ <td>55 MB</td>
+ <td>84b3455de5cdfd841a172c13d24c382e</td>
+ </tr>
+ </table>
+
+
+
+
+ <h4>Version m3-rc20a</h4>
+ <p><em>November 12, 2007 - <a href="OLD_RELEASENOTES.html#m3-rc20a">Release Notes</a></em></p>
+ <table>
+ <tr>
+ <th colspan="2">Package</th>
+ <th>Size</th>
+ <th>MD5 Checksum</th>
+ </tr>
+ <tr>
+ <td>Windows</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_windows_m3-rc20a.zip">
+android_sdk_windows_m3-rc20a.zip</a></td>
+ <td>59 MB</td>
+ <td>a404b875708df7339ba77bdf2e08dc06</td>
+ </tr>
+ <tr class="alt">
+ <td>Mac OS X (intel)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_darwin_m3-rc20a.zip">
+android_sdk_darwin_m3-rc20a.zip</a></td>
+ <td>55 MB</td>
+ <td>8fc29aeaa45eda84bfac854ebd02a6da</td>
+ </tr>
+ <tr>
+ <td>Linux (i386)</td>
+ <td>
+<a
+href="{@docRoot}sdk/download.html?v=archives/android_sdk_linux_m3-rc20a.zip">
+android_sdk_linux_m3-rc20a.zip</a></td>
+ <td>55 MB</td>
+ <td>9196759df9b69cd89a220b156f133364</td>
+ </tr>
+ </table>
diff --git a/docs/html/tools/sdk/platforms.jd b/docs/html/tools/sdk/platforms.jd
new file mode 100644
index 0000000..27e89de
--- /dev/null
+++ b/docs/html/tools/sdk/platforms.jd
@@ -0,0 +1,9 @@
+page.title=Android Development Platforms
+
+@jd:body
+
+
+
+<p>A page that lists platforms and links to release notes. Links to dashboards etc.</p>
+
+
diff --git a/docs/html/tools/sdk/preview/features.jd b/docs/html/tools/sdk/preview/features.jd
new file mode 100644
index 0000000..02897cd
--- /dev/null
+++ b/docs/html/tools/sdk/preview/features.jd
@@ -0,0 +1,8 @@
+@jd:body
+
+<script type="text/javascript">
+ document.location=toRoot+"about/versions/android-3.0.html"
+</script>
+
+<p>You should have already been redirected by your browser. Please go to the
+<a href="{@docRoot}about/versions/android-3.0.html">Android 3.0 Platform</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/sdk/preview/index.jd b/docs/html/tools/sdk/preview/index.jd
new file mode 100644
index 0000000..ed8f7e0
--- /dev/null
+++ b/docs/html/tools/sdk/preview/index.jd
@@ -0,0 +1,2 @@
+sdk.redirect=true
+@jd:body
diff --git a/docs/html/tools/sdk/preview/installing.jd b/docs/html/tools/sdk/preview/installing.jd
new file mode 100644
index 0000000..c40e531
--- /dev/null
+++ b/docs/html/tools/sdk/preview/installing.jd
@@ -0,0 +1,8 @@
+@jd:body
+
+<script type="text/javascript">
+ document.location=toRoot+"sdk/installing/index.html"
+</script>
+
+<p>You should have already been redirected by your browser. Please go to
+<a href="{@docRoot}sdk/installing/index.html">Installing the SDK</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/sdk/preview/requirements.jd b/docs/html/tools/sdk/preview/requirements.jd
new file mode 100644
index 0000000..b5aed80
--- /dev/null
+++ b/docs/html/tools/sdk/preview/requirements.jd
@@ -0,0 +1,8 @@
+@jd:body
+
+<script type="text/javascript">
+ document.location=toRoot+"sdk/requirements.html"
+</script>
+
+<p>You should have already been redirected by your browser. Please go to the
+<a href="{@docRoot}sdk/requirements.html">SDK System Requirements</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/sdk/preview/upgrading.jd b/docs/html/tools/sdk/preview/upgrading.jd
new file mode 100644
index 0000000..1c53bdb
--- /dev/null
+++ b/docs/html/tools/sdk/preview/upgrading.jd
@@ -0,0 +1,8 @@
+@jd:body
+
+<script type="text/javascript">
+ document.location=toRoot+"sdk/index.html"
+</script>
+
+<p>You should have already been redirected by your browser. Please go to
+<a href="{@docRoot}sdk/index.html">the Android SDK</a>.</p>
\ No newline at end of file
diff --git a/docs/html/tools/sdk/tools-notes.jd b/docs/html/tools/sdk/tools-notes.jd
new file mode 100644
index 0000000..f08209b
--- /dev/null
+++ b/docs/html/tools/sdk/tools-notes.jd
@@ -0,0 +1,855 @@
+page.title=SDK Tools
+@jd:body
+
+<p>SDK Tools is a downloadable component for the Android SDK. It includes the
+complete set of development and debugging tools for the Android SDK.</p>
+
+<p>If you are new to the Android SDK, the <a
+href="{@docRoot}sdk/index.html">SDK starter package</a> installs the
+latest revision of the SDK Tools in the <code><sdk>/tools</code> directory.</p>
+
+<p>If you are already using the SDK and you want to update to the latest version
+of the SDK Tools, use the <em>Android SDK Manager</em> to get the
+update, rather than downloading a new SDK starter package. For more information
+about how to update, see <a
+href="{@docRoot}sdk/exploring.html#UpdatingComponents">Exploring the SDK</a>.</p>
+
+
+<h2 id="notes">Revisions</h2>
+
+<p>The sections below provide notes about successive releases of
+the SDK Tools, as denoted by revision number. To determine what revision of the SDK
+Tools you are using, refer to the "Installed Packages" listing in the Android SDK Manager. </p>
+
+<p>For a summary of all known issues in SDK Tools, see <a
+href="http://tools.android.com/knownissues">http://tools.android.com/knownissues</a>.</p>
+
+<script type="text/javascript">
+function toggleDiv(link) {
+ var toggleable = $(link).parent();
+ if (toggleable.hasClass("closed")) {
+ //$(".toggleme", toggleable).slideDown("fast");
+ toggleable.removeClass("closed");
+ toggleable.addClass("open");
+ $(".toggle-img", toggleable).attr("title", "hide").attr("src", (toRoot + "assets/images/triangle-opened.png"));
+ } else {
+ //$(".toggleme", toggleable).slideUp("fast");
+ toggleable.removeClass("open");
+ toggleable.addClass("closed");
+ $(".toggle-img", toggleable).attr("title", "show").attr("src", (toRoot + "assets/images/triangle-closed.png"));
+ }
+ return false;
+}
+</script>
+<style>
+.toggleable {
+padding: 5px 0 0;
+}
+.toggleme {
+ padding: 10px 0 0 20px;
+}
+.toggleable a {
+ text-decoration:none;
+}
+.toggleme a {
+ text-decoration:underline;
+}
+.toggleable.closed .toggleme {
+ display:none;
+}
+#jd-content .toggle-img {
+ margin:0 5px 3px 0;
+}
+</style>
+
+<div class="toggleable opened">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 19</a> <em>(April 2012)</em>
+
+ <div class="toggleme">
+ <p class="note"><strong>Note:</strong> This update of SDK Tools is only available through
+the <a href="{@docRoot}sdk/exploring.html">Android SDK Manager</a>. Use this tool to
+download and install this update.</p>
+
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>
+ <ul>
+ <li>Android SDK Platform-tools revision 9 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r19 is designed for
+ use with ADT 18.0.0 and later. If you haven't already, we highly recommend updating your
+ <a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 18.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have
+ <a href="http://ant.apache.org/">Apache Ant</a> 1.8 or later.</li>
+ </ul>
+ </dd>
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed an issue that prevented some developers from running the emulator with GPU
+acceleration.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 18</a> <em>(April 2012)</em>
+
+ <div class="toggleme">
+ <p class="caution"><strong>Important:</strong> To download the new Android
+ 4.0 system components from the Android SDK Manager, you must first update the
+ SDK tools to revision 14 or later and restart the Android SDK Manager. If you do not,
+ the Android 4.0 system components will not be available for download.</p>
+
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>
+ <ul>
+ <li>Android SDK Platform-tools revision 9 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r18 is designed for
+ use with ADT 18.0.0 and later. If you haven't already, we highly recommend updating your
+ <a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 18.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have
+ <a href="http://ant.apache.org/">Apache Ant</a> 1.8 or later.</li>
+ </ul>
+ </dd>
+ <dt>General notes:</dt>
+ <dd>
+ <ul>
+ <li>Updated the SdkController app to encapsulate both sensor and multitouch emulation
+ functionality.</li>
+ </ul>
+ </dd>
+ <dt>Bug fixes:</dt>
+ <dd>
+ <ul>
+ <li>Fixed Ant issues where some jar libraries in the {@code libs/} folder are not picked up
+in some cases.</li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 17</a> <em>(March 2012)</em>
+
+ <div class="toggleme">
+ <p class="caution"><strong>Important:</strong> To download the new Android
+ 4.0 system components from the Android SDK Manager, you must first update the
+ SDK tools to revision 14 or later and restart the Android SDK Manager. If you do not,
+ the Android 4.0 system components will not be available for download.</p>
+
+ <dl>
+ <dt>Dependencies:</dt>
+ <dd>
+ <ul>
+ <li>Android SDK Platform-tools revision 9 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r17 is designed for
+ use with ADT 17.0.0 and later. If you haven't already, we highly recommend updating your
+ <a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 17.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have
+ <a href="http://ant.apache.org/">Apache Ant</a> 1.8 or later.</li>
+ </ul>
+ </dd>
+ <dt>General notes:</dt>
+ <dd>
+ <ul>
+ <li>Emulator
+ <ul>
+ <li>Added support for hardware accelerated graphics rendering. This feature requires an
+API Level 15, Revision 3 or later system image.
+(<a href="{@docRoot}tools/devices/emulator.html#accel-graphics">more info</a>)
+ </li>
+ <li>Added support for running Android x86 system images in virtualization mode on
+Windows and Mac OS X.
+(<a href="{@docRoot}tools/devices/emulator.html#accel-vm">more info</a>)
+ <p class="note"><strong>Note:</strong> Use the Android SDK Manager to download and
+install x86 system images. Android x86 system images are not available for all API levels.</p>
+ </li>
+ <li>Added experimental support for multi-touch input by enabing the emulator to receive
+ touch input from a USB-tethered physical Android device.
+ (<a href="http://tools.android.com/tips/hardware-emulation">more info</a>)</li>
+ </ul>
+ </li>
+ <li>Added viewing of live detailed network usage of an app in DDMS. (<a
+ href="http://tools.android.com/recent/detailednetworkusageinddms">more info</a>)</li>
+ <li>ProGuard
+ <ul>
+ <li>Updated the bundled ProGuard tool to version 4.7. In addition to many new features,
+this update fixes the {@code Conversion to Dalvik format failed with error 1} error some users have
+experienced.</li>
+ <li>Updated the default {@code proguard.cfg} file with better default flags for
+ Android.</li>
+ <li>Split the ProGuard configuration file has been in half, with project specific flags
+kept in project and the generic Android flags distributed (and updated) with the tools
+themselves.</li>
+ </ul>
+ </li>
+ <li>Build
+ <ul>
+ <li>Added a feature that allows you to run some code only in debug mode. Builds now
+generate a class called {@code BuildConfig} containing a {@code DEBUG} constant that is
+automatically set according to your build type. You can check the ({@code BuildConfig.DEBUG})
+constant in your code to run debug-only functions.</li>
+ <li>Fixed issue when a project and its libraries include the same jar file in their libs
+ folder. (<a href="http://tools.android.com/recent/dealingwithdependenciesinandroidprojects">more
+ info</a>)</li>
+ <li>Added support for custom views with custom attributes in libraries. Layouts using
+custom attributes must use the namespace URI {@code http://schemas.android.com/apk/res-auto} instead
+of the URI that includes the app package name. This URI is replaced with the app specific one at
+build time.</li>
+ </ul>
+ </li>
+ <li>Lint
+ <ul>
+ <li>Updated Lint to check Android application code. Lint rules which previously
+performed pattern based searches in the application code (such as the unused resource check) have
+been rewritten to use the more accurate Java-style parse trees.</li>
+ <li>Added support for checking library projects. This change means that rules such as
+the unused resource check properly handle resources declared in a library project and referenced in
+a downstream project.</li>
+ <li>Added ability to suppress Lint warnings in Java code with the new
+{@code @SuppressLint} annotation, and in XML files with the new tools: namespace and
+ignore attribute. (<a
+ href="http://tools.android.com/recent/ignoringlintwarnings">more info</a>)</li>
+ <li>New Lint checks:
+ <ul>
+ <li>Added check for Android API calls that require a version of Android higher than
+ the minimum supported version. You can use the new {@code @TargetApi} annotation
+ to suppress warnings when the code is wrapped in a system version condition.
+ (<a href="http://tools.android.com/recent/lintapicheck">more info</a>)</li>
+ <li>Added over 20 new Lint rules, including checks for
+ <a href="http://tools.android.com/recent/lintperformancechecks">performance</a>,
+ XML layouts, manifest and file handling.</li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+ </ul>
+ </dd>
+ </dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 16</a> <em>(December 2011)</em>
+
+ <div class="toggleme">
+ <p class="caution"><strong>Important:</strong> To download the new Android
+ 4.0 system components from the Android SDK Manager, you must first update the
+ SDK tools to revision 14 or later and restart the Android SDK Manager. If you do not,
+ the Android 4.0 system components will not be available for download.</p>
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+ <ul>
+ <li>Android SDK Platform-tools revision 9 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r16 is designed for use
+ with ADT 16.0.0 and later. If you haven't already, we highly recommend updating your
+ <a href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 16.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+ Ant</a> 1.8 or later.</li>
+</ul>
+</dd>
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>Added Lint tools to detect common errors in Android projects.
+ (<a href="http://tools.android.com/recent/lint">more info</a>)</li>
+ <li>Added sensor emulation support, which allows the emulator to read sensor data from a
+ physical Android device.
+ (<a href="http://tools.android.com/recent/sensoremulation">more info</a>)</li>
+ <li>Added support for using a webcam to emulate a camera on Mac OS X.</li>
+ </ul>
+</dd>
+<dt>Bug fixes:</dt>
+<dd>
+ <ul>
+ <li>Snapshots now work for Android 4.0 system images.</li>
+ <li>Fixed several small issues for the build file.
+ (<a href="http://code.google.com/p/android/issues/detail?id=21023">Issue 21023</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=21267">Issue 21267</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=21465">Issue 21465</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=21525">Issue 21525</a>).</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 15</a> <em>(October 2011)</em>
+
+ <div class="toggleme">
+ <p class="caution"><strong>Important:</strong> To download the new Android
+ 4.0 system components from the Android SDK Manager, you must first update the
+ SDK tools to revision 14 or later and restart the Android SDK Manager. If you do not,
+ the Android 4.0 system components will not be available for download.</p>
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+ <ul><li>Android SDK Platform-tools revision 9 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r15 is designed for use
+ with ADT 15.0.0 and later. If you haven't already, we highly recommend updating your <a
+ href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 15.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+ Ant</a> 1.8 or later.</li>
+</ul>
+
+<dt>Bug fixes:</dt>
+<dd>
+ <ul>
+ <li>Fixed emulator crash on Linux due to improper webcam detection
+ (<a href="http://code.google.com/p/android/issues/detail?id=20952">Issue 20952</a>).</li>
+ <li>Fixed emulator issue when using the <code>-wipe-data</code> argument.</li>
+ <li>Fixed build issue when using Renderscript in projects that target API levels 11-13
+ (<a href="http://code.google.com/p/android/issues/detail?id=21006">Issue 21006</a>).</li>
+ <li>Fixed issue when creating an AVD using the GoogleTV addon
+ (<a href="http://code.google.com/p/android/issues/detail?id=20963">Issue 20963</a>).</li>
+ <li>Fixed <code>ant test</code>
+ (<a href="http://code.google.com/p/android/issues/detail?id=20979">Issue 20979</a>).</li>
+ <li>Fixed <code>android update project</code>
+ (<a href="http://code.google.com/p/android/issues/detail?id=20535">Issue 20535</a>).</li>
+ <li>Fixed scrolling issue in the new Logcat panel of DDMS.</li>
+ <li>Fixed issue with MonkeyRunner
+ (<a href="http://code.google.com/p/android/issues/detail?id=20964">Issue 20964</a>).</li>
+ <li>Fixed issues in the SDK Manager
+ (<a href="http://code.google.com/p/android/issues/detail?id=20939">Issue 20939</a>,
+ <a href="http://code.google.com/p/android/issues/detail?id=20607">Issue 20607</a>).</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+ SDK Tools, Revision 14</a> <em>(October 2011)</em>
+
+ <div class="toggleme">
+ <p class="note"><strong>Important:</strong> To download the new Android
+ 4.0 system components from the Android SDK Manager, you must first update the
+ SDK tools to revision 14 and restart the Android SDK Manager. If you do not,
+ the Android 4.0 system components will not be available for download.</p>
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+ <ul><li>Android SDK Platform-tools revision 8 or later.</li>
+ <li>If you are developing in Eclipse with ADT, note that the SDK Tools r14 is designed for use
+ with ADT 14.0.0 and later. If you haven't already, we highly recommend updating your <a
+ href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 14.0.0.</li>
+ <li>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+ Ant</a> 1.8 or later.</li>
+</ul>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>Added webcam support to Android 4.0 or later platforms to emulate rear-facing cameras when
+ one webcam is present, and to emulate both rear-facing and front-facing cameras when two
+ webcams are present. Webcam support is for Windows and Linux only.
+ Mac support will come in a later release.</li>
+ <li>Changed <code>default.properties</code> to <code>project.properties</code> and
+ <code>build.properties</code> to <code>ant.properties</code>. Any existing
+ projects that you build with Ant must be updated with the <code>android update project</code>
+ command.</li>
+ <li>Changed Ant <code>build.xml</code> file to support improvements to the
+ build system and added and modified Ant commands to support these changes. For a list of Ant
+commands, see the
+<a href="{@docRoot}tools/building/building-cmdline.html#AntReference">Ant Command
+Reference</a>.</li>
+ <li>Changed how library projects are built.</li>
+ <li>Improved incremental builds, so that resource compilation runs less frequently. Builds no
+ longer run when you edit strings or layouts (unless you add a new <code>id</code>) and no longer
+ run once for each library project.</li>
+ <li>Introduced a "PNG crunch cache" that only runs on modified PNG files, instead of
+ crunching all existing PNG files, all the time.</li>
+ <li>Revamped the SDK Manager UI (<a href="http://tools.android.com/recent/newsdkmanager">more
+info</a>).</li>
+ </ul>
+ <p>For a complete overview of the build system changes and what you need to do to support them,
+see the <a href="http://tools.android.com/recent/buildchangesinrevision14">Android Tools Project
+site</a>.</p>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+ width="9px" />
+SDK Tools, Revision 13</a> <em>(September 2011)</em>
+ <div class="toggleme">
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that the SDK Tools r13 is designed for use with
+ADT 12.0.0 and later. If you haven't already, we highly recommend updating your <a
+href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 12.0.0.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>Fix compilation issue in Ant (<code>dex</code> step) when paths have spaces.</li>
+ <li>Fix issue in emulator installation when paths have spaces.</li>
+ <li>Fix issue when AVD paths have spaces.</li>
+ <li>Fix rendering issue when using emulator scaling (<a href="http://code.google.com/p/android/issues/detail?id=18299">see more</a>).</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 12</a> <em>(July 2011)</em>
+ <div class="toggleme">
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that the SDK Tools r12 is designed for use with
+ADT 12.0.0 and later. If you haven't already, we highly recommend updating your <a
+href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 12.0.0.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>The AVD manager and emulator can now use system images
+ compiled for ARM v7 and x86 CPUs.</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 11</a> <em>(May 2011)</em>
+ <div class="toggleme">
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that the SDK Tools r11 is designed for use with
+ADT 10.0.1 and later. If you haven't already, we highly recommend updating your <a
+href="{@docRoot}tools/sdk/eclipse-adt.html">ADT Plugin</a> to 10.0.1.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>Miscellaneous emulator changes to support Android 3.1.</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+SDK Tools, Revision 10</a> <em>(February 2011)</em>
+ <div class="toggleme">
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that the SDK Tools r10 is
+designed for use with ADT 10.0.0 and later. After installing SDK Tools r10, we
+highly recommend updating your ADT Plugin to 10.0.0.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>The tools now automatically generate Java Programming Language source files (in the
+<code>gen</code> directory) and
+ bytecode (in the <code>res/raw</code> directory) from your native <code>.rs</code> files</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 9</a> <em>(January 2011)</em>
+ <div class="toggleme">
+ <dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that the SDK Tools r9 is
+designed for use with ADT 9.0.0 and later. After installing SDK Tools r9, we
+highly recommend updating your ADT Plugin to 9.0.0.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<dt>Upgrading to SDK Tools r9:</dt>
+<dd>
+<p>If you are upgrading to SDK Tools r9 from SDK Tools r7 or earlier, the default installed location
+for the <code>adb</code> tool has changed from <code><<em>SDK</em>>/tools/adb</code> to
+<code><<em>SDK</em>>/platform-tools/adb</code>. This means that you should
+add the new location to your PATH and modify any custom build scripts to
+reference the new location. Copying the <code>adb</code> executable from the new
+location to the old is not recommended, since subsequent updates to the SDK
+Tools will delete the file.</p>
+</dd>
+
+<dt>General notes:</dt>
+<dd>
+ <ul>
+ <li>The default ProGuard configuration, <code>proguard.cfg</code>, now ignores the following classes:
+ <ul>
+ <li>classes that extend {@link android.preference.Preference}</li>
+ <li>classes that extend {@link android.app.backup.BackupAgentHelper}</li>
+ </ul>
+ </li>
+ <li>Ant lib rules now allow you to override <code>java.encoding</code>, <code>java.source</code>,
+ and <code>java.target</code> properties.</li>
+ <li>The default encoding for the <code>javac</code> Ant task is now UTF-8.</li>
+ <li>The LogCat view in DDMS now properly displays UTF-8 characters.</li>
+ <li>The SDK Manager is more reliable on Windows. For details on the improvements, see the
+ <a href="http://tools.android.com/recent/sdkmanagerfixes">Android Tools Project Site</a>. </li>
+ <li>Early look at the new snapshot feature: To improve startup time for the emulator, you can
+enable snapshots for the system state. The emulator will then restore to the state when it last
+closed almost instantly. <strong>Note:</strong> The snapshot feature is still under active
+development and might not always perform as expected.</li>
+ <li>Fixed the missing JAR file error that prevented <code>draw9patch</code> from running.</li>
+ <li>Fixed the Windows launch scripts <code>hierarchyviewer</code> and <code>ddms</code> to support
+ the new location of <code>adb</code>.</li>
+ <li>Known issues with emulator performance: Because the Android emulator must simulate the ARM
+instruction set architecture on your computer, emulator performance is slow. We're working hard to
+resolve the performance issues and it will improve in future releases.</li>
+ </ul>
+</dd>
+</dl>
+</div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 8</a> <em>(December 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that SDK Tools r8 is
+designed for use with ADT 8.0.0 and later. After installing SDK Tools r8, we
+highly recommend updating your ADT Plugin to 8.0.0.</p>
+
+<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache
+Ant</a> 1.8 or later.</p>
+
+<p>Also note that SDK Tools r8 requires a new SDK component called
+<em>Platform-tools</em>. The new Platform-tools component lets all SDK platforms
+(Android 2.1, Android 2.2, and so on) use the same (latest) version of build
+tools such as <code>adb</code>, <code>aapt</code>, <code>aidl</code>, and
+<code>dx</code>. To download the Platform-tools component, use the Android SDK
+Manager, as described in <a href="{@docRoot}sdk/exploring.html">Exploring the
+SDK</a></p>
+
+<dt>Upgrading from SDK Tools r7:</dt>
+<dd>
+<p>If you are upgrading to SDK Tools r8 from an earlier version, note that the
+the default installed location for the <code>adb</code> tool has changed from
+<code><<em>SDK</em>>/tools/adb</code> to
+<code><<em>SDK</em>>/platform-tools/adb</code>. This means that you should
+add the new location to your PATH and modify any custom build scripts to
+reference the new location. Copying the <code>adb</code> executable from the new
+location to the old is not recommended, since subsequent updates to the SDK
+Tools will delete the file.</p>
+</dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>All SDK platforms now support Library Projects.</li>
+<li>Support for a true debug build. Developers no longer need to add the
+<code>android:debuggable</code> attribute to the
+<code><application></code> tag in the manifest — the build tools add
+the attribute automatically. In Eclipse/ADT, all incremental builds are assumed
+to be debug builds, so the tools insert <code>android:debuggable="true"</code>.
+When exporting a signed release build, the tools do not add the attribute. In
+Ant, a <code>ant debug</code> command automatically inserts the
+<code>android:debuggable="true"</code> attribute, while <code>ant release</code>
+does not. If <code>android:debuggable="true"</code> is manually set, then
+<code>ant release</code> will actually do a debug build, rather than a release
+build.</li>
+<li>Automatic ProGuard support in release builds. Developers generate a ProGuard
+configuration file using the <code>android</code> tool — the build tools
+then automatically run ProGuard against the project sources during the build.
+For more information, see the <a
+href="{@docRoot}tools/help/proguard.html">ProGuard</a>
+documentation. </li>
+<li>New overridable Ant javac properties: <code>java.encoding</code>,
+<code>java.source</code>, and <code>java.target</code> (default values are
+"ascii", "1.5", and "1.5", respectively).</li>
+<li>New UI for the HierarchyViewer tool.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 7</a> <em>(September 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that SDK Tools r7 is
+designed for use with ADT 0.9.8 and later. After installing SDK Tools r7, we
+highly recommend updating your ADT Plugin to 0.9.8.</p>
+</dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>Added support for library projects that depend on other library projects.</li>
+<li>Adds support for aidl files in library projects.</li>
+<li>Adds support for extension targets in Ant build to perform tasks between the
+normal tasks: <code>-pre-build</code>, <code>-pre-compile</code>, and
+<code>-post-compile</code>.</li>
+<li>Adds support for "headless" SDK update. See <code>android -h update sdk</code>
+for more information.</li>
+<li>Fixes location control in DDMS to work in any locale not using '.' as a
+decimal point.</li>
+</ul>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 6</a> <em>(May 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd>
+<p>If you are developing in Eclipse with ADT, note that SDK Tools r6 is
+designed for use with ADT 0.9.7 and later. After installing SDK Tools r6, we
+highly recommend updating your ADT Plugin to 0.9.7.</p>
+</dd>
+
+<dt>Library projects:</dt>
+<dd>
+<p>The SDK Tools now support the use of <em>library projects</em> during
+development, a capability that lets you store shared Android application
+code and resources in a separate development project. You can then reference the
+library project from other Android projects and, at build time, the tools
+compile the shared code and resources as part of the dependent applications.
+More information about this feature is available in the <a
+href="{@docRoot}tools/projects/index.html#LibraryProjects">Creating and Managing Projects</a> document.</p>
+<p>If you are developing in Eclipse, <a href="eclipse-adt.html">ADT</a>
+provides the equivalent library project support.</p>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 5</a> <em>(March 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd><ul>
+<li>If you are developing in Eclipse with ADT, note that SDK Tools r5 is
+designed for use with ADT 0.9.6 and later. After installing SDK Tools r5, we
+highly recommend updating your ADT Plugin to 0.9.6.</li>
+<li>For Mac OS platforms, OS X 10.4.x (Tiger) is no longer
+officially supported. </li>
+</ul>
+</dd>
+
+<dt>SDK and AVD Manager:</dt>
+<dd>
+<ul>
+<li>Fixes SSL download for the standalone version of the SDK Updater.</li>
+<li>Fixes issue with 64-bit JVM on Windows.</li>
+<li>Adds support for platform samples components.</li>
+<li>Improves support for dependency between components.</li>
+<li>AVDs now sorted by API level.</li>
+<li>The AVD creation dialog now enforces a minimum SD card size of 9MB.</li>
+<li>Prevents deletion of running AVDs.</li>
+<li>Settings are now automatically saved, no need to click "Apply".</li>
+</ul>
+</dd>
+
+<dt>Emulator:</dt>
+<dd>
+<ul>
+<li>Emulator now requires SD card to be 9MB or more.</li>
+</ul>
+</dd>
+
+<dt>Layoutopt:</dt>
+<dd>
+<ul>
+<li>Fixes <code>layoutopt.bat</code> to execute correctly on Windows.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 4</a> <em>(December 2009)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd><p>SDK Tools r4 is compatible with ADT 0.9.5 and later, but not
+compatible with earlier versions. If you are developing in Eclipse with ADT, you
+<strong>must</strong> update your ADT plugin to version 0.9.5 or higher if you
+install SDK Tools r4 in your SDK. </p></dd>
+
+<dt>General notes:</dt>
+<dd>
+<ul>
+<li>Launcher script now forces GDK_NATIVE_WINDOW=true (linux only), to fix a
+compatibility issue between GTK and SWT.</li>
+</ul>
+</dd>
+
+<dt>Android SDK and AVD Manager:</dt>
+<dd>
+<ul>
+<li>AVD Launch dialog now shows scale value.</li>
+<li>Fixes potential NPE in SDK Manager on AVD launch, for older AVD with no
+skin name specified.</li>
+<li>Fixes XML validation issue in on older Java versions.</li>
+<li>No longer forces the use of Java 1.5 on Mac OS X.</li>
+</ul>
+</dd>
+
+<dt>Emulator:</dt>
+<dd>
+<ul>
+<li>No longer limits the size of the system partition.</li>
+</ul>
+</dd>
+
+<dt>Ant build tools:</dt>
+<dd>
+<ul>
+<li>.apk packaging now properly ignores vi swap files as well as hidden files.</li>
+</ul>
+</dd>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+SDK Tools, Revision 3</a> <em>(October 2009)</em>
+ <div class="toggleme">
+
+<dl>
+<dt>Dependencies:</dt>
+<dd><p>SDK Tools r3 is compatible with ADT 0.9.4 and later, but not
+compatible with earlier versions. If you are developing in Eclipse with ADT, you
+<strong>must</strong> update your ADT plugin to version 0.9.4 or higher if you
+install SDK Tools r3 in your SDK.</p>
+</dd>
+
+<dt>Android tool:</dt>
+<dd>
+<ul>
+<li>Adds new <code>android create test-project</code> and <code>android update
+test-project</code> commands to allow for greater flexibility in the location of the
+main and test projects.</li>
+</ul>
+</dd>
+
+<dt>DDMS:</dt>
+<dd>
+<ul>
+<li>Adds a button to dump HPROF file for running applications (app must be able
+to write to the sdcard).</li>
+<li>Button to start/stop profiling of a running application (app must be able to
+write to the sdcard). Upon stop, Traceview will automatically be launched to
+display the trace.</li>
+<li>Fixed DDMS, Traceview, and the AVD Mananger/SDK Updater to run on Mac OS X
+10.6.</li>
+<li>Fixed screenshot support for devices running 32-bit framebuffer.</li>
+</ul>
+</dd>
+
+<dt>Android SDK and AVD Manager:</dt>
+<dd>
+<ul>
+<li>Provides a new UI that lets you set options for controlling
+the emulator skin, screen size/density, and scale factor used when launching
+an AVD.</li>
+<li>Provides improved AVD creation UI, which lets you customize the hardware
+properties of your AVDs.</li>
+<li>Now enforces dependencies between platforms and tools components, and
+between SDK add-ons and platforms.</li>
+</ul>
+</dd>
+
+<dt>Layoutopt, a new tool for optimizing layouts:</dt>
+
+<dd><p>The SDK Tools r3 package includes <code>layoutopt</code>, a new command-line
+tool that helps you optimize your layout hierarchies. When run against your
+layout files, the tool analyzes their hierarchies and notifies you of
+inefficiencies and other potential issues. The tool also provides simple
+solutions for the issues it finds. For usage, see <a
+href="/tools/help/layoutopt.html">layoutopt</a>.</p>
+</dd>
+</dl>
+ </div>
+</div>
diff --git a/docs/html/tools/sdk/usb-drivers.jd b/docs/html/tools/sdk/usb-drivers.jd
new file mode 100644
index 0000000..27e89de
--- /dev/null
+++ b/docs/html/tools/sdk/usb-drivers.jd
@@ -0,0 +1,9 @@
+page.title=Android Development Platforms
+
+@jd:body
+
+
+
+<p>A page that lists platforms and links to release notes. Links to dashboards etc.</p>
+
+
diff --git a/docs/html/tools/sdk/win-usb.jd b/docs/html/tools/sdk/win-usb.jd
new file mode 100644
index 0000000..d322340
--- /dev/null
+++ b/docs/html/tools/sdk/win-usb.jd
@@ -0,0 +1,172 @@
+page.title=Google USB Driver
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#notes">Revisions</a></li>
+ <li><a href="#WinUsbDriver">Downloading the Google USB Driver</a></li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/extras/oem-usb.html#InstallingDriver">Installing a USB Driver</a></li>
+ <li><a href="{@docRoot}tools/device.html">Using Hardware Devices</a></li>
+ <li><a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a></li>
+ </ol>
+</div>
+</div>
+
+<p>The Google USB driver is a downloadable component for the Android SDK, available
+from the SDK Manager. The driver is for Windows only and provides the necessary drivers for the
+following devices:</p>
+ <ul>
+ <li>ADP1 / T-Mobile G1*</li>
+ <li>ADP2 / Google Ion / T-Mobile myTouch 3G*</li>
+ <li>Verizon Droid*</li>
+ <li>Nexus One</li>
+ <li>Nexus S</li>
+ </ul>
+ <p>* <em>Or similar hardware on other carriers</em></p>
+
+ <p>All other devices require Windows drivers provided by the hardware manufacturer, as listed in
+the <a href="{@docRoot}tools/extras/oem-usb.html">OEM USB Drivers</a> document. The Galaxy Nexus
+driver is also distributed by <a
+href="http://www.samsung.com/us/support/downloads/verizon-wireless/SCH-I515MSAVZW">Samsung</a>
+(listed as model SCH-I515).</p>
+
+<p class="note"><strong>Note:</strong>
+If you're developing on Mac OS X or Linux, then you do not need to install a USB driver. To start
+developing with your device, also read <a href="{@docRoot}tools/device.html">Using
+Hardware Devices</a>.</p>
+
+<p>The sections below provide instructions on how to download and install the Google USB Driver
+for Windows. </p>
+
+
+
+
+<h2 id="notes">Revisions</h2>
+
+<p>The sections below provide notes about successive revisions of the USB Driver
+for Windows, as denoted by revision number. To determine what revision of the
+USB Driver for Windows you are using, refer to the "Installed Packages" listing
+in the Android SDK Manager.</p>
+
+<script type="text/javascript">
+function toggleDiv(link) {
+ var toggleable = $(link).parent();
+ if (toggleable.hasClass("closed")) {
+ //$(".toggleme", toggleable).slideDown("fast");
+ toggleable.removeClass("closed");
+ toggleable.addClass("open");
+ $(".toggle-img", toggleable).attr("title", "hide").attr("src", (toRoot + "assets/images/triangle-opened.png"));
+ } else {
+ //$(".toggleme", toggleable).slideUp("fast");
+ toggleable.removeClass("open");
+ toggleable.addClass("closed");
+ $(".toggle-img", toggleable).attr("title", "show").attr("src", (toRoot + "assets/images/triangle-closed.png"));
+ }
+ return false;
+}
+</script>
+<style>
+.toggleable {
+padding: .25em 1em;
+}
+.toggleme {
+ padding: 1em 1em 0 2em;
+ line-height:1em;
+}
+.toggleable a {
+ text-decoration:none;
+}
+.toggleme a {
+ text-decoration:underline;
+}
+.toggleable.closed .toggleme {
+ display:none;
+}
+#jd-content .toggle-img {
+ margin:0;
+}
+</style>
+
+<div class="toggleable opened">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px"
+width="9px" />
+USB Driver for Windows, Revision 4</a> <em>(December 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt><p>Adds support for the Nexus S.</p></dt>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px"
+width="9px" />
+USB Driver for Windows, Revision 3</a> <em>(January 2010)</em>
+ <div class="toggleme">
+
+<dl>
+<dt><p>Adds support for the Nexus One.</p></dt>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+USB Driver for Windows, Revision 2</a> <em>(November 2009)</em>
+ <div class="toggleme">
+
+<dl>
+<dt><p>Adds support for the Verizon Droid (or similar hardware on
+other carriers).</p></dt>
+</dl>
+ </div>
+</div>
+
+<div class="toggleable closed">
+ <a href="#" onclick="return toggleDiv(this)">
+ <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" />
+USB Driver for Windows, Revision 1</a> <em>(October 2009)</em>
+ <div class="toggleme">
+
+<dl>
+<dt><p>Initial release of the WinUsb-based driver, with support
+for the T-Mobile G1 and myTouch 3G (and similar devices).</p></dt>
+</dl>
+ </div>
+</div>
+
+
+<h2 id="WinUsbDriver">Downloading the Google USB Driver</h2>
+
+<div class="figure" style="width:536px;margin:0">
+ <img src="{@docRoot}images/developing/sdk-usb-driver.png" alt="" />
+ <p class="img-caption"><strong>Figure 1.</strong> The SDK Manager
+ with the Google USB Driver selected.</p>
+</div>
+
+<p>The USB Driver for Windows is available for download as an optional SDK
+component. You need the driver only if you are developing on Windows and
+want to connect an Android-powered device (ADP, Nexus One, or Nexus S) to your
+development environment over USB. </p>
+
+<p>To download the driver, use the Android SDK Manager tool that is
+included with the <a href="{@docRoot}sdk/index.html">Android SDK</a>:</p>
+<ol>
+ <li>Launch the Android SDK Manager by double-clicking <code>SDK Manager.exe</code>,
+ at the root of your SDK directory.</li>
+ <li>Expand <em>Extras</em>.</li>
+ <li>Check <strong>Google USB Driver package</strong> and click <strong>Install</strong>.</li>
+ <li>Proceed to install the package. When done, the driver files are
+downloaded into the <code><sdk>\extras\google\usb_driver\</code> directory.</li>
+</ol>
+
+<p>For installation information, read <a href="{@docRoot}tools/extras/oem-usb.html#InstallingDriver">Installing a USB Driver</a>.</p>
diff --git a/docs/html/tools/testing/activity_test.jd b/docs/html/tools/testing/activity_test.jd
new file mode 100644
index 0000000..8288249
--- /dev/null
+++ b/docs/html/tools/testing/activity_test.jd
@@ -0,0 +1,1334 @@
+page.title=Activity Testing Tutorial
+parent.title=Testing
+parent.link=index.html
+@jd:body
+ <div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#Prerequisites">Prerequisites</a>
+ </li>
+ <li>
+ <a href="#DownloadCode">Installing the Tutorial Sample Code</a>
+ </li>
+ <li>
+ <a href="#SetupEmulator">Setting Up the Emulator</a>
+ </li>
+ <li>
+ <a href="#SetupProjects">Setting Up the Projects</a>
+ </li>
+ <li>
+ <a href="#CreateTestCaseClass">Creating the Test Case Class</a>
+ <ol>
+ <li>
+ <a href="#AddTestCaseClass">Adding the test case class file</a>
+ </li>
+ <li>
+ <a href="#AddConstructor">Adding the test case constructor</a>
+ </li>
+ <li>
+ <a href="#AddSetupMethod">Adding the setup method</a>
+ </li>
+ <li>
+ <a href="#AddPreConditionsTest">Adding an initial conditions test</a>
+ </li>
+ <li>
+ <a href="#AddUITest">Adding a UI test</a>
+ </li>
+ <li>
+ <a href="#StateManagementTests">Adding state management tests</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#RunTests">Running the Tests and Seeing the Results</a>
+ </li>
+ <li>
+ <a href="#TestFailure">Forcing Some Tests to Fail</a>
+ </li>
+ <li>
+ <a href="#NextSteps">Next Steps</a>
+ </li>
+</ol>
+<h2 id="#Appendix">Appendix</h2>
+<ol>
+ <li>
+ <a href="#InstallCompletedTestApp">Installing the Completed Test Application File</a>
+ </li>
+ <li>
+ <a href="#EditorCommandLine">For Users Not Developing In Eclipse</a>
+ </li>
+</ol>
+<h2>See Also</h2>
+<ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>
+ </li>
+ <li>
+ {@link android.test.ActivityInstrumentationTestCase2}
+ </li>
+ <li>
+ {@link junit.framework.Assert}
+ </li>
+ <li>
+ {@link android.test.InstrumentationTestRunner}
+ </li>
+</ol>
+</div>
+</div>
+<p>
+ Android includes powerful tools for testing applications. The tools extend JUnit with additional features, provide convenience classes for mock Android system objects, and use
+ instrumentation to give you control over your main application while you are testing it. The entire Android testing environment is discussed in the document
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>.
+</p>
+<p>
+ This tutorial demonstrates the Android testing tools by presenting a simple Android application and then leading you step-by-step through the creation of a test application for it.
+ The test application demonstrates these key points:
+</p>
+ <ul>
+ <li>
+ An Android test is itself an Android application that is linked to the application under test by entries in its <code>AndroidManifest.xml</code> file.
+ </li>
+ <li>
+ Instead of Android components, an Android test application contains one or more test cases. Each of these is a separate class definition.
+ </li>
+ <li>
+ Android test case classes extend the JUnit {@link junit.framework.TestCase} class.
+ </li>
+ <li>
+ Android test case classes for activities extend JUnit and also connect you to the application under test with instrumentation. You can send keystroke or touch events directly to the UI.
+ </li>
+ <li>
+ You choose an Android test case class based on the type of component (application, activity, content provider, or service) you are testing.
+ </li>
+ <li>
+ Additional test tools in Eclipse/ADT provide integrated support for creating test applications, running them, and viewing the results.
+ </li>
+ </ul>
+<p>
+ The test application contains methods that perform the following tests:
+</p>
+ <ul>
+ <li>
+ Initial conditions test. Tests that the application under test initializes correctly. This is also a unit test of the application's
+ {@link android.app.Activity#onCreate(android.os.Bundle) onCreate()} method. Testing initial conditions also provides a confidence measure for subsequent tests.
+ </li>
+ <li>
+ UI test. Tests that the main UI operation works correctly. This test demonstrates the instrumentation features available in activity testing.
+ It shows that you can automate UI tests by sending key events from the test application to the main application.
+ </li>
+ <li>
+ State management tests. Test the application's code for saving state. This test demonstrates the instrumentation features of the test runner, which
+ are available for testing any component.
+ </li>
+ </ul>
+<h2 id="Prerequisites">Prerequisites</h2>
+<p>
+ The instructions and code in this tutorial depend on the following:
+</p>
+ <ul>
+ <li>
+ Basic knowledge of Android programming. If you haven't yet written an Android application,
+ do the class
+ <a href="{@docRoot}training/basics/firstapp/index.html">Building Your First App</a>.
+ If you want to learn more about Spinner, the application under test, then you
+ might want to review the "Spinner" sample app.
+ </li>
+ <li>
+ Some familiarity with the Android testing framework and concepts. If you haven't explored
+ Android testing yet, start by reading the
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>
+ guide.
+ </li>
+ <li>
+ Eclipse with ADT. This tutorial describes how to set up and run a test application using
+ Eclipse with ADT. If you haven't yet installed Eclipse and the ADT plugin,
+ follow the steps in <a href="{@docRoot}sdk/installing/index.html">Installing the SDK</a>
+ to install them before continuing. If you are not developing in Eclipse, you will
+ find instructions for setting up and running the test application in the
+ <a href="#EditorCommandLine">appendix</a> of this document.
+ </li>
+ <li>
+ Android 1.5 platform (API Level 3) or higher. You must have the Android 1.5 platform
+ (API Level 3) or higher installed in your SDK, because this tutorial uses APIs that
+ were introduced in that version.
+ <p>
+ If you are not sure which platforms are installed in your SDK,
+ open the Android SDK and AVD Manager and check in the
+ <strong>Installed Packages</strong> panel.
+ If aren't sure how to download a platform into your SDK,
+ read <a href="{@docRoot}sdk/exploring.html">Exploring the SDK</a>.
+ </p>
+ </li>
+ </ul>
+<h2 id="DownloadCode">Installing the Tutorial Sample Code</h2>
+<p>
+ During this tutorial, you will be working with sample code that is provided as part
+ of the downloadable Samples component of the SDK. Specifically, you will be working
+ with a pair of related sample applications — an application under test and a test
+ application:
+</p>
+ <ul>
+ <li>
+ Spinner is the application under test. This tutorial focuses on the
+ common situation of writing tests for an application that already exists, so the main
+ application is provided to you.
+ </li>
+ <li>
+ SpinnerTest is the test application. In the tutorial, you create this application
+ step-by-step. If you want to run quickly through the tutorial,
+ you can install the completed SpinnerTest application first, and then follow the
+ text. You may get more from the tutorial, however, if you create the test application
+ as you go. The instructions for installing the completed test application are in the
+ section
+ <a href="#InstallCompletedTestApp">Installing the Completed Test Application File</a>.
+ </li>
+ </ul>
+<p>
+ The sample applications are described in more detail in the
+ <a href="{@docRoot}tools/samples/index.html">Samples</a> topic. Follow the instructions to
+ download the version of the samples that's appropriate for the platform you're working with.
+</p>
+<h2 id="SetupEmulator">Setting Up the Emulator</h2>
+<p>
+ In this tutorial, you will use the Android emulator to run applications. The emulator needs
+ an Android Virtual Device (AVD) with an API level equal to or higher than the one you set for the projects in the previous step.
+ To find out how to check this and create the right AVD if necessary,
+ see <a href="{@docRoot}tools/devices/managing-avds.html">Creating an AVD</a>.
+</p>
+<p>
+ As a test of the AVD and emulator, run the SpinnerActivity application in Eclipse with ADT. When it starts,
+ click the large downward-pointing arrow to the right of the spinner text. You see the spinner expand and display the title "Select a planet" at the top.
+ Click one of the other planets. The spinner closes, and your selection appears below it on the screen.
+</p>
+<h2 id="SetupProjects">Setting Up the Projects</h2>
+<p>
+ When you are ready to get started with the tutorial, begin by setting up Eclipse projects for
+ both Spinner (the application under test) and SpinnerTest (the test application).
+</p>
+<p>
+ You'll be using the Spinner application as-is, without modification, so you'll be loading it
+ into Eclipse as a new Android project from existing source. In the process, you'll be
+ creating a new test project associated with Spinner that will contain the SpinnerTest
+ application. The SpinnerTest application will be completely new and you'll be
+ using the code examples in this tutorial to add test classes and tests to it.
+</p>
+<p>
+ To install the Spinner app in a new Android project from existing source, following these steps:
+</p>
+<ol>
+ <li>
+ In Eclipse, select <strong>File</strong> > <strong>New</strong> > <strong>Project</strong> > <strong>Android</strong> > <strong>Android Project</strong>,
+ then click Next. The <strong>New Android Project</strong> dialog appears.
+ </li>
+ <li>
+ In the <em>Project name</em> text box, enter "SpinnerActivity". The <em>Properties</em> area is filled in automatically.
+ </li>
+ <li>
+ In the <em>Contents</em> area, set "Create project from existing source".
+ </li>
+ <li>
+ For <em>Location</em>, click <strong>Browse</strong>, navigate to the directory <code><SDK_path>/samples/android-8/Spinner</code>,
+ then click Open. The directory name <code><SDK_path>/samples/android-8/Spinner</code> now appears in the <em>Location</em> text box.
+ </li>
+ <li>
+ In the <em>Build Target</em> area, set a API level of 3 or higher. If you are already developing with a particular target, and it is API level 3 or higher, then use that target.
+ </li>
+ <li>
+ In the <em>Properties</em> area, in the <em>Min SDK Version:</em>, enter "3".
+ </li>
+ <li>
+ You should now see these values:
+ <ul>
+ <li><em>Project Name:</em> "SpinnerActivity"</li>
+ <li><em>Create project from existing source:</em> set</li>
+ <li><em>Location:</em> "<code><SDK_path>/samples/android-8/Spinner</code>"</li>
+ <li><em>Build Target:</em> "API level of 3 or higher" (<em>Target Name</em> "Android 1.5 or higher")</li>
+ <li><em>Package name:</em> (disabled, set to "<code>com.android.example.spinner</code>")</li>
+ <li><em>Create Activity:</em> (disabled, set to ".SpinnerActivity")</li>
+ <li><em>Min SDK Version:</em> "3"</li>
+ </ul>
+ <p>
+ The following screenshot summarizes these values:
+ </p>
+ <a href="{@docRoot}images/testing/eclipse_new_android_project_complete_callouts.png">
+ <img src="{@docRoot}images/testing/eclipse_new_android_project_complete_callouts.png" alt="New Android Project dialog with filled-in values" style="height:230px"/>
+ </a>
+
+ </li>
+</ol>
+<p>
+ To create a new test project for the SpinnerTest application, follow these steps:
+</p>
+<ol>
+ <li>
+ Click Next. The <strong>New Android Test Project</strong> dialog appears.
+ </li>
+ <li>
+ Set "Create a Test Project".
+ </li>
+ <li>
+ Leave the other values unchanged. The result should be:
+ <ul>
+ <li><em>Create a Test Project:</em> checked</li>
+ <li><em>Test Project Name:</em> "SpinnerActivityTest"</li>
+ <li><em>Use default location:</em> checked (this should contain the directory name "<code>workspace/SpinnerActivityTest</code>").</li>
+ <li><em>Build Target:</em> Use the same API level you used in the previous step.</li>
+ <li><em>Application name:</em> "SpinnerActivityTest"</li>
+ <li><em>Package name:</em> "<code>com.android.example.spinner.test</code>"</li>
+ <li><em>Min SDK Version:</em> "3"</li>
+ </ul>
+ <p>
+ The following screenshot summarizes these values:
+ </p>
+ <a href="{@docRoot}images/testing/eclipse_new_android_testproject_complete_callouts.png">
+ <img src="{@docRoot}images/testing/eclipse_new_android_testproject_complete_callouts.png" alt="New Android Test Project dialog with filled-in values" style="height:230px"/>
+ </a>
+ </li>
+ <li>
+ Click Finish. Entries for SpinnerActivity and SpinnerActivityTest should appear in the
+ <strong>Package Explorer</strong>.
+ <p class="note">
+ <strong>Note:</strong> If you set <em>Build Target</em> to an API level higher than "3", you will see the warning
+ "The API level for the selected SDK target does not match the Min SDK version". You do not need to change the API level or the Min SDK version.
+ The message tells you that you are building the projects with one particular API level, but specifying that a lower API level is required. This may
+ occur if you have chosen not to install the optional earlier API levels.
+ </p>
+ <p>
+ If you see errors listed in the <strong>Problems</strong> pane at the bottom of the Eclipse window, or if a red error marker appears next to
+ the entry for SpinnerActivity in the Package Explorer, highlight the SpinnerActivity entry and then select
+ <strong>Project</strong> > <strong>Clean</strong>. This should fix any errors.
+ </p>
+ </li>
+</ol>
+<p>
+ You now have the application under test in the SpinnerActivity project,
+ and an empty test project in SpinnerActivityTest. You may
+ notice that the two projects are in different directories, but Eclipse with
+ ADT handles this automatically. You should have no problem in either building or running them.
+</p>
+<p>
+ Notice that Eclipse and ADT have already done some initial setup for your test application.
+ Expand the SpinnerActivityTest project, and notice that it already has an
+ Android manifest file <code>AndroidManifest.xml</code>.
+ Eclipse with ADT created this when you added the test project.
+ Also, the test application is already set up to use instrumentation. You can see this
+ by examining <code>AndroidManifest.xml</code>.
+ Open it, then at the bottom of the center pane click <strong>AndroidManifest.xml</strong>
+ to display the XML contents:
+</p>
+<pre>
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.example.spinner.test"
+ android:versionCode="1"
+ android:versionName="1.0">
+ <uses-sdk android:minSdkVersion="3" />
+ <instrumentation
+ android:targetPackage="com.android.example.spinner"
+ android:name="android.test.InstrumentationTestRunner" />
+ <application android:icon="@drawable/icon" android:label="@string/app_name">
+ <uses-library android:name="android.test.runner" />
+ ...
+ </application>
+</manifest>
+</pre>
+<p>
+ Notice the <code><instrumentation></code> element. The attribute
+ <code>android:targetPackage="com.android.example.spinner"</code> tells Android that the
+ application under test is defined in the Android package
+ <code>com.android.example.spinner</code>. Android now knows to use that
+ package's <code>AndroidManifest.xml</code> file to launch the application under test.
+ The <code><instrumentation></code> element also contains the attribute
+ <code>android:name="android.test.InstrumentationTestRunner"</code>, which tells Android
+ instrumentation to run the test application with Android's instrumentation-enabled test runner.
+</p>
+<h2 id="CreateTestCaseClass">Creating the Test Case Class</h2>
+
+<p>
+ You now have a test project SpinnerActivityTest, and the basic structure of a test
+ application also called SpinnerActivityTest. The basic structure includes all the files and
+ directories you need to build and run a test application, except for the class that
+ contains your tests (the test case class).
+</p>
+<p>
+ The next step is to define the test case class. In this tutorial, you'll be creating a
+ test case class that includes:
+</p>
+<ul>
+ <li>
+ Test setup. This use of the JUnit {@link junit.framework.TestCase#setUp() setUp()}
+ method demonstrates some of the tasks you might perform before running an Android test.
+ </li>
+ <li>
+ Testing initial conditions. This test demonstrates a good testing technique.
+ It also demonstrates that with Android instrumentation you can look at the application
+ under test <em>before</em> the main activity starts. The test checks that the application's
+ important objects have been initialized.
+ If the test fails, you then know that any other tests against the application are
+ unreliable, since the application was running in an incorrect state.
+ <p class="note">
+ <strong>Note:</strong> The purpose of testing initial conditions is not the same as
+ using <code>setUp()</code>. The JUnit {@link junit.framework.TestCase#setUp()} runs once
+ before <strong>each test method</strong>, and its purpose is to create a clean test
+ environment. The initial conditions test runs once, and its purpose is to verify that the
+ application under test is ready to be tested.
+ </p>
+ </li>
+ <li>
+ Testing the UI. This test shows how to control the main application's UI
+ with instrumentation, a powerful automation feature of Android testing.
+ </li>
+ <li>
+ Testing state management. This test shows some techniques for testing how
+ well the application maintains state in the Android environment. Remember that to
+ provide a satisfactory user experience, your application must never lose its current state,
+ even if it's interrupted by a phone call or destroyed because of memory constraints.
+ The Android activity lifecycle provides ways to maintain state, and the
+ <code>SpinnerActivity</code> application uses them. The test shows the techniques for
+ verifying that they work.
+ </li>
+</ul>
+<p>
+ Android tests are contained in a special type of Android application that contains one or more test class definitions. Each of these contains
+ one or more test methods that do the actual tests. In this tutorial, you will first add a test case class, and then add tests to it.
+</p>
+<p>
+ You first choose an Android test case class to extend. You choose from the base test case classes according to the Android component you are testing and the types of tests you are doing.
+ In this tutorial, the application under test has a single simple activity, so the test case class will be for an Activity component. Android offers several, but the one that tests in
+ the most realistic environment is {@link android.test.ActivityInstrumentationTestCase2}, so you will use it as the base class. Like all activity test case classes,
+ <code>ActivityInstrumentationTestCase2</code> offers convenience methods for interacting directly with the UI of the application under test.
+</p>
+<h3 id="AddTestCaseClass">Adding the test case class file</h3>
+<p>
+ To add <code>ActivityInstrumentationTestCase2</code> as the base test case class, follow these steps:
+</p>
+<ol>
+ <li>
+ In the Package Explorer, expand the test project SpinnerActivityTest if it is not open already.
+ </li>
+ <li>
+ Within SpinnerActivityTest, expand the <code>src/</code> folder and then the package marker for
+ <code>com.android.example.spinner.test</code>. Right-click on the package name and select <strong>New</strong> > <strong>Class</strong>:<br/>
+ <a href="{@docRoot}images/testing/spinner_create_test_class_callouts.png">
+ <img alt="Menu for creating a new class in the test application" src="{@docRoot}images/testing/spinner_create_test_class_callouts.png" style="height:230px"/>
+ </a>
+ <p>
+ The <strong>New Java Class</strong> wizard appears:
+ </p>
+ <a href="{@docRoot}images/testing/spinnertest_new_class_callouts.png">
+ <img alt="New Java Class wizard dialog" src="{@docRoot}images/testing/spinnertest_new_class_callouts.png" style="height:230px"/>
+ </a>
+ </li>
+ <li>
+ In the wizard, enter the following:
+ <ul>
+ <li>
+ <em>Name:</em> "SpinnerActivityTest". This becomes the name of your test class.
+ </li>
+ <li>
+ <em>Superclass:</em> "<code>android.test.ActivityInstrumentationTestCase2<SpinnerActivity></code>". The superclass is parameterized, so
+ you have to provide it your main application's class name.
+ </li>
+ </ul>
+ <p>
+ Do not change any of the other settings. Click Finish.
+ </p>
+ </li>
+ <li>
+ You now have a new file <code>SpinnerActivityTest.java</code> in the project.
+ </li>
+ <li>
+ To resolve the reference to SpinnerActivity, add the following import:
+<pre>
+import com.android.example.spinner.SpinnerActivity;
+</pre>
+ </li>
+</ol>
+<h3 id="AddConstructor">Adding the test case constructor</h3>
+ <p>
+ To ensure that the test application is instantiated correctly, you must set up a constructor that the test
+ runner will call when it instantiates your test class. This constructor has no parameters, and its sole
+ purpose is to pass information to the superclass's default constructor. To set up this constructor, enter the
+ following code in the class:
+ </p>
+<pre>
+ public SpinnerActivityTest() {
+ super("com.android.example.spinner", SpinnerActivity.class);
+ } // end of SpinnerActivityTest constructor definition
+</pre>
+<p>
+ This calls the superclass constructor with the Android package name (<code>com.android.example.spinner</code>)and main activity's class
+ (<code>SpinnerActivity.class</code>) for the application under test. Android uses this information to find the application and activity to test.
+</p>
+<p>
+ You are now ready to add tests, by adding test methods to the class.
+</p>
+<h3 id="AddSetupMethod">Adding the setup method</h3>
+<p>
+ The <code>setUp()</code> method is invoked before every test. You use it to initialize variables and clean up from previous tests. You can also use
+ the JUnit {@link junit.framework.TestCase#tearDown() tearDown()} method, which runs <strong>after</strong> every test method. The tutorial does not use it.
+</p>
+<p>
+ The method you are going to add does the following:
+</p>
+<ul>
+ <li>
+ <code>super.setUp()</code>. Invokes the superclass constructor for <code>setUp()</code>, which is required by JUnit.
+ </li>
+ <li>
+ Calls {@link android.test.ActivityInstrumentationTestCase2#setActivityInitialTouchMode(boolean) setActivityInitialTouchMode(false)}.
+ This turns off <strong>touch mode</strong> in the device or emulator. If any of your test methods send key events to the application,
+ you must turn off touch mode <em>before</em> you start any activities; otherwise, the call is ignored.
+ </li>
+ <li>
+ Stores references to system objects. Retrieves and stores a reference to the activity under test, the <code>Spinner</code>
+ widget used by the activity, the <code>SpinnerAdapter</code> that backs the widget, and the string value of the selection that is
+ set when the application is first installed. These objects are used in the state management test. The methods invoked are:
+ <ul>
+ <li>
+ {@link android.test.ActivityInstrumentationTestCase2#getActivity()}. Gets a reference to the activity under test (<code>SpinnerActivity</code>).
+ This call also starts the activity if it is not already running.
+ </li>
+ <li>
+ {@link android.app.Activity#findViewById(int)}. Gets a reference to the <code>Spinner</code> widget of the application under test.
+ </li>
+ <li>
+ {@link android.widget.AbsSpinner#getAdapter()}. Gets a reference to the adapter (an array of strings) backing the spinner.
+ </li>
+ </ul>
+ </li>
+</ul>
+<p>
+ Add this code to the definition of <code>SpinnerActivityTest</code>, after the constructor definition:
+</p>
+<pre>
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ setActivityInitialTouchMode(false);
+
+ mActivity = getActivity();
+
+ mSpinner =
+ (Spinner) mActivity.findViewById(
+ com.android.example.spinner.R.id.Spinner01
+ );
+
+ mPlanetData = mSpinner.getAdapter();
+
+ } // end of setUp() method definition
+</pre>
+<p>
+ Add these members to the test case class:
+</p>
+<pre>
+ private SpinnerActivity mActivity;
+ private Spinner mSpinner;
+ private SpinnerAdapter mPlanetData;
+</pre>
+<p>
+ Add these imports:
+</p>
+<pre>
+import android.widget.Spinner;
+import android.widget.SpinnerAdapter;
+</pre>
+<p>
+ You now have the the complete <code>setUp()</code> method.
+</p>
+<h3 id="AddPreConditionsTest">Adding an initial conditions test</h3>
+<p>
+ The initial conditions test verifies that the application under test is initialized correctly. It is an illustration of the types of tests you can run, so it is not comprehensive.
+ It verifies the following:
+</p>
+<ul>
+ <li>
+ The item select listener is initialized. This listener is called when a selection is made from the spinner.
+ </li>
+ <li>
+ The adapter that provides values to the spinner is initialized.
+ </li>
+ <li>
+ The adapter contains the right number of entries.
+ </li>
+</ul>
+<p>
+ The actual initialization of the application under test is done in <code>setUp()</code>, which the test runner calls automatically before every test. The verifications are
+ done with JUnit {@link junit.framework.Assert} calls. As a useful convention, the method name is <code>testPreConditions()</code>:
+</p>
+<pre>
+ public void testPreConditions() {
+ assertTrue(mSpinner.getOnItemSelectedListener() != null);
+ assertTrue(mPlanetData != null);
+ assertEquals(mPlanetData.getCount(),ADAPTER_COUNT);
+ } // end of testPreConditions() method definition
+</pre>
+<p>
+ Add this member:
+</p>
+<pre>
+ public static final int ADAPTER_COUNT = 9;
+</pre>
+<h3 id="AddUITest">Adding a UI test</h3>
+<p>
+ Now create a UI test that selects an item from the <code>Spinner</code> widget. The test sends key events to the UI with key events.
+ The test confirms that the selection matches the result you expect.
+</p>
+<p>
+ This test demonstrates the power of using instrumentation in Android testing. Only an instrumentation-based test class allows you to send key events (or touch events)
+ to the application under test. With instrumentation, you can test your UI without having to take screenshots, record the screen, or do human-controlled testing.
+</p>
+<p>
+ To work with the spinner, the test has to request focus for it and then set it to a known position. The test uses {@link android.view.View#requestFocus() requestFocus()} and
+ {@link android.widget.AbsSpinner#setSelection(int) setSelection()} to do this. Both of these methods interact with a View in the application under test, so you have to call them
+ in a special way.
+</p>
+<p>
+ Code in a test application that interacts with a View of the application under test must run in the main application's thread, also
+ known as the <em>UI thread</em>. To do this, you use the {@link android.app.Activity#runOnUiThread(java.lang.Runnable) Activity.runOnUiThread()}
+ method. You pass the code to <code>runOnUiThread()</code>in an anonymous {@link java.lang.Runnable Runnable} object. To set
+ the statements in the <code>Runnable</code> object, you override the object's {@link java.lang.Runnable#run()} method.
+</p>
+<p>
+ To send key events to the UI of the application under test, you use the <a href="{@docRoot}reference/android/test/InstrumentationTestCase.html#sendKeys(int...)">sendKeys</a>() method.
+ This method does not have to run on the UI thread, since Android uses instrumentation to pass the key events to the application under test.
+</p>
+<p>
+ The last part of the test compares the selection made by sending the key events to a pre-determined value. This tests that the spinner is working as intended.
+</p>
+<p>
+ The following sections show you how to add the code for this test.
+</p>
+<ol>
+ <li>
+ Get focus and set selection. Create a new method <code>public void testSpinnerUI()</code>. Add
+ code to to request focus for the spinner and set its position to default or initial position, "Earth". This code is run on the UI thread of
+ the application under test:
+<pre>
+ public void testSpinnerUI() {
+
+ mActivity.runOnUiThread(
+ new Runnable() {
+ public void run() {
+ mSpinner.requestFocus();
+ mSpinner.setSelection(INITIAL_POSITION);
+ } // end of run() method definition
+ } // end of anonymous Runnable object instantiation
+ ); // end of invocation of runOnUiThread
+</pre>
+ <p>
+ Add the following member to the test case class.
+ </p>
+<pre>
+ public static final int INITIAL_POSITION = 0;
+</pre>
+ </li>
+ <li>
+ Make a selection. Send key events to the spinner to select one of the items. To do this, open the spinner by
+ "clicking" the center keypad button (sending a DPAD_CENTER key event) and then clicking (sending) the down arrow keypad button five times. Finally,
+ click the center keypad button again to highlight the desired item. Add the following code:
+<pre>
+ this.sendKeys(KeyEvent.KEYCODE_DPAD_CENTER);
+ for (int i = 1; i <= TEST_POSITION; i++) {
+ this.sendKeys(KeyEvent.KEYCODE_DPAD_DOWN);
+ } // end of for loop
+
+ this.sendKeys(KeyEvent.KEYCODE_DPAD_CENTER);
+</pre>
+ <p>
+ Add the following member to the test case class:
+ </p>
+<pre>
+ public static final int TEST_POSITION = 5;
+</pre>
+ <p>
+ This sets the final position of the spinner to "Saturn" (the spinner's backing adapter is 0-based).
+ </p>
+ </li>
+ <li>
+ Check the result. Query the current state of the spinner, and compare its current selection to the expected value.
+ Call the method {@link android.widget.AdapterView#getSelectedItemPosition() getSelectedItemPosition()} to find out the current selection position, and then
+ {@link android.widget.AdapterView#getItemAtPosition(int) getItemAtPosition()} to get the object corresponding to that position (casting it to a String). Assert that
+ this string value matches the expected value of "Saturn":
+<pre>
+ mPos = mSpinner.getSelectedItemPosition();
+ mSelection = (String)mSpinner.getItemAtPosition(mPos);
+ TextView resultView =
+ (TextView) mActivity.findViewById(
+ com.android.example.spinner.R.id.SpinnerResult
+ );
+
+ String resultText = (String) resultView.getText();
+
+ assertEquals(resultText,mSelection);
+
+ } // end of testSpinnerUI() method definition
+</pre>
+<p>
+ Add the following members to the test case class:
+</p>
+<pre>
+ private String mSelection;
+ private int mPos;
+</pre>
+ <p>
+ Add the following imports to the test case class:
+ </p>
+<pre>
+ import android.view.KeyEvent;
+ import android.widget.TextView;
+</pre>
+ </li>
+</ol>
+<p>
+ Pause here to run the tests you have. The procedure for running a test application is different
+ from running a regular Android application. You run a test application as an Android JUnit
+ application. To see how to do this, see <a href="#RunTests">Running the Tests and Seeing the Results</a>.
+</p>
+<p>
+ Eventually, you will see the <code>SpinnerActivity</code> application start, and the test
+ application controlling it by sending it key events. You will also see a new
+ <strong>JUnit</strong> view in the Explorer pane, showing the results of the
+ test. The JUnit view is documented in a following section,
+ <a href="#RunTests">Running the Test and Seeing the Results</a>.
+</p>
+<h3 id="StateManagementTests">Adding state management tests</h3>
+<p>
+ You now write two tests that verify that SpinnerActivity maintains its state when it is paused or terminated.
+ The state, in this case, is the current selection in the spinner. When users make a selection,
+ pause or terminate the application, and then resume or restart it, they should see
+ the same selection.
+</p>
+<p>
+ Maintaining state is an important feature of an application. Users may switch from the current
+ application temporarily to answer the phone, and then switch back. Android may decide to
+ terminate and restart an activity to change the screen orientation, or terminate an unused
+ activity to regain storage. In each case, users are best served by having the UI return to its
+ previous state (except where the logic of the application dictates otherwise).
+</p>
+<p>
+ SpinnerActivity manages its state in these ways:
+</p>
+ <ul>
+ <li>
+ Activity is hidden. When the spinner screen (the activity) is running but hidden by some other screen, it
+ stores the spinner's position and value in a form that persists while the application is running.
+ </li>
+ <li>
+ Application is terminated. When the activity is terminated, it stores the spinner's position and value in
+ a permanent form. The activity can read the position and value when it restarts, and restore the spinner to its previous state.
+ </li>
+ <li>
+ Activity re-appears. When the user returns to the spinner screen, the previous selection is restored.
+ </li>
+ <li>
+ Application is restarted. When the user starts the application again, the previous selection is restored.
+ </li>
+ </ul>
+<p class="note">
+ <strong>Note:</strong> An application can manage its state in other ways as well, but these are
+ not covered in this tutorial.
+</p>
+<p>
+ When an activity is hidden, it is <strong>paused</strong>. When it re-appears, it
+ <strong>resumes</strong>. Recognizing that these are key points in an activity's life cycle,
+ the Activity class provides two callback methods {@link android.app.Activity#onPause()} and
+ {@link android.app.Activity#onResume()} for handling pauses and resumes.
+ SpinnerActivity uses them for code that saves and restores state.
+</p>
+<p>
+ <strong>Note:</strong> If you would like to learn more about the difference between losing
+ focus/pausing and killing an application,
+ read about the <a href="{@docRoot}guide/components/activities.html#Lifecycle">activity
+lifecycle</a>.
+</p>
+<p>
+ The first test verifies that the spinner selection is maintained after the entire application is shut down and then restarted. The test uses instrumentation to
+ set the spinner's variables outside of the UI. It then terminates the activity by calling {@link android.app.Activity#finish() Activity.finish()}, and restarts it
+ using the instrumentation method {@link android.test.ActivityInstrumentationTestCase2#getActivity()}. The test then asserts that the current spinner state matches
+ the test values.
+</p>
+<p>
+ The second test verifies that the spinner selection is maintained after the activity is paused and then resumed. The test uses instrumentation to
+ set the spinner's variables outside of the UI and then force calls to the <code>onPause()</code> and <code>onResume()</code> methods. The test then
+ asserts that the current spinner state matches the test values.
+</p>
+<p>
+ Notice that these tests make limited assumptions about the mechanism by which the activity manages state. The tests use the activity's getters and
+ setters to control the spinner. The first test also knows that hiding an activity calls <code>onPause()</code>, and bringing it back to the foreground
+ calls <code>onResume()</code>. Other than this, the tests treat the activity as a "black box".
+</p>
+<p>
+ To add the code for testing state management across shutdown and restart, follow these steps:
+</p>
+ <ol>
+ <li>
+ Add the test method <code>testStateDestroy()</code>, then
+ set the spinner selection to a test value:
+<pre>
+ public void testStateDestroy() {
+ mActivity.setSpinnerPosition(TEST_STATE_DESTROY_POSITION);
+ mActivity.setSpinnerSelection(TEST_STATE_DESTROY_SELECTION);
+</pre>
+ </li>
+ <li>
+ Terminate the activity and restart it:
+<pre>
+ mActivity.finish();
+ mActivity = this.getActivity();
+</pre>
+ </li>
+ <li>
+ Get the current spinner settings from the activity:
+<pre>
+ int currentPosition = mActivity.getSpinnerPosition();
+ String currentSelection = mActivity.getSpinnerSelection();
+</pre>
+ </li>
+ <li>
+ Test the current settings against the test values:
+<pre>
+ assertEquals(TEST_STATE_DESTROY_POSITION, currentPosition);
+ assertEquals(TEST_STATE_DESTROY_SELECTION, currentSelection);
+ } // end of testStateDestroy() method definition
+</pre>
+<p>
+ Add the following members to the test case class:
+<pre>
+ public static final int TEST_STATE_DESTROY_POSITION = 2;
+ public static final String TEST_STATE_DESTROY_SELECTION = "Earth";
+</pre>
+ </li>
+ </ol>
+<p>
+ To add the code for testing state management across a pause and resume, follow these steps:
+</p>
+<ol>
+ <li>
+ Add the test method <code>testStatePause()</code>:
+<pre>
+ @UiThreadTest
+ public void testStatePause() {
+</pre>
+ <p>
+ The <code>@UiThreadTest</code> annotation tells Android to build this method so that it runs
+ on the UI thread. This allows the method to change the state of the spinner widget in the
+ application under test. This use of <code>@UiThreadTest</code> shows that, if necessary, you
+ can run an entire method on the UI thread.
+ </p>
+ </li>
+ <li>
+ Set up instrumentation. Get the instrumentation object
+ that is controlling the application under test. This is used later to
+ invoke the <code>onPause()</code> and <code>onResume()</code> methods:
+<pre>
+ Instrumentation mInstr = this.getInstrumentation();
+</pre>
+ </li>
+ <li>
+ Set the spinner selection to a test value:
+<pre>
+ mActivity.setSpinnerPosition(TEST_STATE_PAUSE_POSITION);
+ mActivity.setSpinnerSelection(TEST_STATE_PAUSE_SELECTION);
+</pre>
+ </li>
+ <li>
+ Use instrumentation to call the Activity's <code>onPause()</code>:
+<pre>
+ mInstr.callActivityOnPause(mActivity);
+</pre>
+ <p>
+ Under test, the activity is waiting for input. The invocation of
+ {@link android.app.Instrumentation#callActivityOnPause(android.app.Activity)}
+ performs a call directly to the activity's <code>onPause()</code> instead
+ of manipulating the activity's UI to force it into a paused state.
+ </p>
+ </li>
+ <li>
+ Force the spinner to a different selection:
+<pre>
+ mActivity.setSpinnerPosition(0);
+ mActivity.setSpinnerSelection("");
+</pre>
+ <p>
+ This ensures that resuming the activity actually restores the
+ spinner's state rather than simply leaving it as it was.
+ </p>
+ </li>
+ <li>
+ Use instrumentation to call the Activity's <code>onResume()</code>:
+<pre>
+ mInstr.callActivityOnResume(mActivity);
+</pre>
+ <p>
+ Invoking {@link android.app.Instrumentation#callActivityOnResume(android.app.Activity)}
+ affects the activity in a way similar to <code>callActivityOnPause</code>. The
+ activity's <code>onResume()</code> method is invoked instead of manipulating the
+ activity's UI to force it to resume.
+ </p>
+ </li>
+ <li>
+ Get the current state of the spinner:
+<pre>
+ int currentPosition = mActivity.getSpinnerPosition();
+ String currentSelection = mActivity.getSpinnerSelection();
+</pre>
+ </li>
+ <li>
+ Test the current spinner state against the test values:
+<pre>
+ assertEquals(TEST_STATE_PAUSE_POSITION,currentPosition);
+ assertEquals(TEST_STATE_PAUSE_SELECTION,currentSelection);
+ } // end of testStatePause() method definition
+</pre>
+ <p>
+ Add the following members to the test case class:
+ </p>
+<pre>
+ public static final int TEST_STATE_PAUSE_POSITION = 4;
+ public static final String TEST_STATE_PAUSE_SELECTION = "Jupiter";
+</pre>
+ </li>
+ <li>
+ Add the following imports:
+<pre>
+ import android.app.Instrumentation;
+ import android.test.UiThreadTest;
+</pre>
+ </li>
+</ol>
+<h2 id="RunTests">Running the Tests and Seeing the Results</h2>
+ <p>
+ The most simple way to run the <code>SpinnerActivityTest</code> test case is to run it directly from the Package Explorer.
+ </p>
+ <p>
+ To run the <code>SpinnerActivityTest</code> test, follow these steps:
+</p>
+ <ol>
+ <li>
+ In the Package Explorer, right-click the project SpinnerActivityTest at the top level, and then
+ select <strong>Run As</strong> > <strong>Android JUnit Test</strong>:<br/>
+ <a href="{@docRoot}images/testing/spinnertest_runas_menu_callouts.png">
+ <img alt="Menu to run a test as an Android JUnit test" src="{@docRoot}images/testing/spinnertest_runas_menu_callouts.png" style="height:230px">
+ </a>
+ </li>
+ <li>
+ You will see the emulator start. When the unlock option is displayed (its appearance depends on the API level you specified for the AVD),
+ unlock the home screen.
+ </li>
+ <li>
+ The test application starts. You see a new tab for the <strong>JUnit</strong> view, next to the Package Explorer tab:<br/>
+ <a href="{@docRoot}images/testing/spinnertest_junit_panel.png">
+ <img alt="The JUnit window" src="{@docRoot}images/testing/spinnertest_junit_panel.png" style="height:230px">
+ </a>
+ </li>
+</ol>
+<p>
+ This view contains two sub-panes. The top pane summarizes the tests that were run, and the bottom pane shows failure traces for
+ highlighted tests.
+</p>
+<p>
+ At the conclusion of a successful test run, this is the view's appearance:<br/>
+ <a href="{@docRoot}images/testing/spinnertest_junit_success.png">
+ <img src="{@docRoot}images/testing/spinnertest_junit_success.png" alt="JUnit test run success" style="height:230px"/>
+ </a>
+</p>
+<p>
+ The upper pane summarizes the test:
+</p>
+ <ul>
+ <li>
+ Total time elapsed for the test application(labeled <em>Finished after <x> seconds</em>).
+ </li>
+ <li>
+ Number of runs (<em>Runs:</em>) - the number of tests in the entire test class.
+ </li>
+ <li>
+ Number of errors (<em>Errors:</em>) - the number of program errors and exceptions encountered during
+ the test run.
+ </li>
+ <li>
+ Number of failures (<em>Failures:</em>) - the number of test failures encountered during the test
+ run. This is the number of assertion failures. A test can fail even if the program does not encounter an error.
+ </li>
+ <li>
+ A progress bar. The progress bar extends from left to right as the tests run.
+ <p>
+ If all the tests succeed, the bar remains green. If a test fails, the bar turns from green to red.
+ </p>
+ </li>
+ <li>
+ A test method summary. Below the bar, you see a line for each class in the test application. To look at the results for the individual
+ methods in a test, click the arrow at the left to expand the line. You see the name of each test method. To the
+ right of the name, you see the time taken by the test. You can look at the test's code
+ by double-clicking its name.
+ </li>
+ </ul>
+<p>
+ The lower pane contains the failure trace. If all the tests are successful, this pane is empty. If some tests fail,
+ then if you highlight a failed test in the upper pane, the lower view contains a stack trace for the test. This is
+ demonstrated in the next section.
+</p>
+<p class="note">
+ <strong>Note:</strong> If you run the test application and nothing seems to happen, look for
+ the JUnit view. If you do not see it, you may have run the test application
+ as a regular Android application.
+ Remember that you need to run it as an Android <strong>JUnit</strong>
+ application.
+</p>
+<h2 id="TestFailure">Forcing Some Tests to Fail</h2>
+<p>
+ A test is as useful when it fails as when it succeeds. This section shows what happens in Eclipse with ADT when a test fails. You
+ can quickly see that a test class has failed, find the method or methods that failed, and then use a failure trace to find
+ the exact problem.
+</p>
+<p>
+ The example application SpinnerActivity that you downloaded passes all the tests in the test application SpinnerActivityTest.
+ To force the test to fail, you must modify the example application. You change a line of setup code in the application under test. This
+ causes the <code>testPreConditions()</code> and <code>testTextView()</code> test methods to fail.
+</p>
+<p>
+ To force the tests to fail, follow these steps:
+</p>
+<ol>
+ <li>
+ In Eclipse with ADT, go to the SpinnerActivity project and open the file <code>SpinnerActivity.java</code>.
+ </li>
+ <li>
+ At the top of <code>SpinnerActivity.java</code>, at the end of the <code>onCreate()</code> method, find the following line:
+<pre>
+ // mySpinner.setOnItemSelectedListener(null);
+</pre>
+ <p>Remove the forward slash characters at the beginning of the line to
+ uncomment the line. This sets the listener callback to null:
+ </p>
+<pre>
+ mySpinner.setOnItemSelectedListener(null);
+</pre>
+ </li>
+ <li>
+ The <code>testPreConditions()</code> method in <code>SpinnerActivityTest</code> contains the following test:
+ <code>assertTrue(mSpinner.getOnItemSelectedListener() != null);</code>. This test asserts that the listener callback is <em>not</em> null.
+ Since you have modified the application under test, this assertion now fails.
+ </li>
+ <li>
+ Run the test, as described in the previous section <a href="#RunTests">Running the Tests and Seeing the Results</a>.
+ </li>
+</ol>
+<p>
+ The JUnit view is either created or updated with the results of the test. Now, however, the progress bar is red,
+ the number of failures is 2, and small "x" icons appear in the list icons next to the testPreConditions and
+ TestSpinnerUI tests. This indicates that the tests have failed. The display is similar to this:<br/>
+ <a href="{@docRoot}images/testing/spinnertest_junit_panel_fail_callouts.png">
+ <img src="{@docRoot}images/testing/spinnertest_junit_panel_fail_callouts.png" alt="The JUnit Failure window" style="height:230px"/>
+ </a>
+</p>
+<p>
+ You now want to look at the failures to see exactly where they occurred.
+</p>
+<p>
+ To examine the failures, follow these steps:
+</p>
+<ol>
+ <li>
+ Click the testPreconditions entry. In the lower pane entitled <strong>Failure Trace</strong>,
+ you see a stack trace of the calls that led to the failure. This trace is similar to the following screenshot:<br/>
+ <a href="{@docRoot}images/testing/spinnertest_junit_panel_failtrace_callouts.png">
+ <img src="{@docRoot}images/testing/spinnertest_junit_panel_failtrace_callouts.png" alt="The JUnit failure trace" style="height:230px"/>
+ </a>
+ </li>
+ <li>
+ The first line of the trace tells you the error. In this case, a JUnit assertion failed. To look at the
+ assertion in the test code, double-click the next line (the first line of the trace). In the center pane
+ a new tabbed window opens, containing the code for the test application <code>SpinnerActivityTest</code>. The failed assertion
+ is highlighted in the middle of the window.
+ </li>
+</ol>
+<p>
+ The assertion failed because you modified the main application to set the <code>getOnItemSelectedListener</code> callback to <code>null</code>.
+</p>
+<p>
+ You can look at the failure in <code>testTextView</code> if you want. Remember, though, that <code>testPreConditions</code> is meant to verify the
+ initial setup of the application under test. If testPreConditions() fails, then succeeding tests can't be trusted. The best strategy to follow is to
+ fix the problem and re-run all the tests.
+</p>
+<p>
+ Remember to go back to <code>SpinnerActivity.java</code> and re-comment the line you uncommented in an earlier step.
+</p>
+<p>
+ You have now completed the tutorial.
+</p>
+<h2 id="NextSteps">Next Steps</h2>
+<p>
+ This example test application has shown you how to create a test project and link it to
+ the application you want to test, how to choose and add a test case class, how to write
+ UI and state management tests, and how to run the tests against the application under
+ test. Now that you are familiar with the basics of testing Android applications, here
+ are some suggested next steps:
+</p>
+<p>
+ <strong>Learn more about testing on Android</strong>
+</p>
+<ul>
+ <li>
+ If you haven't done so already, read the
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>
+ document in the <em>Dev Guide</em>. It provides an overview of how testing on Android
+ works. If you are just getting started with Android testing, reading that document will
+ help you understand the tools available to you, so that you can develop effective
+ tests.
+ </li>
+</ul>
+<p>
+ <strong>Review the main Android test case classes</strong>
+</p>
+<ul>
+ <li>
+ {@link android.test.ActivityInstrumentationTestCase2}
+ </li>
+ <li>
+ {@link android.test.ActivityUnitTestCase}
+ </li>
+ <li>
+ {@link android.test.ProviderTestCase2}
+ </li>
+ <li>
+ {@link android.test.ServiceTestCase}
+ </li>
+</ul>
+<p>
+ <strong>Learn more about the assert and utility classes</strong>
+</p>
+<ul>
+ <li>
+ {@link junit.framework.Assert}, the JUnit Assert class.
+ </li>
+ <li>
+ {@link android.test.MoreAsserts}, additional Android assert methods.
+ </li>
+ <li>
+ {@link android.test.ViewAsserts}, useful assertion methods for testing Views.
+ </li>
+ <li>
+ {@link android.test.TouchUtils}, utility methods for simulating touch events in an Activity.
+ </li>
+</ul>
+<p>
+ <strong>Learn about instrumentation and the instrumented test runner</strong>
+</p>
+<ul>
+ <li>
+ {@link android.app.Instrumentation}, the base instrumentation class.
+ </li>
+ <li>
+ {@link android.test.InstrumentationTestCase}, the base instrumentation test case.
+ </li>
+ <li>
+ {@link android.test.InstrumentationTestRunner}, the standard Android test runner.
+ </li>
+</ul>
+<h2 id="Appendix">Appendix</h2>
+<h3 id="InstallCompletedTestApp">Installing the Completed Test Application File</h3>
+<p>
+ The recommended approach to this tutorial is to follow the instructions step-by-step and
+ write the test code as you go. However, if you want to do this tutorial quickly,
+ you can install the entire file for the test application into the test project.
+</p>
+<p>
+ To do this, you first create a test project with the necessary structure and files by using
+ the automated tools in Eclipse. Then you exit Eclipse and copy the test application's file
+ from the SpinnerTest sample project into your test project. The SpinnerTest sample project is
+ part of the Samples component of the SDK.
+</p>
+<p>
+ The result is a complete test application, ready to run against the Spinner sample application.
+</p>
+<p>
+ To install the test application file, follow these steps:
+</p>
+<ol>
+ <li>
+ Set up the projects for the application under test and the test application, as described
+ in the section section <a href="#SetupProjects">Setting Up the Projects</a>.
+ </li>
+ <li>
+ Set up the emulator, as described in the section <a href="#SetupEmulator">Setting Up the Emulator</a>.
+ </li>
+ <li>
+ Add the test case class, as described in the section <a href="#AddTestCaseClass">Adding the test case class file</a>.
+ </li>
+ <li>
+ Close Eclipse with ADT.
+ </li>
+ <li>
+ Copy the file <code><SDK_path>/samples/android-8/SpinnerTest/src/com/android/example/spinner/test/SpinnerActivityTest.java</code>
+ to the directory <code>workspace/SpinnerActivityTest/src/com/android/example/spinner/test/</code>.
+ </li>
+ <li>
+ Restart Eclipse with ADT.
+ </li>
+ <li>
+ In Eclipse with ADT, re-build the project <code>SpinnerActivityTest</code> by selecting it in the Package Explorer, right-clicking,
+ and selecting <em>Project</em> > <em>Clean</em>.
+ </li>
+ <li>
+ The complete, working test application should now be in the <code>SpinnerActivityTest</code> project.
+ </li>
+</ol>
+<p>
+ You can now continue with the tutorial, starting at the section <a href="#AddConstructor">Adding the test case constructor</a> and
+ following along in the text.
+</p>
+<h3 id="EditorCommandLine">For Users Not Developing In Eclipse</h3>
+<p>
+ If you are not developing in Eclipse, you can still do this tutorial. Android provides tools for
+ creating test applications using a code editor and command-line tools. You use the following tools:
+</p>
+<ul>
+ <li>
+ <a href="{@docRoot}tools/help/adb.html">adb</a> - Installs and uninstalls applications and test applications to a device or the emulator. You
+ also use this tool to run the test application from the command line.
+ </li>
+ <li>
+ <a href="{@docRoot}tools/help/android.html">android</a> - Manages projects and test projects. This tool also manages AVDs and Android platforms.
+ </li>
+</ul>
+ <p>
+ You use the <code>emulator</code> tool to run the emulator from the command line.
+ </p>
+ <p>
+ Here are the general steps for doing this tutorial using an editor and the command line:
+ </p>
+<ol>
+ <li>
+ As described in the section <a href="#DownloadCode">Installing the Tutorial Sample Code</a>, get the sample code. You will then
+ have a directory <code><SDK_path>/samples/android-8</code>, containing (among others) the directories <code>Spinner</code>
+ and <code>SpinnerTest</code>:
+ <ul>
+ <li>
+ <code>Spinner</code> contains the main application, also known as the <strong>application under test</strong>. This tutorial focuses on the
+ common situation of writing tests for an application that already exists, so the main application is provided to you.
+ </li>
+ <li>
+ <code>SpinnerTest</code> contains all the code for the test application. If you want to run quickly through the tutorial, you can
+ install the test code and then follow the text. You may get more from the tutorial, however, if you write the code as you go. The instructions
+ for installing the test code are in the section <a href="#InstallCompletedTestApp">Appendix: Installing the Completed Test Application File</a>.
+ </li>
+ </ul>
+ </li>
+ <li>
+ Navigate to the directory <code><SDK_path>/samples/android-8</code>.
+ </li>
+ <li>
+ Create a new Android application project using <code>android create project</code>:
+<pre>
+$ android create project -t <APItarget> -k com.android.example.spinner -a SpinnerActivity -n SpinnerActivity -p Spinner
+</pre>
+ <p>
+ The value of <code><APItarget></code> should be "3" (API level 3) or higher. If you are already developing with a particular API level, and it is
+ higher than 3, then use that API level.
+ </p>
+ <p>
+ This a new Android project <code>SpinnerActivity</code> in the existing <code>Spinner</code> directory. The existing source and
+ resource files are not touched, but the <code>android</code> tool adds the necessary build files.
+ </p>
+ </li>
+ <li>
+ Create a new Android test project using <code>android create test-project</code>:
+<pre>
+$ android create test-project -m ../Spinner -n SpinnerActivityTest -p SpinnerActivityTest
+</pre>
+ <p>
+ This will create a new Android test project in the <em>new</em> directory <code>SpinnerActivityTest</code>. You do this
+ so that the solution to the tutorial that is in <code>SpinnerTest</code> is left untouched. If you want to use the solution
+ code instead of entering it as you read through the tutorial, refer to the section
+ <a href="#InstallCompletedTestApp">Appendix: Installing the Completed Test Application File</a>.
+ </p>
+ <p class="Note">
+ <strong>Note:</strong> Running <code>android create test-project</code> will automatically create
+ the file <code>AndroidManifest.xml</code> with the correct <code><instrumentation></code> element.
+ </p>
+ </li>
+ <li>
+ Build the sample application. If you are building with Ant, then it is easiest to use the command <code>ant debug</code> to build a debug version, since the SDK comes
+ with a debug signing key. The result will be the file <code>Spinner/bin/SpinnerActivity-debug.apk</code>.
+ You can install this to your device or emulator. Attach your device or start the emulator if you haven't already, and run the command:
+<pre>
+$ adb install Spinner/bin/SpinnerActivity-debug.apk
+</pre>
+ </li>
+ <li>
+ To create the test application, create a file <code>SpinnerActivityTest.java</code> in the directory
+ <code>SpinnerActivityTest/src/com/android/example/spinner/test/</code>.
+ </li>
+ <li>
+ Follow the tutorial, starting with the section <a href="#CreateTestCaseClass">Creating the Test Case Class</a>. When you are prompted to
+ run the sample application, go the the Launcher screen in your device or emulator and select SpinnerActivity.
+ When you are prompted to run the test application, return here to continue with the following instructions.
+ </li>
+ <li>
+ Build the test application. If you are building with Ant, then it is easiest to use the command <code>ant debug</code> to build a
+ debug version, since the SDK comes with a debug signing key. The result will be the Android file
+ <code>SpinnerActivityTest/bin/SpinnerActivityTest-debug.apk</code>. You can install this to your device or emulator.
+ Attach your device or start the emulator if you haven't already, and run the command:
+<pre>
+$ adb install SpinnerActivityTest/bin/SpinnerActivityTest-debug.apk
+</pre>
+ </li>
+ <li>
+ In your device or emulator, check that both the main application <code>SpinnerActivity</code> and the test application
+ <code>SpinnerActivityTest</code> are installed.
+ </li>
+ <li>
+ To run the test application, enter the following at the command line:
+<pre>
+$ adb shell am instrument -w com.android.example.spinner.test/android.test.InstrumentationTestRunner
+ </pre>
+ </li>
+</ol>
+<p>
+ The result of a successful test looks like this:
+</p>
+<pre>
+com.android.example.spinner.test.SpinnerActivityTest:....
+Test results for InstrumentationTestRunner=....
+Time: 10.098
+OK (4 tests)
+</pre>
+<p>
+ If you force the test to fail, as described in the previous section <a href="#TestFailure">Forcing Some Tests to Fail</a>, then
+ the output looks like this:
+</p>
+<pre>
+com.android.example.spinner.test.SpinnerActivityTest:
+Failure in testPreConditions:
+junit.framework.AssertionFailedError
+ at com.android.example.spinner.test.SpinnerActivityTest.testPreConditions(SpinnerActivityTest.java:104)
+ at java.lang.reflect.Method.invokeNative(Native Method)
+ at android.test.InstrumentationTestCase.runMethod(InstrumentationTestCase.java:205)
+ at android.test.InstrumentationTestCase.runTest(InstrumentationTestCase.java:195)
+ at android.test.ActivityInstrumentationTestCase2.runTest(ActivityInstrumentationTestCase2.java:175)
+ at android.test.AndroidTestRunner.runTest(AndroidTestRunner.java:169)
+ at android.test.AndroidTestRunner.runTest(AndroidTestRunner.java:154)
+ at android.test.InstrumentationTestRunner.onStart(InstrumentationTestRunner.java:430)
+ at android.app.Instrumentation$InstrumentationThread.run(Instrumentation.java:1447)
+Failure in testSpinnerUI:
+junit.framework.ComparisonFailure: expected:<Result> but was:<Saturn>
+ at com.android.example.spinner.test.SpinnerActivityTest.testSpinnerUI(SpinnerActivityTest.java:153)
+ at java.lang.reflect.Method.invokeNative(Native Method)
+ at android.test.InstrumentationTestCase.runMethod(InstrumentationTestCase.java:205)
+ at android.test.InstrumentationTestCase.runTest(InstrumentationTestCase.java:195)
+ at android.test.ActivityInstrumentationTestCase2.runTest(ActivityInstrumentationTestCase2.java:175)
+ at android.test.AndroidTestRunner.runTest(AndroidTestRunner.java:169)
+ at android.test.AndroidTestRunner.runTest(AndroidTestRunner.java:154)
+ at android.test.InstrumentationTestRunner.onStart(InstrumentationTestRunner.java:430)
+ at android.app.Instrumentation$InstrumentationThread.run(Instrumentation.java:1447)
+..
+Test results for InstrumentationTestRunner=.F.F..
+Time: 9.377
+FAILURES!!!
+Tests run: 4, Failures: 2, Errors: 0
+</pre>
diff --git a/docs/html/tools/testing/activity_testing.jd b/docs/html/tools/testing/activity_testing.jd
new file mode 100644
index 0000000..7190b98
--- /dev/null
+++ b/docs/html/tools/testing/activity_testing.jd
@@ -0,0 +1,375 @@
+page.title=Activity Testing
+parent.title=Testing
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#ActivityTestAPI">The Activity Testing API</a>
+ <ol>
+ <li>
+ <a href="#ActivityInstrumentationTestCase2">ActivityInstrumentationTestCase2</a>
+ </li>
+ <li>
+ <a href="#ActivityUnitTestCase">ActivityUnitTestCase</a>
+ </li>
+ <li>
+ <a href="#SingleLaunchActivityTestCase">SingleLaunchActivityTestCase</a>
+ </li>
+ <li>
+ <a href="#MockObjectNotes">Mock objects and activity testing</a>
+ </li>
+ <li>
+ <a href="#AssertionNotes">Assertions for activity testing</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#WhatToTest">What to Test</a>
+ </li>
+ <li>
+ <a href="#NextSteps">Next Steps</a>
+ </li>
+ <li>
+ <a href="#UITesting">Appendix: UI Testing Notes</a>
+ <ol>
+ <li>
+ <a href="#RunOnUIThread">Testing on the UI thread</a>
+ </li>
+ <li>
+ <a href="#NotouchMode">Turning off touch mode</a>
+ </li>
+ <li>
+ <a href="#UnlockDevice">Unlocking the Emulator or Device</a>
+ </li>
+ <li>
+ <a href="#UITestTroubleshooting">Troubleshooting UI tests</a>
+ </li>
+ </ol>
+ </li>
+ </ol>
+<h2>Key Classes</h2>
+ <ol>
+ <li>{@link android.test.InstrumentationTestRunner}</li>
+ <li>{@link android.test.ActivityInstrumentationTestCase2}</li>
+ <li>{@link android.test.ActivityUnitTestCase}</li>
+ </ol>
+<h2>Related Tutorials</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>
+ </li>
+ </ol>
+<h2>See Also</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing from Eclipse with ADT</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing from Other IDEs</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ Activity testing is particularly dependent on the the Android instrumentation framework.
+ Unlike other components, activities have a complex lifecycle based on callback methods; these
+ can't be invoked directly except by instrumentation. Also, the only way to send events to the
+ user interface from a program is through instrumentation.
+</p>
+<p>
+ This document describes how to test activities using instrumentation and other test
+ facilities. The document assumes you have already read
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ the introduction to the Android testing and instrumentation framework.
+</p>
+<h2 id="ActivityTestAPI">The Activity Testing API</h2>
+<p>
+ The activity testing API base class is {@link android.test.InstrumentationTestCase},
+ which provides instrumentation to the test case subclasses you use for Activities.
+</p>
+<p>
+ For activity testing, this base class provides these functions:
+</p>
+<ul>
+ <li>
+ Lifecycle control: With instrumentation, you can start the activity under test, pause it,
+ and destroy it, using methods provided by the test case classes.
+ </li>
+ <li>
+ Dependency injection: Instrumentation allows you to create mock system objects such as
+ Contexts or Applications and use them to run the activity under test. This
+ helps you control the test environment and isolate it from production systems. You can
+ also set up customized Intents and start an activity with them.
+ </li>
+ <li>
+ User interface interaction: You use instrumentation to send keystrokes or touch events
+ directly to the UI of the activity under test.
+ </li>
+</ul>
+<p>
+ The activity testing classes also provide the JUnit framework by extending
+ {@link junit.framework.TestCase} and {@link junit.framework.Assert}.
+</p>
+<p>
+ The two main testing subclasses are {@link android.test.ActivityInstrumentationTestCase2} and
+ {@link android.test.ActivityUnitTestCase}. To test an Activity that is launched in a mode
+ other than <code>standard</code>, you use {@link android.test.SingleLaunchActivityTestCase}.
+</p>
+<h3 id="ActivityInstrumentationTestCase2">ActivityInstrumentationTestCase2</h3>
+<p>
+ The {@link android.test.ActivityInstrumentationTestCase2} test case class is designed to do
+ functional testing of one or more Activities in an application, using a normal system
+ infrastructure. It runs the Activities in a normal instance of the application under test,
+ using a standard system Context. It allows you to send mock Intents to the activity under
+ test, so you can use it to test an activity that responds to multiple types of intents, or
+ an activity that expects a certain type of data in the intent, or both. Notice, though, that it
+ does not allow mock Contexts or Applications, so you can not isolate the test from the rest of
+ a production system.
+</p>
+<h3 id="ActivityUnitTestCase">ActivityUnitTestCase</h3>
+<p>
+ The {@link android.test.ActivityUnitTestCase} test case class tests a single activity in
+ isolation. Before you start the activity, you can inject a mock Context or Application, or both.
+ You use it to run activity tests in isolation, and to do unit testing of methods
+ that do not interact with Android. You can not send mock Intents to the activity under test,
+ although you can call
+ {@link android.app.Activity#startActivity(Intent) Activity.startActivity(Intent)} and then
+ look at arguments that were received.
+</p>
+<h3 id="SingleLaunchActivityTestCase">SingleLaunchActivityTestCase</h3>
+<p>
+ The {@link android.test.SingleLaunchActivityTestCase} class is a convenience class for
+ testing a single activity in an environment that doesn't change from test to test.
+ It invokes {@link junit.framework.TestCase#setUp() setUp()} and
+ {@link junit.framework.TestCase#tearDown() tearDown()} only once, instead of once per
+ method call. It does not allow you to inject any mock objects.
+</p>
+<p>
+ This test case is useful for testing an activity that runs in a mode other than
+ <code>standard</code>. It ensures that the test fixture is not reset between tests. You
+ can then test that the activity handles multiple calls correctly.
+</p>
+<h3 id="MockObjectNotes">Mock objects and activity testing</h3>
+<p>
+ This section contains notes about the use of the mock objects defined in
+ {@link android.test.mock} with activity tests.
+</p>
+<p>
+ The mock object {@link android.test.mock.MockApplication} is only available for activity
+ testing if you use the {@link android.test.ActivityUnitTestCase} test case class.
+ By default, <code>ActivityUnitTestCase</code>, creates a hidden <code>MockApplication</code>
+ object that is used as the application under test. You can inject your own object using
+ {@link android.test.ActivityUnitTestCase#setApplication(Application) setApplication()}.
+</p>
+<h3 id="AssertionNotes">Assertions for activity testing</h3>
+<p>
+ {@link android.test.ViewAsserts} defines assertions for Views. You use it to verify the
+ alignment and position of View objects, and to look at the state of ViewGroup objects.
+</p>
+<h2 id="WhatToTest">What To Test</h2>
+<ul>
+ <li>
+ Input validation: Test that an activity responds correctly to input values in an
+ EditText View. Set up a keystroke sequence, send it to the activity, and then
+ use {@link android.view.View#findViewById(int)} to examine the state of the View. You can
+ verify that a valid keystroke sequence enables an OK button, while an invalid one leaves the
+ button disabled. You can also verify that the Activity responds to invalid input by
+ setting error messages in the View.
+ </li>
+ <li>
+ Lifecycle events: Test that each of your application's activities handles lifecycle events
+ correctly. In general, lifecycle events are actions, either from the system or from the
+ user, that trigger a callback method such as <code>onCreate()</code> or
+ <code>onClick()</code>. For example, an activity should respond to pause or destroy events
+ by saving its state. Remember that even a change in screen orientation causes the current
+ activity to be destroyed, so you should test that accidental device movements don't
+ accidentally lose the application state.
+ </li>
+ <li>
+ Intents: Test that each activity correctly handles the intents listed in the intent
+ filter specified in its manifest. You can use
+ {@link android.test.ActivityInstrumentationTestCase2} to send mock Intents to the
+ activity under test.
+ </li>
+ <li>
+ Runtime configuration changes: Test that each activity responds correctly to the
+ possible changes in the device's configuration while your application is running. These
+ include a change to the device's orientation, a change to the current language, and so
+ forth. Handling these changes is described in detail in the topic
+ <a href="{@docRoot}guide/topics/resources/runtime-changes.html">Handling Runtime
+ Changes</a>.
+ </li>
+ <li>
+ Screen sizes and resolutions: Before you publish your application, make sure to test it on
+ all of the screen sizes and densities on which you want it to run. You can test the
+ application on multiple sizes and densities using AVDs, or you can test your application
+ directly on the devices that you are targeting. For more information, see the topic
+ <a href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple Screens</a>.
+ </li>
+</ul>
+<h2 id="NextSteps">Next Steps</h2>
+<p>
+ To learn how to set up and run tests in Eclipse, please refer to
+<a href="{@docRoot}tools/testing/testing_eclipse.html">Testing from Eclipse with ADT</a>.
+ If you're not working in Eclipse, refer to
+<a href="{@docRoot}tools/testing/testing_otheride.html">Testing from Other IDEs</a>.
+</p>
+<p>
+ If you want a step-by-step introduction to testing activities, try the
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>, which
+ guides you through a testing scenario that you develop against an activity-oriented application.
+</p>
+<h2 id="UITesting">Appendix: UI Testing Notes</h2>
+<p>
+ The following sections have tips for testing the UI of your Android application, specifically
+ to help you handle actions that run in the UI thread, touch screen and keyboard events, and home
+ screen unlock during testing.
+</p>
+<h3 id="RunOnUIThread">Testing on the UI thread</h3>
+<p>
+ An application's activities run on the application's <strong>UI thread</strong>. Once the
+ UI is instantiated, for example in the activity's <code>onCreate()</code> method, then all
+ interactions with the UI must run in the UI thread. When you run the application normally, it
+ has access to the thread and does not have to do anything special.
+</p>
+<p>
+ This changes when you run tests against the application. With instrumentation-based classes,
+ you can invoke methods against the UI of the application under test. The other test classes
+ don't allow this. To run an entire test method on the UI thread, you can annotate the thread
+ with <code>@UIThreadTest</code>. Notice that this will run <em>all</em> of the method statements
+ on the UI thread. Methods that do not interact with the UI are not allowed; for example, you
+ can't invoke <code>Instrumentation.waitForIdleSync()</code>.
+</p>
+<p>
+ To run a subset of a test method on the UI thread, create an anonymous class of type
+ <code>Runnable</code>, put the statements you want in the <code>run()</code> method, and
+ instantiate a new instance of the class as a parameter to the method
+ <code><em>appActivity</em>.runOnUiThread()</code>, where <code><em>appActivity</em></code> is
+ the instance of the application you are testing.
+</p>
+<p>
+ For example, this code instantiates an activity to test, requests focus (a UI action) for the
+ Spinner displayed by the activity, and then sends a key to it. Notice that the calls to
+ <code>waitForIdleSync</code> and <code>sendKeys</code> aren't allowed to run on the UI thread:
+</p>
+<pre>
+ private MyActivity mActivity; // MyActivity is the class name of the app under test
+ private Spinner mSpinner;
+
+ ...
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ mInstrumentation = getInstrumentation();
+
+ mActivity = getActivity(); // get a references to the app under test
+
+ /*
+ * Get a reference to the main widget of the app under test, a Spinner
+ */
+ mSpinner = (Spinner) mActivity.findViewById(com.android.demo.myactivity.R.id.Spinner01);
+
+ ...
+
+ public void aTest() {
+ /*
+ * request focus for the Spinner, so that the test can send key events to it
+ * This request must be run on the UI thread. To do this, use the runOnUiThread method
+ * and pass it a Runnable that contains a call to requestFocus on the Spinner.
+ */
+ mActivity.runOnUiThread(new Runnable() {
+ public void run() {
+ mSpinner.requestFocus();
+ }
+ });
+
+ mInstrumentation.waitForIdleSync();
+
+ this.sendKeys(KeyEvent.KEYCODE_DPAD_CENTER);
+</pre>
+
+<h3 id="NotouchMode">Turning off touch mode</h3>
+<p>
+ To control the emulator or a device with key events you send from your tests, you must turn off
+ touch mode. If you do not do this, the key events are ignored.
+</p>
+<p>
+ To turn off touch mode, you invoke
+ <code>ActivityInstrumentationTestCase2.setActivityTouchMode(false)</code>
+ <em>before</em> you call <code>getActivity()</code> to start the activity. You must invoke the
+ method in a test method that is <em>not</em> running on the UI thread. For this reason, you
+ can't invoke the touch mode method from a test method that is annotated with
+ <code>@UIThread</code>. Instead, invoke the touch mode method from <code>setUp()</code>.
+</p>
+<h3 id="UnlockDevice">Unlocking the emulator or device</h3>
+<p>
+ You may find that UI tests don't work if the emulator's or device's home screen is disabled with
+ the keyguard pattern. This is because the application under test can't receive key events sent
+ by <code>sendKeys()</code>. The best way to avoid this is to start your emulator or device
+ first and then disable the keyguard for the home screen.
+</p>
+<p>
+ You can also explicitly disable the keyguard. To do this,
+ you need to add a permission in the manifest file (<code>AndroidManifest.xml</code>) and
+ then disable the keyguard in your application under test. Note, though, that you either have to
+ remove this before you publish your application, or you have to disable it with code in
+ the published application.
+</p>
+<p>
+ To add the the permission, add the element
+ <code><uses-permission android:name="android.permission.DISABLE_KEYGUARD"/></code>
+ as a child of the <code><manifest></code> element. To disable the KeyGuard, add the
+ following code to the <code>onCreate()</code> method of activities you intend to test:
+</p>
+<pre>
+ mKeyGuardManager = (KeyguardManager) getSystemService(KEYGUARD_SERVICE);
+ mLock = mKeyGuardManager.newKeyguardLock("<em>activity_classname</em>");
+ mLock.disableKeyguard();
+</pre>
+<p>where <code><em>activity_classname</em></code> is the class name of the activity.</p>
+<h3 id="UITestTroubleshooting">Troubleshooting UI tests</h3>
+<p>
+ This section lists some of the common test failures you may encounter in UI testing, and their
+ causes:
+</p>
+<dl>
+ <dt><code>WrongThreadException</code></dt>
+ <dd>
+ <p><strong>Problem:</strong></p>
+ For a failed test, the Failure Trace contains the following error message:
+ <code>
+ android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created
+ a view hierarchy can touch its views.
+ </code>
+ <p><strong>Probable Cause:</strong></p>
+ This error is common if you tried to send UI events to the UI thread from outside the UI
+ thread. This commonly happens if you send UI events from the test application, but you don't
+ use the <code>@UIThread</code> annotation or the <code>runOnUiThread()</code> method. The
+ test method tried to interact with the UI outside the UI thread.
+ <p><strong>Suggested Resolution:</strong></p>
+ Run the interaction on the UI thread. Use a test class that provides instrumentation. See
+ the previous section <a href="#RunOnUIThread">Testing on the UI Thread</a>
+ for more details.
+ </dd>
+ <dt><code>java.lang.RuntimeException</code></dt>
+ <dd>
+ <p><strong>Problem:</strong></p>
+ For a failed test, the Failure Trace contains the following error message:
+ <code>
+ java.lang.RuntimeException: This method can not be called from the main application thread
+ </code>
+ <p><strong>Probable Cause:</strong></p>
+ This error is common if your test method is annotated with <code>@UiThreadTest</code> but
+ then tries to do something outside the UI thread or tries to invoke
+ <code>runOnUiThread()</code>.
+ <p><strong>Suggested Resolution:</strong></p>
+ Remove the <code>@UiThreadTest</code> annotation, remove the <code>runOnUiThread()</code>
+ call, or re-factor your tests.
+ </dd>
+</dl>
diff --git a/docs/html/tools/testing/contentprovider_testing.jd b/docs/html/tools/testing/contentprovider_testing.jd
new file mode 100644
index 0000000..a6440df
--- /dev/null
+++ b/docs/html/tools/testing/contentprovider_testing.jd
@@ -0,0 +1,217 @@
+page.title=Content Provider Testing
+parent.title=Testing
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#DesignAndTest">Content Provider Design and Testing</a>
+ </li>
+ <li>
+ <a href="#ContentProviderTestAPI">The Content Provider Testing API</a>
+ <ol>
+ <li>
+ <a href="#ProviderTestCase2">ProviderTestCase2 </a>
+ </li>
+ <li>
+ <a href="#MockObjects">Mock object classes</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#WhatToTest">What To Test</a>
+ </li>
+ <li>
+ <a href="#NextSteps">Next Steps</a>
+ </li>
+ </ol>
+ <h2>Key Classes</h2>
+ <ol>
+ <li>{@link android.test.InstrumentationTestRunner}</li>
+ <li>{@link android.test.ProviderTestCase2}</li>
+ <li>{@link android.test.IsolatedContext}</li>
+ <li>{@link android.test.mock.MockContentResolver}</li>
+ </ol>
+ <h2>Related Tutorials</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>
+ </li>
+ </ol>
+ <h2>See Also</h2>
+ <ol>
+ <li>
+ <a
+ href="{@docRoot}tools/testing/testing_android.html">
+ Testing Fundamentals</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing From Eclipse with ADT</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing From Other IDEs</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ Content providers, which store and retrieve data and make it accessible across applications,
+ are a key part of the Android API. As an application developer you're allowed to provide your
+ own public providers for use by other applications. If you do, then you should test them
+ using the API you publish.
+</p>
+<p>
+ This document describes how to test public content providers, although the information is
+ also applicable to providers that you keep private to your own application. If you aren't
+ familiar with content providers or the Android testing framework, please read
+ <a href="{@docRoot}guide/topics/providers/content-providers.html">Content Providers</a>,
+ the guide to developing content providers, and
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ the introduction to the Android testing and instrumentation framework.
+</p>
+<h2 id="DesignAndTest">Content Provider Design and Testing</h2>
+<p>
+ In Android, content providers are viewed externally as data APIs that provide
+ tables of data, with their internals hidden from view. A content provider may have many
+ public constants, but it usually has few if any public methods and no public variables.
+ This suggests that you should write your tests based only on the provider's public members.
+ A content provider that is designed like this is offering a contract between itself and its
+ users.
+</p>
+<p>
+ The base test case class for content providers,
+ {@link android.test.ProviderTestCase2}, allows you to test your content provider in an
+ isolated environment. Android mock objects such as {@link android.test.IsolatedContext} and
+ {@link android.test.mock.MockContentResolver} also help provide an isolated test environment.
+</p>
+<p>
+ As with other Android tests, provider test packages are run under the control of the test
+ runner {@link android.test.InstrumentationTestRunner}. The section
+ <a href="{@docRoot}tools/testing/testing_android.html#InstrumentationTestRunner">
+ Running Tests With InstrumentationTestRunner</a> describes the test runner in
+ more detail. The topic <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing From Eclipse with ADT</a> shows you how to run a test package in Eclipse, and the
+ topic <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing From Other IDEs</a>
+ shows you how to run a test package from the command line.
+</p>
+<h2 id="ContentProviderTestAPI">Content Provider Testing API</h2>
+<p>
+ The main focus of the provider testing API is to provide an isolated testing environment. This
+ ensures that tests always run against data dependencies set explicitly in the test case. It
+ also prevents tests from modifying actual user data. For example, you want to avoid writing
+ a test that fails because there was data left over from a previous test, and you want to
+ avoid adding or deleting contact information in a actual provider.
+</p>
+<p>
+ The test case class and mock object classes for provider testing set up this isolated testing
+ environment for you.
+</p>
+<h3 id="ProviderTestCase2">ProviderTestCase2</h3>
+<p>
+ You test a provider with a subclass of {@link android.test.ProviderTestCase2}. This base class
+ extends {@link android.test.AndroidTestCase}, so it provides the JUnit testing framework as well
+ as Android-specific methods for testing application permissions. The most important
+ feature of this class is its initialization, which creates the isolated test environment.
+</p>
+<p>
+ The initialization is done in the constructor for {@link android.test.ProviderTestCase2}, which
+ subclasses call in their own constructors. The {@link android.test.ProviderTestCase2}
+ constructor creates an {@link android.test.IsolatedContext} object that allows file and
+ database operations but stubs out other interactions with the Android system.
+ The file and database operations themselves take place in a directory that is local to the
+ device or emulator and has a special prefix.
+</p>
+<p>
+ The constructor then creates a {@link android.test.mock.MockContentResolver} to use as the
+ resolver for the test. The {@link android.test.mock.MockContentResolver} class is described in
+ detail in the section
+ <a href="{@docRoot}tools/testing/testing_android.html#MockObjectClasses">Mock object
+classes</a>.
+</p>
+<p>
+ Lastly, the constructor creates an instance of the provider under test. This is a normal
+ {@link android.content.ContentProvider} object, but it takes all of its environment information
+ from the {@link android.test.IsolatedContext}, so it is restricted to
+ working in the isolated test environment. All of the tests done in the test case class run
+ against this isolated object.
+</p>
+<h3 id="MockObjects">Mock object classes</h3>
+<p>
+ {@link android.test.ProviderTestCase2} uses {@link android.test.IsolatedContext} and
+ {@link android.test.mock.MockContentResolver}, which are standard mock object classes. To
+ learn more about them, please read
+ <a href="{@docRoot}tools/testing/testing_android.html#MockObjectClasses">
+ Testing Fundamentals</a>.
+</p>
+<h2 id="WhatToTest">What To Test</h2>
+<p>
+ The topic <a href="{@docRoot}tools/testing/what_to_test.html">What To Test</a>
+ lists general considerations for testing Android components.
+ Here are some specific guidelines for testing content providers.
+</p>
+<ul>
+ <li>
+ Test with resolver methods: Even though you can instantiate a provider object in
+ {@link android.test.ProviderTestCase2}, you should always test with a resolver object
+ using the appropriate URI. This ensures that you are testing the provider using the same
+ interaction that a regular application would use.
+ </li>
+ <li>
+ Test a public provider as a contract: If you intent your provider to be public and
+ available to other applications, you should test it as a contract. This includes
+ the following ideas:
+ <ul>
+ <li>
+ Test with constants that your provider publicly exposes. For
+ example, look for constants that refer to column names in one of the provider's
+ data tables. These should always be constants publicly defined by the provider.
+ </li>
+ <li>
+ Test all the URIs offered by your provider. Your provider may offer several URIs,
+ each one referring to a different aspect of the data. The
+ <a href="{@docRoot}resources/samples/NotePad/index.html">Note Pad</a> sample,
+ for example, features a provider that offers one URI for retrieving a list of notes,
+ another for retrieving an individual note by it's database ID, and a third for
+ displaying notes in a live folder.
+ </li>
+ <li>
+ Test invalid URIs: Your unit tests should deliberately call the provider with an
+ invalid URI, and look for errors. Good provider design is to throw an
+ IllegalArgumentException for invalid URIs.
+
+ </li>
+ </ul>
+ </li>
+ <li>
+ Test the standard provider interactions: Most providers offer six access methods:
+ query, insert, delete, update, getType, and onCreate(). Your tests should verify that all
+ of these methods work. These are described in more detail in the topic
+ <a href="{@docRoot}guide/topics/providers/content-providers.html">Content Providers</a>.
+ </li>
+ <li>
+ Test business logic: Don't forget to test the business logic that your provider should
+ enforce. Business logic includes handling of invalid values, financial or arithmetic
+ calculations, elimination or combining of duplicates, and so forth. A content provider
+ does not have to have business logic, because it may be implemented by activities that
+ modify the data. If the provider does implement business logic, you should test it.
+ </li>
+</ul>
+<h2 id="NextSteps">Next Steps</h2>
+<p>
+ To learn how to set up and run tests in Eclipse, please refer to
+<a href="{@docRoot}tools/testing/testing_eclipse.html">Testing from Eclipse with ADT</a>.
+ If you're not working in Eclipse, refer to
+<a href="{@docRoot}tools/testing/testing_otheride.html">Testing From Other IDEs</a>.
+</p>
+<p>
+ If you want a step-by-step introduction to testing activities, try the
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>, which
+ guides you through a testing scenario that you develop against an activity-oriented application.
+</p>
+
diff --git a/docs/html/tools/testing/index.jd b/docs/html/tools/testing/index.jd
new file mode 100644
index 0000000..56de4cf
--- /dev/null
+++ b/docs/html/tools/testing/index.jd
@@ -0,0 +1,40 @@
+page.title=Testing
+@jd:body
+
+<p> The Android framework includes an integrated testing framework that helps you test all aspects
+of your application and the SDK tools include tools for setting up and running test applications.
+Whether you are working in Eclipse with ADT or working from the command line, the SDK tools help you
+set up and run your tests within an emulator or the device you are targeting. </p>
+
+<p>If you aren't yet familiar with the Android testing framework, start by reading <a
+href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>. For a step-by-step
+introduction to Android testing, try the <a
+href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>. </p>
+
+
+
+<div class="landing-docs">
+
+ <div class="col-13" style="margin-left:0">
+ <h3>Blog Articles</h3>
+
+ <a href="http://android-developers.blogspot.com/2010/12/new-gingerbread-api-strictmode.html">
+ <h4>New Gingerbread API: StrictMode</h4>
+ <p>StrictMode is a new API in Gingerbread which primarily lets you set a policy on a thread
+declaring what you’re not allowed to do on that thread, and what the penalty is if you violate the
+policy. Implementation-wise, this policy is simply a thread-local integer bitmask.</p>
+ </a>
+
+ <a href="http://android-developers.blogspot.com/2010/10/traceview-war-story.html">
+ <h4>Traceview War Story</h4>
+ <p>I recently took my first serious look at Traceview, and it occurred to me, first, that
+there are probably a few other Android developers who haven’t used it and, second, that this is an
+opportunity to lecture sternly on one of my favorite subjects: performance improvement and
+profiling.</p>
+ </a>
+ </div>
+
+
+</div>
+
+
diff --git a/docs/html/tools/testing/service_testing.jd b/docs/html/tools/testing/service_testing.jd
new file mode 100644
index 0000000..7c56fd9
--- /dev/null
+++ b/docs/html/tools/testing/service_testing.jd
@@ -0,0 +1,176 @@
+page.title=Service Testing
+parent.title=Testing
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#DesignAndTest">Service Design and Testing</a>
+ </li>
+ <li>
+ <a href="#ServiceTestCase">ServiceTestCase</a>
+ </li>
+ <li>
+ <a href="#MockObjects">Mock object classes</a>
+ </li>
+ <li>
+ <a href="#TestAreas">What to Test</a>
+ </li>
+ </ol>
+ <h2>Key Classes</h2>
+ <ol>
+ <li>{@link android.test.InstrumentationTestRunner}</li>
+ <li>{@link android.test.ServiceTestCase}</li>
+ <li>{@link android.test.mock.MockApplication}</li>
+ <li>{@link android.test.RenamingDelegatingContext}</li>
+ </ol>
+ <h2>Related Tutorials</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>
+ </li>
+ </ol>
+ <h2>See Also</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing From Eclipse with ADT</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing From Other IDEs</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ Android provides a testing framework for Service objects that can run them in
+ isolation and provides mock objects. The test case class for Service objects is
+ {@link android.test.ServiceTestCase}. Since the Service class assumes that it is separate
+ from its clients, you can test a Service object without using instrumentation.
+</p>
+<p>
+ This document describes techniques for testing Service objects. If you aren't familiar with the
+ Service class, please read the <a href="{@docRoot}guide/components/services.html">
+ Services</a> document. If you aren't familiar with Android testing, please read
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ the introduction to the Android testing and instrumentation framework.
+</p>
+<h2 id="DesignAndTest">Service Design and Testing</h2>
+<p>
+ When you design a Service, you should consider how your tests can examine the various states
+ of the Service lifecycle. If the lifecycle methods that start up your Service, such as
+ {@link android.app.Service#onCreate() onCreate()} or
+ {@link android.app.Service#onStartCommand(Intent, int, int) onStartCommand()} do not normally
+ set a global variable to indicate that they were successful, you may want to provide such a
+ variable for testing purposes.
+</p>
+<p>
+ Most other testing is facilitated by the methods in the {@link android.test.ServiceTestCase}
+ test case class. For example, the {@link android.test.ServiceTestCase#getService()} method
+ returns a handle to the Service under test, which you can test to confirm that the Service is
+ running even at the end of your tests.
+</p>
+<h2 id="ServiceTestCase">ServiceTestCase</h2>
+<p>
+ {@link android.test.ServiceTestCase} extends the JUnit {@link junit.framework.TestCase} class
+ with with methods for testing application permissions and for controlling the application and
+ Service under test. It also provides mock application and Context objects that isolate your
+ test from the rest of the system.
+</p>
+<p>
+ {@link android.test.ServiceTestCase} defers initialization of the test environment until you
+ call {@link android.test.ServiceTestCase#startService(Intent) ServiceTestCase.startService()} or
+ {@link android.test.ServiceTestCase#bindService(Intent) ServiceTestCase.bindService()}. This
+ allows you to set up your test environment, particularly your mock objects, before the Service
+ is started.
+</p>
+<p>
+ Notice that the parameters to <code>ServiceTestCase.bindService()</code>are different from
+ those for <code>Service.bindService()</code>. For the <code>ServiceTestCase</code> version,
+ you only provide an Intent. Instead of returning a boolean,
+ <code>ServiceTestCase.bindService()</code> returns an object that subclasses
+ {@link android.os.IBinder}.
+</p>
+<p>
+ The {@link android.test.ServiceTestCase#setUp()} method for {@link android.test.ServiceTestCase}
+ is called before each test. It sets up the test fixture by making a copy of the current system
+ Context before any test methods touch it. You can retrieve this Context by calling
+ {@link android.test.ServiceTestCase#getSystemContext()}. If you override this method, you must
+ call <code>super.setUp()</code> as the first statement in the override.
+</p>
+<p>
+ The methods {@link android.test.ServiceTestCase#setApplication(Application) setApplication()}
+ and {@link android.test.AndroidTestCase#setContext(Context)} setContext()} allow you to set
+ a mock Context or mock Application (or both) for the Service, before you start it. These mock
+ objects are described in <a href="#MockObjects">Mock object classes</a>.
+</p>
+<p>
+ By default, {@link android.test.ServiceTestCase} runs the test method
+ {@link android.test.AndroidTestCase#testAndroidTestCaseSetupProperly()}, which asserts that
+ the base test case class successfully set up a Context before running.
+</p>
+<h2 id="MockObjects">Mock object classes</h2>
+<p>
+ <code>ServiceTestCase</code> assumes that you will use a mock Context or mock Application
+ (or both) for the test environment. These objects isolate the test environment from the
+ rest of the system. If you don't provide your own instances of these objects before you
+ start the Service, then {@link android.test.ServiceTestCase} will create its own internal
+ instances and inject them into the Service. You can override this behavior by creating and
+ injecting your own instances before starting the Service
+</p>
+<p>
+ To inject a mock Application object into the Service under test, first create a subclass of
+ {@link android.test.mock.MockApplication}. <code>MockApplication</code> is a subclass of
+ {@link android.app.Application} in which all the methods throw an Exception, so to use it
+ effectively you subclass it and override the methods you need. You then inject it into the
+ Service with the
+ {@link android.test.ServiceTestCase#setApplication(Application) setApplication()} method.
+ This mock object allows you to control the application values that the Service sees, and
+ isolates it from the real system. In addition, any hidden dependencies your Service has on
+ its application reveal themselves as exceptions when you run the test.
+</p>
+<p>
+ You inject a mock Context into the Service under test with the
+ {@link android.test.AndroidTestCase#setContext(Context) setContext()} method. The mock
+ Context classes you can use are described in more detail in
+ <a href="{@docRoot}tools/testing/testing_android.html#MockObjectClasses">
+ Testing Fundamentals</a>.
+</p>
+<h2 id="TestAreas">What to Test</h2>
+<p>
+ The topic <a href="{@docRoot}tools/testing/what_to_test.html">What To Test</a>
+ lists general considerations for testing Android components.
+ Here are some specific guidelines for testing a Service:
+</p>
+<ul>
+ <li>
+ Ensure that the {@link android.app.Service#onCreate()} is called in response to
+ {@link android.content.Context#startService(Intent) Context.startService()} or
+ {@link android.content.Context#bindService(Intent,ServiceConnection,int) Context.bindService()}.
+ Similarly, you should ensure that {@link android.app.Service#onDestroy()} is called in
+ response to {@link android.content.Context#stopService(Intent) Context.stopService()},
+ {@link android.content.Context#unbindService(ServiceConnection) Context.unbindService()},
+ {@link android.app.Service#stopSelf()}, or
+ {@link android.app.Service#stopSelfResult(int) stopSelfResult()}.
+ </li>
+ <li>
+ Test that your Service correctly handles multiple calls from
+ <code>Context.startService()</code>. Only the first call triggers
+ <code>Service.onCreate()</code>, but all calls trigger a call to
+ <code>Service.onStartCommand()</code>.
+ <p>
+ In addition, remember that <code>startService()</code> calls don't
+ nest, so a single call to <code>Context.stopService()</code> or
+ <code>Service.stopSelf()</code> (but not <code>stopSelf(int)</code>)
+ will stop the Service. You should test that your Service stops at the correct point.
+ </p>
+ </li>
+ <li>
+ Test any business logic that your Service implements. Business logic includes checking for
+ invalid values, financial and arithmetic calculations, and so forth.
+ </li>
+</ul>
diff --git a/docs/html/tools/testing/testing_android.jd b/docs/html/tools/testing/testing_android.jd
new file mode 100755
index 0000000..acf5ec2e
--- /dev/null
+++ b/docs/html/tools/testing/testing_android.jd
@@ -0,0 +1,640 @@
+page.title=Testing Fundamentals
+parent.title=Testing
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#TestStructure">Test Structure</a>
+ </li>
+ <li>
+ <a href="#TestProjects">Test Projects</a>
+ </li>
+ <li>
+ <a href="#TestAPI">The Testing API</a>
+ <ol>
+ <li>
+ <a href="#JUnit">JUnit</a>
+ </li>
+ <li>
+ <a href="#Instrumentation">Instrumentation</a>
+ </li>
+ <li>
+ <a href="#TestCaseClasses">Test case classes</a>
+ </li>
+ <li>
+ <a href="#AssertionClasses">Assertion classes</a>
+ </li>
+ <li>
+ <a href="#MockObjectClasses">Mock object classes</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#InstrumentationTestRunner">Running Tests</a>
+ </li>
+ <li>
+ <a href="#TestResults">Seeing Test Results</a>
+ </li>
+ <li>
+ <a href="#Monkeys">monkey and monkeyrunner</a>
+ </li>
+ <li>
+ <a href="#PackageNames">Working With Package Names</a>
+ </li>
+ <li>
+ <a href="#WhatToTest">What To Test</a>
+ </li>
+ <li>
+ <a href="#NextSteps">Next Steps</a>
+ </li>
+ </ol>
+ <h2>Key classes</h2>
+ <ol>
+ <li>{@link android.test.InstrumentationTestRunner}</li>
+ <li>{@link android.test}</li>
+ <li>{@link android.test.mock}</li>
+ <li>{@link junit.framework}</li>
+ </ol>
+ <h2>Related tutorials</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>
+ </li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing from Eclipse with ADT</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing from Other IDEs</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/help/monkeyrunner_concepts.html">
+ monkeyrunner</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/help/monkey.html">UI/Application Exerciser Monkey</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ The Android testing framework, an integral part of the development environment,
+ provides an architecture and powerful tools that help you test every aspect of your application
+ at every level from unit to framework.
+</p>
+<p>
+ The testing framework has these key features:
+</p>
+<ul>
+ <li>
+ Android test suites are based on JUnit. You can use plain JUnit to test a class that doesn't
+ call the Android API, or Android's JUnit extensions to test Android components. If you're
+ new to Android testing, you can start with general-purpose test case classes such as {@link
+ android.test.AndroidTestCase} and then go on to use more sophisticated classes.
+ </li>
+ <li>
+ The Android JUnit extensions provide component-specific test case classes. These classes
+ provide helper methods for creating mock objects and methods that help you control the
+ lifecycle of a component.
+ </li>
+ <li>
+ Test suites are contained in test packages that are similar to main application packages, so
+ you don't need to learn a new set of tools or techniques for designing and building tests.
+ </li>
+ <li>
+ The SDK tools for building and tests are available in Eclipse with ADT, and also in
+ command-line form for use with other IDES. These tools get information from the project of
+ the application under test and use this information to automatically create the build files,
+ manifest file, and directory structure for the test package.
+ </li>
+ <li>
+ The SDK also provides
+ <a href="{@docRoot}tools/help/monkeyrunner_concepts.html">monkeyrunner</a>, an API
+ testing devices with Python programs, and <a
+ href="{@docRoot}tools/help/monkey.html">UI/Application Exerciser Monkey</a>,
+ a command-line tool for stress-testing UIs by sending pseudo-random events to a device.
+ </li>
+</ul>
+<p>
+ This document describes the fundamentals of the Android testing framework, including the
+ structure of tests, the APIs that you use to develop tests, and the tools that you use to run
+ tests and view results. The document assumes you have a basic knowledge of Android application
+ programming and JUnit testing methodology.
+</p>
+<p>
+ The following diagram summarizes the testing framework:
+</p>
+<div style="width: 70%; margin-left:auto; margin-right:auto;">
+<a href="{@docRoot}images/testing/test_framework.png">
+ <img src="{@docRoot}images/testing/test_framework.png"
+ alt="The Android testing framework"/>
+</a>
+</div>
+<h2 id="TestStructure">Test Structure</h2>
+<p>
+ Android's build and test tools assume that test projects are organized into a standard
+ structure of tests, test case classes, test packages, and test projects.
+</p>
+<p>
+ Android testing is based on JUnit. In general, a JUnit test is a method whose
+ statements test a part of the application under test. You organize test methods into classes
+ called test cases (or test suites). Each test is an isolated test of an individual module in
+ the application under test. Each class is a container for related test methods, although it
+ often provides helper methods as well.
+</p>
+<p>
+ In JUnit, you build one or more test source files into a class file. Similarly, in Android you
+ use the SDK's build tools to build one or more test source files into class files in an
+ Android test package. In JUnit, you use a test runner to execute test classes. In Android, you
+ use test tools to load the test package and the application under test, and the tools then
+ execute an Android-specific test runner.
+</p>
+<h2 id="TestProjects">Test Projects</h2>
+<p>
+ Tests, like Android applications, are organized into projects.
+</p>
+<p>
+ A test project is a directory or Eclipse project in which you create the source code, manifest
+ file, and other files for a test package. The Android SDK contains tools for Eclipse with ADT
+ and for the command line that create and update test projects for you. The tools create the
+ directories you use for source code and resources and the manifest file for the test package.
+ The command-line tools also create the Ant build files you need.
+</p>
+<p>
+ You should always use Android tools to create a test project. Among other benefits,
+ the tools:
+</p>
+ <ul>
+ <li>
+ Automatically set up your test package to use
+ {@link android.test.InstrumentationTestRunner} as the test case runner. You must use
+ <code>InstrumentationTestRunner</code> (or a subclass) to run JUnit tests.
+ </li>
+ <li>
+ Create an appropriate name for the test package. If the application
+ under test has a package name of <code>com.mydomain.myapp</code>, then the
+ Android tools set the test package name to <code>com.mydomain.myapp.test</code>. This
+ helps you identify their relationship, while preventing conflicts within the system.
+ </li>
+ <li>
+ Automatically create the proper build files, manifest file, and directory
+ structure for the test project. This helps you to build the test package without
+ having to modify build files and sets up the linkage between your test package and
+ the application under test.
+ The
+ </li>
+ </ul>
+<p>
+ You can create a test project anywhere in your file system, but the best approach is to
+ add the test project so that its root directory <code>tests/</code> is at the same level
+ as the <code>src/</code> directory of the main application's project. This helps you find the
+ tests associated with an application. For example, if your application project's root directory
+ is <code>MyProject</code>, then you should use the following directory structure:
+</p>
+<pre class="classic no-pretty-print">
+ MyProject/
+ AndroidManifest.xml
+ res/
+ ... (resources for main application)
+ src/
+ ... (source code for main application) ...
+ tests/
+ AndroidManifest.xml
+ res/
+ ... (resources for tests)
+ src/
+ ... (source code for tests)
+</pre>
+<h2 id="TestAPI">The Testing API</h2>
+<p>
+ The Android testing API is based on the JUnit API and extended with a instrumentation
+ framework and Android-specific testing classes.
+</p>
+<h3 id="JUnit">JUnit</h3>
+<p>
+ You can use the JUnit {@link junit.framework.TestCase TestCase} class to do unit testing on
+ a class that doesn't call Android APIs. <code>TestCase</code> is also the base class for
+ {@link android.test.AndroidTestCase}, which you can use to test Android-dependent objects.
+ Besides providing the JUnit framework, AndroidTestCase offers Android-specific setup,
+ teardown, and helper methods.
+</p>
+<p>
+ You use the JUnit {@link junit.framework.Assert} class to display test results.
+ The assert methods compare values you expect from a test to the actual results and
+ throw an exception if the comparison fails. Android also provides a class of assertions that
+ extend the possible types of comparisons, and another class of assertions for testing the UI.
+ These are described in more detail in the section <a href="#AssertionClasses">
+ Assertion classes</a>
+</p>
+<p>
+ To learn more about JUnit, you can read the documentation on the
+ <a href="http://www.junit.org">junit.org</a> home page.
+ Note that the Android testing API supports JUnit 3 code style, but not JUnit 4. Also, you must
+ use Android's instrumented test runner {@link android.test.InstrumentationTestRunner} to run
+ your test case classes. This test runner is described in the
+ section <a href="#InstrumentationTestRunner">Running Tests</a>.
+</p>
+<h3 id="Instrumentation">Instrumentation</h3>
+<p>
+ Android instrumentation is a set of control methods or "hooks" in the Android system. These hooks
+ control an Android component independently of its normal lifecycle. They also control how
+ Android loads applications.
+</p>
+<p>
+ Normally, an Android component runs in a lifecycle determined by the system. For example, an
+ Activity object's lifecycle starts when the Activity is activated by an Intent. The object's
+ <code>onCreate()</code> method is called, followed by <code>onResume()</code>. When the user
+ starts another application, the <code>onPause()</code> method is called. If the Activity
+ code calls the <code>finish()</code> method, the <code>onDestroy()</code> method is called.
+ The Android framework API does not provide a way for your code to invoke these callback
+ methods directly, but you can do so using instrumentation.
+</p>
+<p>
+ Also, the system runs all the components of an application into the same
+ process. You can allow some components, such as content providers, to run in a separate process,
+ but you can't force an application to run in the same process as another application that is
+ already running.
+</p>
+<p>
+ With Android instrumentation, though, you can invoke callback methods in your test code.
+ This allows you to run through the lifecycle of a component step by step, as if you were
+ debugging the component. The following test code snippet demonstrates how to use this to
+ test that an Activity saves and restores its state:
+</p>
+<a name="ActivitySnippet"></a>
+<pre>
+ // Start the main activity of the application under test
+ mActivity = getActivity();
+
+ // Get a handle to the Activity object's main UI widget, a Spinner
+ mSpinner = (Spinner)mActivity.findViewById(com.android.example.spinner.R.id.Spinner01);
+
+ // Set the Spinner to a known position
+ mActivity.setSpinnerPosition(TEST_STATE_DESTROY_POSITION);
+
+ // Stop the activity - The onDestroy() method should save the state of the Spinner
+ mActivity.finish();
+
+ // Re-start the Activity - the onResume() method should restore the state of the Spinner
+ mActivity = getActivity();
+
+ // Get the Spinner's current position
+ int currentPosition = mActivity.getSpinnerPosition();
+
+ // Assert that the current position is the same as the starting position
+ assertEquals(TEST_STATE_DESTROY_POSITION, currentPosition);
+</pre>
+<p>
+ The key method used here is
+ {@link android.test.ActivityInstrumentationTestCase2#getActivity()}, which is a
+ part of the instrumentation API. The Activity under test is not started until you call this
+ method. You can set up the test fixture in advance, and then call this method to start the
+ Activity.
+</p>
+<p>
+ Also, instrumentation can load both a test package and the application under test into the
+ same process. Since the application components and their tests are in the same process, the
+ tests can invoke methods in the components, and modify and examine fields in the components.
+</p>
+<h3 id="TestCaseClasses">Test case classes</h3>
+<p>
+ Android provides several test case classes that extend {@link junit.framework.TestCase} and
+ {@link junit.framework.Assert} with Android-specific setup, teardown, and helper methods.
+</p>
+<h4 id="AndroidTestCase">AndroidTestCase</h4>
+<p>
+ A useful general test case class, especially if you are
+ just starting out with Android testing, is {@link android.test.AndroidTestCase}. It extends
+ both {@link junit.framework.TestCase} and {@link junit.framework.Assert}. It provides the
+ JUnit-standard <code>setUp()</code> and <code>tearDown()</code> methods, as well as
+ all of JUnit's Assert methods. In addition, it provides methods for testing permissions, and a
+ method that guards against memory leaks by clearing out certain class references.
+</p>
+<h4 id="ComponentTestCase">Component-specific test cases</h4>
+<p>
+ A key feature of the Android testing framework is its component-specific test case classes.
+ These address specific component testing needs with methods for fixture setup and
+ teardown and component lifecycle control. They also provide methods for setting up mock objects.
+ These classes are described in the component-specific testing topics:
+</p>
+<ul>
+ <li>
+ <a href="{@docRoot}tools/testing/activity_testing.html">Activity Testing</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/contentprovider_testing.html">
+ Content Provider Testing</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/testing/service_testing.html">Service Testing</a>
+ </li>
+</ul>
+<p>
+ Android does not provide a separate test case class for BroadcastReceiver. Instead, test a
+ BroadcastReceiver by testing the component that sends it Intent objects, to verify that the
+ BroadcastReceiver responds correctly.
+</p>
+<h4 id="ApplicationTestCase">ApplicationTestCase</h4>
+<p>
+ You use the {@link android.test.ApplicationTestCase} test case class to test the setup and
+ teardown of {@link android.app.Application} objects. These objects maintain the global state of
+ information that applies to all the components in an application package. The test case can
+ be useful in verifying that the <application> element in the manifest file is correctly
+ set up. Note, however, that this test case does not allow you to control testing of the
+ components within your application package.
+</p>
+<h4 id="InstrumentationTestCase">InstrumentationTestCase</h4>
+<p>
+ If you want to use instrumentation methods in a test case class, you must use
+ {@link android.test.InstrumentationTestCase} or one of its subclasses. The
+ {@link android.app.Activity} test cases extend this base class with other functionality that
+ assists in Activity testing.
+</p>
+
+<h3 id="AssertionClasses">Assertion classes</h3>
+<p>
+ Because Android test case classes extend JUnit, you can use assertion methods to display the
+ results of tests. An assertion method compares an actual value returned by a test to an
+ expected value, and throws an AssertionException if the comparison test fails. Using assertions
+ is more convenient than doing logging, and provides better test performance.
+</p>
+<p>
+ Besides the JUnit {@link junit.framework.Assert} class methods, the testing API also provides
+ the {@link android.test.MoreAsserts} and {@link android.test.ViewAsserts} classes:
+</p>
+<ul>
+ <li>
+ {@link android.test.MoreAsserts} contains more powerful assertions such as
+ {@link android.test.MoreAsserts#assertContainsRegex}, which does regular expression
+ matching.
+ </li>
+ <li>
+ {@link android.test.ViewAsserts} contains useful assertions about Views. For example
+ it contains {@link android.test.ViewAsserts#assertHasScreenCoordinates} that tests if a View
+ has a particular X and Y position on the visible screen. These asserts simplify testing of
+ geometry and alignment in the UI.
+ </li>
+</ul>
+<h3 id="MockObjectClasses">Mock object classes</h3>
+<p>
+ To facilitate dependency injection in testing, Android provides classes that create mock system
+ objects such as {@link android.content.Context} objects,
+ {@link android.content.ContentProvider} objects, {@link android.content.ContentResolver}
+ objects, and {@link android.app.Service} objects. Some test cases also provide mock
+ {@link android.content.Intent} objects. You use these mocks both to isolate tests
+ from the rest of the system and to facilitate dependency injection for testing. These classes
+ are found in the packages {@link android.test} and {@link android.test.mock}.
+</p>
+<p>
+ Mock objects isolate tests from a running system by stubbing out or overriding
+ normal operations. For example, a {@link android.test.mock.MockContentResolver}
+ replaces the normal resolver framework with its own local framework, which is isolated
+ from the rest of the system. MockContentResolver also stubs out the
+ {@link android.content.ContentResolver#notifyChange(Uri, ContentObserver, boolean)} method
+ so that observer objects outside the test environment are not accidentally triggered.
+</p>
+<p>
+ Mock object classes also facilitate dependency injection by providing a subclass of the
+ normal object that is non-functional except for overrides you define. For example, the
+ {@link android.test.mock.MockResources} object provides a subclass of
+ {@link android.content.res.Resources} in which all the methods throw Exceptions when called.
+ To use it, you override only those methods that must provide information.
+</p>
+<p>
+ These are the mock object classes available in Android:
+</p>
+<h4 id="SimpleMocks">Simple mock object classes</h4>
+<p>
+ {@link android.test.mock.MockApplication}, {@link android.test.mock.MockContext},
+ {@link android.test.mock.MockContentProvider}, {@link android.test.mock.MockCursor},
+ {@link android.test.mock.MockDialogInterface}, {@link android.test.mock.MockPackageManager}, and
+ {@link android.test.mock.MockResources} provide a simple and useful mock strategy. They are
+ stubbed-out versions of the corresponding system object class, and all of their methods throw an
+ {@link java.lang.UnsupportedOperationException} exception if called. To use them, you override
+ the methods you need in order to provide mock dependencies.
+</p>
+<p class="Note"><strong>Note:</strong>
+ {@link android.test.mock.MockContentProvider}
+ and {@link android.test.mock.MockCursor} are new as of API level 8.
+</p>
+<h4 id="ResolverMocks">Resolver mock objects</h4>
+<p>
+ {@link android.test.mock.MockContentResolver} provides isolated testing of content providers by
+ masking out the normal system resolver framework. Instead of looking in the system to find a
+ content provider given an authority string, MockContentResolver uses its own internal table. You
+ must explicitly add providers to this table using
+ {@link android.test.mock.MockContentResolver#addProvider(String,ContentProvider)}.
+</p>
+<p>
+ With this feature, you can associate a mock content provider with an authority. You can create
+ an instance of a real provider but use test data in it. You can even set the provider for an
+ authority to <code>null</code>. In effect, a MockContentResolver object isolates your test
+ from providers that contain real data. You can control the
+ function of the provider, and you can prevent your test from affecting real data.
+</p>
+<h3 id="ContextMocks">Contexts for testing</h3>
+<p>
+ Android provides two Context classes that are useful for testing:
+</p>
+<ul>
+ <li>
+ {@link android.test.IsolatedContext} provides an isolated {@link android.content.Context},
+ File, directory, and database operations that use this Context take place in a test area.
+ Though its functionality is limited, this Context has enough stub code to respond to
+ system calls.
+ <p>
+ This class allows you to test an application's data operations without affecting real
+ data that may be present on the device.
+ </p>
+ </li>
+ <li>
+ {@link android.test.RenamingDelegatingContext} provides a Context in which
+ most functions are handled by an existing {@link android.content.Context}, but
+ file and database operations are handled by a {@link android.test.IsolatedContext}.
+ The isolated part uses a test directory and creates special file and directory names.
+ You can control the naming yourself, or let the constructor determine it automatically.
+ <p>
+ This object provides a quick way to set up an isolated area for data operations,
+ while keeping normal functionality for all other Context operations.
+ </p>
+ </li>
+</ul>
+<h2 id="InstrumentationTestRunner">Running Tests</h2>
+<p>
+ Test cases are run by a test runner class that loads the test case class, set ups,
+ runs, and tears down each test. An Android test runner must also be instrumented, so that
+ the system utility for starting applications can control how the test package
+ loads test cases and the application under test. You tell the Android platform
+ which instrumented test runner to use by setting a value in the test package's manifest file.
+</p>
+<p>
+ {@link android.test.InstrumentationTestRunner} is the primary Android test runner class. It
+ extends the JUnit test runner framework and is also instrumented. It can run any of the test
+ case classes provided by Android and supports all possible types of testing.
+</p>
+<p>
+ You specify <code>InstrumentationTestRunner</code> or a subclass in your test package's
+ manifest file, in the
+<code><a href="{@docRoot}guide/topics/manifest/instrumentation-element.html"><instrumentation></a></code>
+ element. Also, <code>InstrumentationTestRunner</code> code resides
+ in the shared library <code>android.test.runner</code>, which is not normally linked to
+ Android code. To include it, you must specify it in a
+<code><a href="{@docRoot}guide/topics/manifest/uses-library-element.html"><uses-library></a></code>
+ element. You do not have to set up these elements yourself. Both Eclipse with ADT and the
+ <code>android</code> command-line tool construct them automatically and add them to your
+ test package's manifest file.
+</p>
+<p class="Note">
+ <strong>Note:</strong> If you use a test runner other than
+ <code>InstrumentationTestRunner</code>, you must change the <instrumentation>
+ element to point to the class you want to use.
+</p>
+<p>
+ To run {@link android.test.InstrumentationTestRunner}, you use internal system classes called by
+ Android tools. When you run a test in Eclipse with ADT, the classes are called automatically.
+ When you run a test from the command line, you run these classes with
+ <a href="{@docRoot}tools/help/adb.html">Android Debug Bridge (adb)</a>.
+</p>
+<p>
+ The system classes load and start the test package, kill any processes that
+ are running an instance of the application under test, and then load a new instance of the
+ application under test. They then pass control to
+ {@link android.test.InstrumentationTestRunner}, which runs
+ each test case class in the test package. You can also control which test cases and
+ methods are run using settings in Eclipse with ADT, or using flags with the command-line tools.
+</p>
+<p>
+ Neither the system classes nor {@link android.test.InstrumentationTestRunner} run
+ the application under test. Instead, the test case does this directly. It either calls methods
+ in the application under test, or it calls its own methods that trigger lifecycle events in
+ the application under test. The application is under the complete control of the test case,
+ which allows it to set up the test environment (the test fixture) before running a test. This
+ is demonstrated in the previous <a href="#ActivitySnippet">code snippet</a> that tests an
+ Activity that displays a Spinner widget.
+</p>
+<p>
+ To learn more about running tests, please read the topics
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing from Eclipse with ADT</a> or
+ <a href="{@docRoot}tools/testing/testing_otheride.html">
+ Testing from Other IDEs</a>.
+</p>
+<h2 id="TestResults">Seeing Test Results</h2>
+<p>
+ The Android testing framework returns test results back to the tool that started the test.
+ If you run a test in Eclipse with ADT, the results are displayed in a new JUnit view pane. If
+ you run a test from the command line, the results are displayed in <code>STDOUT</code>. In
+ both cases, you see a test summary that displays the name of each test case and method that
+ was run. You also see all the assertion failures that occurred. These include pointers to the
+ line in the test code where the failure occurred. Assertion failures also list the expected
+ value and actual value.
+</p>
+<p>
+ The test results have a format that is specific to the IDE that you are using. The test
+ results format for Eclipse with ADT is described in
+ <a href="{@docRoot}tools/testing/testing_eclipse.html#RunTestEclipse">
+ Testing from Eclipse with ADT</a>. The test results format for tests run from the
+ command line is described in
+ <a href="{@docRoot}tools/testing/testing_otheride.html#RunTestsCommand">
+ Testing from Other IDEs</a>.
+</p>
+<h2 id="Monkeys">monkey and monkeyrunner</h2>
+<p>
+ The SDK provides two tools for functional-level application testing:
+</p>
+ <ul>
+ <li>
+The <a href="{@docRoot}tools/help/monkey.html">UI/Application Exerciser Monkey</a>,
+ usually called "monkey", is a command-line tool that sends pseudo-random streams of
+ keystrokes, touches, and gestures to a device. You run it with the
+ <a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a> (adb) tool.
+ You use it to stress-test your application and report back errors that are encountered.
+ You can repeat a stream of events by running the tool each time with the same random
+ number seed.
+ </li>
+ <li>
+ The <a href="{@docRoot}tools/help/monkeyrunner_concepts.html">monkeyrunner</a> tool
+ is an API and execution environment for test programs written in Python. The API
+ includes functions for connecting to a device, installing and uninstalling packages,
+ taking screenshots, comparing two images, and running a test package against an
+ application. Using the API, you can write a wide range of large, powerful, and complex
+ tests. You run programs that use the API with the <code>monkeyrunner</code> command-line
+ tool.
+ </li>
+ </ul>
+<h2 id="PackageNames">Working With Package names</h2>
+<p>
+ In the test environment, you work with both Android application package names and
+ Java package identifiers. Both use the same naming format, but they represent substantially
+ different entities. You need to know the difference to set up your tests correctly.
+</p>
+<p>
+ An Android package name is a unique system name for a <code>.apk</code> file, set by the
+ "android:package" attribute of the <manifest> element in the package's
+ manifest. The Android package name of your test package must be different from the
+ Android package name of the application under test. By default, Android tools create the
+ test package name by appending ".test" to the package name of the application under test.
+</p>
+<p>
+ The test package also uses an Android package name to target the application package it
+ tests. This is set in the "android:targetPackage" attribute of the
+ <instrumentation> element in the test package's manifest.
+</p>
+<p>
+ A Java package identifier applies to a source file. This package name reflects the directory
+ path of the source file. It also affects the visibility of classes and members to each other.
+</p>
+<p>
+ Android tools that create test projects set up an Android test package name for you.
+ From your input, the tools set up the test package name and the target package name for the
+ application under test. For these tools to work, the application project must already exist.
+</p>
+<p>
+ By default, these tools set the Java package identifier for the test class to be the same
+ as the Android package identifier. You may want to change this if you want to expose
+ members in the application under test by giving them package visibility. If you do this,
+ change only the Java package identifier, not the Android package names, and change only the
+ test case source files. Do not change the Java package name of the generated
+ <code>R.java</code> class in your test package, because it will then conflict with the
+ <code>R.java</code> class in the application under test. Do not change the Android package name
+ of your test package to be the same as the application it tests, because then their names
+ will no longer be unique in the system.
+</p>
+<h2 id="WhatToTest">What to Test</h2>
+<p>
+ The topic <a href="{@docRoot}tools/testing/what_to_test.html">What To Test</a>
+ describes the key functionality you should test in an Android application, and the key
+ situations that might affect that functionality.
+</p>
+<p>
+ Most unit testing is specific to the Android component you are testing.
+ The topics <a href="{@docRoot}tools/testing/activity_testing.html">Activity Testing</a>,
+ <a href="{@docRoot}tools/testing/contentprovider_testing.html">
+ Content Provider Testing</a>, and <a href="{@docRoot}tools/testing/service_testing.html">
+ Service Testing</a> each have a section entitled "What To Test" that lists possible testing
+ areas.
+</p>
+<p>
+ When possible, you should run these tests on an actual device. If this is not possible, you can
+ use the <a href="{@docRoot}tools/devices/emulator.html">Android Emulator</a> with
+ Android Virtual Devices configured for the hardware, screens, and versions you want to test.
+</p>
+<h2 id="NextSteps">Next Steps</h2>
+<p>
+ To learn how to set up and run tests in Eclipse, please refer to
+<a href="{@docRoot}tools/testing/testing_eclipse.html">Testing from Eclipse with ADT</a>.
+ If you're not working in Eclipse, refer to
+<a href="{@docRoot}tools/testing/testing_otheride.html">Testing from Other IDEs</a>.
+</p>
+<p>
+ If you want a step-by-step introduction to Android testing, try the
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing Tutorial</a>.
+</p>
diff --git a/docs/html/tools/testing/testing_eclipse.jd b/docs/html/tools/testing/testing_eclipse.jd
new file mode 100644
index 0000000..7d3be47
--- /dev/null
+++ b/docs/html/tools/testing/testing_eclipse.jd
@@ -0,0 +1,535 @@
+page.title=Testing from Eclipse with ADT
+parent.title=Testing
+parent.link=index.html
+@jd:body
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#CreateTestProjectEclipse">Creating a Test Project</a></li>
+ <li><a href="#CreateTestAppEclipse">Creating a Test Package</a></li>
+ <li><a href="#RunTestEclipse">Running Tests</a></li>
+ </ol>
+ </div>
+</div>
+<p>
+ This topic explains how create and run tests of Android applications in Eclipse with ADT.
+ Before you read this topic, you should read about how to create an Android application with the
+ basic processes for creating and running applications with ADT, as described in
+ <a href="{@docRoot}tools/projects/projects-eclipse.html">Managing Projects from
+Eclipse</a>
+ and <a href="{@docRoot}tools/building/building-eclipse.html">Building and Running
+from Eclipse</a>.
+ You may also want to read
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ which provides an overview of the Android testing framework.
+</p>
+<p>
+ ADT provides several features that help you set up and manage your testing environment
+ effectively:
+</p>
+ <ul>
+ <li>
+ It lets you quickly create a test project and link it to the application under test.
+ When it creates the test project, it automatically inserts the necessary
+ <code><instrumentation></code> element in the test package's manifest file.
+ </li>
+ <li>
+ It lets you quickly import the classes of the application under test, so that your
+ tests can inspect them.
+ </li>
+ <li>
+ It lets you create run configurations for your test package and include in
+ them flags that are passed to the Android testing framework.
+ </li>
+ <li>
+ It lets you run your test package without leaving Eclipse. ADT builds both the
+ application under test and the test package automatically, installs them if
+ necessary to your device or emulator, runs the test package, and displays the
+ results in a separate window in Eclipse.
+ </li>
+ </ul>
+<p>
+ If you are not developing in Eclipse or you want to learn how to create and run tests from the
+ command line, see
+ <a href="{@docRoot}tools/testing/testing_otheride.html">Testing from Other IDEs</a>.
+</p>
+<h2 id="CreateTestProjectEclipse">Creating a Test Project</h2>
+<p>
+ To set up a test environment for your Android application, you must first create a separate
+ project that holds the test code. The new project follows the directory structure
+ used for any Android application. It includes the same types of content and files, such as
+ source code, resources, a manifest file, and so forth. The test package you
+ create is connected to the application under test by an
+ <a href="{@docRoot}guide/topics/manifest/instrumentation-element.html">
+ <code><instrumentation></code></a> element in its manifest file.
+</p>
+<p>
+ The <em>New Android Test Project</em> dialog makes it easy for you to generate a
+ new test project that has the proper structure, including the
+ <code><instrumentation></code> element in the manifest file. You can use the New
+ Android Test Project dialog to generate the test project at any time. The dialog appears
+ just after you create a new Android main application project, but you can also run it to
+ create a test project for a project that you created previously.
+</p>
+<p>
+ To create a test project in Eclipse with ADT:
+</p>
+<ol>
+ <li>
+ In Eclipse, select <strong>File > New > Other</strong>. This opens the <em>Select a
+ Wizard</em> dialog.
+ </li>
+ <li>
+ In the dialog, in the <em>Wizards</em> drop-down list, find the entry for Android, then
+ click the toggle to the left. Select <strong>Android Test Project</strong>, then at the
+ bottom of the dialog click <strong>Next</strong>. The <em>New Android Test Project</em>
+ wizard appears.
+ </li>
+ <li>
+ Next to <em>Test Project Name</em>, enter a name for the project. You may use any name,
+ but you may want to associate the name with the project name for the application under test.
+ One way to do this is to take the application's project name, append the string "Test" to
+ it, and then use this as the test package project name.
+ <p>
+ The name becomes part of the suggested project path, but you can change this in the
+ next step.
+ </p>
+ </li>
+ <li>
+ In the <em>Content</em> panel, examine the suggested path to the project.
+ If <em>Use default location</em> is set, then the wizard will suggest a path that is
+ a concatenation of the workspace path and the project name you entered. For example,
+ if your workspace path is <code>/usr/local/workspace</code> and your project name is
+ <code>MyTestApp</code>, then the wizard will suggest
+ <code>/usr/local/workspace/MyTestApp</code>. To enter your own
+ choice for a path, unselect <em>Use default location</em>, then enter or browse to the
+ path where you want your project.
+ <p>
+ To learn more about choosing the location of test projects, please read
+ <a href="{@docRoot}tools/testing/testing_android.html#TestProjectPaths">
+ Testing Fundamentals</a>.
+ </p>
+ </li>
+ <li>
+ In the Test Target panel, set An Existing Android Project, click Browse, then select your
+ Android application from the list. You now see that the wizard has completed the Test
+ Target Package, Application Name, and Package Name fields for you (the latter two are in
+ the Properties panel).
+ </li>
+ <li>
+ In the Build Target panel, select the Android SDK platform that the application under test
+ uses.
+ </li>
+ <li>
+ Click Finish to complete the wizard. If Finish is disabled, look for error messages at the
+ top of the wizard dialog, and then fix any problems.
+ </li>
+</ol>
+<h2 id="CreateTestAppEclipse">Creating a Test Package</h2>
+<p>
+ Once you have created a test project, you populate it with a test package. This package does not
+ require an Activity, although you can define one if you wish. Although your test package can
+ combine Activity classes, test case classes, or ordinary classes, your main test case
+ should extend one of the Android test case classes or JUnit classes, because these provide the
+ best testing features.
+</p>
+<p>
+ Test packages do not need to have an Android GUI. When you run the package in
+ Eclipse with ADT, its results appear in the JUnit view. Running tests and seeing the results is
+ described in more detail in the section <a href="#RunTestEclipse">Running Tests</a>.
+</p>
+
+<p>
+ To create a test package, start with one of Android's test case classes defined in
+ {@link android.test android.test}. These extend the JUnit
+ {@link junit.framework.TestCase TestCase} class. The Android test classes for Activity objects
+ also provide instrumentation for testing an Activity. To learn more about test case
+ classes, please read the topic <a href="{@docRoot}tools/testing/testing_android.html">
+ Testing Fundamentals</a>.
+</p>
+<p>
+ Before you create your test package, you choose the Java package identifier you want to use
+ for your test case classes and the Android package name you want to use. To learn more
+ about this, please read
+ <a href="{@docRoot}tools/testing/testing_android.html#PackageNames">
+ Testing Fundamentals</a>.
+</p>
+<p>
+ To add a test case class to your project:
+</p>
+<ol>
+ <li>
+ In the <em>Project Explorer</em> tab, open your test project, then open the <em>src</em>
+ folder.
+ </li>
+ <li>
+ Find the Java package identifier set by the projection creation wizard. If you haven't
+ added classes yet, this node won't have any children, and its icon will not be filled in.
+ If you want to change the identifier value, right-click the identifier and select
+ <strong>Refactor</strong> > <strong>Rename</strong>, then enter the new name.
+ </li>
+ <li>
+ When you are ready, right-click the Java package identifier again and select
+ <strong>New</strong> > <strong>Class</strong>. This displays the <em>New Java Class</em>
+ dialog, with the <em>Source folder</em> and <em>Package</em> values already set.
+ </li>
+ <li>
+ In the <em>Name</em> field, enter a name for the test case class. One way to choose a
+ class name is to append the string "Test" to the class of the component you are testing.
+ For example, if you are testing the class MyAppActivity, your test case class
+ name would be MyAppActivityTest. Leave the modifiers set to <em>public</em>.
+ </li>
+ <li>
+ In the <em>Superclass</em> field, enter the name of the Android test case class you
+ are extending. You can also browse the available classes.
+ </li>
+ <li>
+ In <em>Which method stubs would you like to create?</em>, unset all the options, then
+ click <strong>Finish</strong>. You will set up the constructor manually.
+ </li>
+ <li>
+ Your new class appears in a new Java editor pane.
+ </li>
+</ol>
+<p>
+ You now have to ensure that the constructor is set up correctly. Create a constructor for your
+ class that has no arguments; this is required by JUnit. As the first statement in this
+ constructor, add a call to the base class' constructor. Each base test case class has its
+ own constructor signature. Refer to the class documentation in the documentation for
+ {@link android.test} for more information.
+</p>
+<p>
+ To control your test environment, you will want to override the <code>setUp()</code> and
+ <code>tearDown()</code> methods:
+</p>
+<ul>
+ <li>
+ <code>setUp()</code>: This method is invoked before any of the test methods in the class.
+ Use it to set up the environment for the test (the test fixture. You can use
+ <code>setUp()</code> to instantiate a new Intent with the action <code>ACTION_MAIN</code>.
+ You can then use this intent to start the Activity under test.
+ </li>
+ <li>
+ <code>tearDown()</code>: This method is invoked after all the test methods in the class. Use
+ it to do garbage collection and to reset the test fixture.
+ </li>
+</ul>
+<p>
+ Another useful convention is to add the method <code>testPreconditions()</code> to your test
+ class. Use this method to test that the application under test is initialized correctly. If this
+ test fails, you know that that the initial conditions were in error. When this happens, further
+ test results are suspect, regardless of whether or not the tests succeeded.
+</p>
+<p>
+ The Resources tab contains an
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing</a>
+ tutorial with more information about creating test classes and methods.
+</p>
+<h2 id="RunTestEclipse">Running Tests</h2>
+ <div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Running tests from the command line</h2>
+ <p>
+ If you've created your tests in Eclipse, you can still run your tests and test
+ suites by using command-line tools included with the Android SDK. You may want
+ to do this, for example, if you have a large number of tests to run, if you
+ have a large test case, or if you want a fine level of control over which
+ tests are run at a particular time.
+ </p>
+ <p>
+ To run tests created in Eclipse with ADT with command-line tools, you must first
+ install additional files into the test project using the <code>android</code>
+ tool's "create test-project" option. To see how to do this, read
+ <a href="{@docRoot}tools/testing/testing_otheride.html#CreateProject">
+ Testing in Other IDEs</a>.
+ </p>
+ </div>
+ </div>
+<p>
+ When you run a test package in Eclipse with ADT, the output appears in the Eclipse JUnit view.
+ You can run the entire test package or one test case class. To do run tests, Eclipse runs the
+ <code>adb</code> command for running a test package, and displays the output, so there is no
+ difference between running tests inside Eclipse and running them from the command line.
+</p>
+<p>
+ As with any other package, to run a test package in Eclipse with ADT you must either attach a
+ device to your computer or use the Android emulator. If you use the emulator, you must have an
+ Android Virtual Device (AVD) that uses the same target as the test package.
+</p>
+<p>
+ To run a test in Eclipse, you have two choices:</p>
+<ul>
+ <li>
+ Run a test just as you run an application, by selecting
+ <strong>Run As... > Android JUnit Test</strong> from the project's context menu or
+ from the main menu's <strong>Run</strong> item.
+ </li>
+ <li>
+ Create an Eclipse run configuration for your test project. This is useful if you want
+ multiple test suites, each consisting of selected tests from the project. To run
+ a test suite, you run the test configuration.
+ <p>
+ Creating and running test configurations is described in the next section.
+ </p>
+ </li>
+</ul>
+<p>
+ To create and run a test suite using a run configuration:
+</p>
+<ol>
+ <li>
+ In the Package Explorer, select the test project, then from the main menu, select
+ <strong>Run > Run Configurations...</strong>. The Run Configurations dialog appears.
+ </li>
+ <li>
+ In the left-hand pane, find the Android JUnit Test entry. In the right-hand pane, click the
+ Test tab. The Name: text box shows the name of your project. The Test class: dropdown box
+ shows one of the test classes in your project.
+ </li>
+ <li>
+ To run one test class, click Run a single test, then enter your project name in the
+ Project: text box and the class name in the Test class: text box.
+ <p>
+ To run all the test classes, click Run all tests in the selected project or package,
+ then enter the project or package name in the text box.
+ </p>
+ </li>
+ <li>
+ Now click the Target tab.
+ <ul>
+ <li>
+ Optional: If you are using the emulator, click Automatic, then in the Android
+ Virtual Device (AVD) selection table, select an existing AVD.
+ </li>
+ <li>
+ In the Emulator Launch Parameters pane, set the Android emulator flags you want to
+ use. These are documented in the topic
+ <a href="{@docRoot}tools/help/emulator.html#startup-options">
+ Android Emulator</a>.
+ </li>
+ </ul>
+ </li>
+ <li>
+ Click the Common tab. In the Save As pane, click Local to save this run configuration
+ locally, or click Shared to save it to another project.
+ </li>
+ <li>
+ Optional: Add the configuration to the Run toolbar and the <strong>Favorites</strong>
+ menu: in the Display in Favorites pane click the checkbox next to Run.
+ </li>
+ <li>
+ Optional: To add this configuration to the <strong>Debug</strong> menu and toolbar, click
+ the checkbox next to Debug.
+ </li>
+ <li>
+ To save your settings, click Close.<br/>
+ <p class="note"><strong>Note:</strong>
+ Although you can run the test immediately by clicking Run, you should save the test
+ first and then run it by selecting it from the Eclipse standard toolbar.
+ </p>
+ </li>
+ <li>
+ On the Eclipse standard toolbar, click the down arrow next to the green Run arrow. This
+ displays a menu of saved Run and Debug configurations.
+ </li>
+ <li>
+ Select the test run configuration you just created. The test starts.
+ </li>
+</ol>
+<p>
+ The progress of your test appears in the Console view as a series of messages. Each message is
+ preceded by a timestamp and the <code>.apk</code> filename to which it applies. For example,
+ this message appears when you run a test to the emulator, and the emulator is not yet started:
+</p>
+<div class="sidebox-wrapper">
+ <div class="sidebox">
+ <h2>Message Examples</h2>
+ <p>
+ The examples shown in this section come from the
+ <a href="{@docRoot}resources/samples/SpinnerTest/index.html">SpinnerTest</a>
+ sample test package, which tests the
+ <a href="{@docRoot}resources/samples/Spinner/index.html">Spinner</a>
+ sample application. This test package is also featured in the
+ <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing</a>
+ tutorial.
+ </p>
+ </div>
+</div>
+<pre>
+ [<em>yyyy-mm-dd hh:mm:ss</em> - <em>testfile</em>] Waiting for HOME ('android.process.acore') to be launched...
+</pre>
+<p>
+ In the following description of these messages, <code><em>devicename</em></code> is the name of
+ the device or emulator you are using to run the test, and <code><em>port</em></code> is the
+ port number for the device. The name and port number are in the format used by the
+ <code><a href="{@docRoot}tools/help/adb.html#devicestatus">adb devices</a></code>
+ command. Also, <code><em>testfile</em></code> is the <code>.apk</code> filename of the test
+ package you are running, and <em>appfile</em> is the filename of the application under test.
+</p>
+<ul>
+ <li>
+ If you are using an emulator and you have not yet started it, then Eclipse
+ first starts the emulator. When this is complete, you see
+ the message:
+ <p>
+ <code>HOME is up on device '<em>devicename</em>-<em>port</em>'</code>
+ </p>
+ </li>
+ <li>
+ If you have not already installed your test package, then you see
+ the message:
+ <p>
+ <code>Uploading <em>testfile</em> onto device '<em>devicename</em>-<em>port</em>'
+ </code>
+ </p>
+ <p>
+ then the message <code>Installing <em>testfile</em></code>.
+ </p>
+ <p>
+ and finally the message <code>Success!</code>
+ </p>
+ </li>
+</ul>
+<p>
+ The following lines are an example of this message sequence:
+</p>
+<code>
+[2010-07-01 12:44:40 - MyTest] HOME is up on device 'emulator-5554'<br>
+[2010-07-01 12:44:40 - MyTest] Uploading MyTest.apk onto device 'emulator-5554'<br>
+[2010-07-01 12:44:40 - MyTest] Installing MyTest.apk...<br>
+[2010-07-01 12:44:49 - MyTest] Success!<br>
+</code>
+<br>
+<ul>
+ <li>
+ Next, if you have not yet installed the application under test to the device or
+ emulator, you see the message
+ <p>
+ <code>Project dependency found, installing: <em>appfile</em></code>
+ </p>
+ <p>
+ then the message <code>Uploading <em>appfile</em></code> onto device
+ '<em>devicename</em>-<em>port</em>'
+ </p>
+ <p>
+ then the message <code>Installing <em>appfile</em></code>
+ </p>
+ <p>
+ and finally the message <code>Success!</code>
+ </p>
+ </li>
+</ul>
+<p>
+ The following lines are an example of this message sequence:
+</p>
+<code>
+[2010-07-01 12:44:49 - MyTest] Project dependency found, installing: MyApp<br>
+[2010-07-01 12:44:49 - MyApp] Uploading MyApp.apk onto device 'emulator-5554'<br>
+[2010-07-01 12:44:49 - MyApp] Installing MyApp.apk...<br>
+[2010-07-01 12:44:54 - MyApp] Success!<br>
+</code>
+<br>
+<ul>
+ <li>
+ Next, you see the message
+ <code>Launching instrumentation <em>instrumentation_class</em> on device
+ <em>devicename</em>-<em>port</em></code>
+ <p>
+ <code>instrumentation_class</code> is the fully-qualified class name of the
+ instrumentation test runner you have specified (usually
+ {@link android.test.InstrumentationTestRunner}.
+ </p>
+ </li>
+ <li>
+ Next, as {@link android.test.InstrumentationTestRunner} builds a list of tests to run,
+ you see the message
+ <p>
+ <code>Collecting test information</code>
+ </p>
+ <p>
+ followed by
+ </p>
+ <p>
+ <code>Sending test information to Eclipse</code>
+ </p>
+ </li>
+ <li>
+ Finally, you see the message <code>Running tests</code>, which indicates that your tests
+ are running. At this point, you should start seeing the test results in the JUnit view.
+ When the tests are finished, you see the console message <code>Test run complete</code>.
+ This indicates that your tests are finished.
+ </li>
+</ul>
+<p>
+ The following lines are an example of this message sequence:
+</p>
+<code>
+[2010-01-01 12:45:02 - MyTest] Launching instrumentation android.test.InstrumentationTestRunner on device emulator-5554<br>
+[2010-01-01 12:45:02 - MyTest] Collecting test information<br>
+[2010-01-01 12:45:02 - MyTest] Sending test information to Eclipse<br>
+[2010-01-01 12:45:02 - MyTest] Running tests...<br>
+[2010-01-01 12:45:22 - MyTest] Test run complete<br>
+</code>
+<br>
+<p>
+ The test results appear in the JUnit view. This is divided into an upper summary pane,
+ and a lower stack trace pane.
+</p>
+<p>
+ The upper pane contains test information. In the pane's header, you see the following
+ information:
+</p>
+<ul>
+ <li>
+ Total time elapsed for the test package (labeled Finished after <em>x</em> seconds).
+ </li>
+ <li>
+ Number of runs (Runs:) - the number of tests in the entire test class.
+ </li>
+ <li>
+ Number of errors (Errors:) - the number of program errors and exceptions encountered
+ during the test run.
+ </li>
+ <li>
+ Number of failures (Failures:) - the number of test failures encountered during the test
+ run. This is the number of assertion failures. A test can fail even if the program does
+ not encounter an error.
+ </li>
+ <li>
+ A progress bar. The progress bar extends from left to right as the tests run. If all the
+ tests succeed, the bar remains green. If a test fails, the bar turns from green to red.
+ </li>
+</ul>
+<p>
+ The body of the upper pane contains the details of the test run. For each test case class
+ that was run, you see a line with the class name. To look at the results for the individual
+ test methods in that class, you click the left arrow to expand the line. You now see a
+ line for each test method in the class, and to its right the time it took to run.
+ If you double-click the method name, Eclipse opens the test class source in an editor view
+ pane and moves the focus to the first line of the test method.
+</p>
+<p>
+ The results of a successful test are shown in figure 1.
+</p>
+<a href="{@docRoot}images/testing/eclipse_test_results.png">
+ <img src="{@docRoot}images/testing/eclipse_test_results.png"
+ alt="Messages for a successful test" height="327px" id="TestResults"/>
+</a>
+<p class="img-caption">
+ <strong>Figure 1.</strong> Messages for a successful test.
+</p>
+<p>
+ The lower pane is for stack traces. If you highlight a failed test in the upper pane, the
+ lower pane contains a stack trace for the test. If a line corresponds to a point in your
+ test code, you can double-click it to display the code in an editor view pane, with the
+ line highlighted. For a successful test, the lower pane is empty.
+</p>
+<p>The results of a failed test are shown in figure 2.</p>
+<a href="{@docRoot}images/testing/eclipse_test_run_failure.png">
+ <img src="{@docRoot}images/testing/eclipse_test_run_failure.png"
+ alt="" height="372px" id="TestRun"/>
+</a>
+<p class="img-caption">
+ <strong>Figure 2.</strong> Messages for a test failure.
+</p>
diff --git a/docs/html/tools/testing/testing_otheride.jd b/docs/html/tools/testing/testing_otheride.jd
new file mode 100644
index 0000000..0678f52
--- /dev/null
+++ b/docs/html/tools/testing/testing_otheride.jd
@@ -0,0 +1,690 @@
+page.title=Testing from Other IDEs
+parent.title=Testing
+parent.link=index.html
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>In this document</h2>
+ <ol>
+ <li>
+ <a href="#CreateTestProjectCommand">Working with Test Projects</a>
+ <ol>
+ <li>
+ <a href="#CreateTestProject">Creating a test project</a>
+ </li>
+ <li>
+ <a href="#UpdateTestProject">Updating a test project</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#CreateTestApp">Creating a Test Package</a>
+ </li>
+ <li>
+ <a href="#RunTestsCommand">Running Tests</a>
+ <ol>
+ <li>
+ <a href="#RunTestsAnt">Quick build and run with Ant</a>
+ </li>
+ <li>
+ <a href="#RunTestsDevice">Running tests on a device or emulator</a>
+ </li>
+ </ol>
+ </li>
+ <li>
+ <a href="#AMSyntax">Using the Instrument Command</a>
+ <ol>
+ <li>
+ <a href="#AMOptionsSyntax">Instrument options</a>
+ </li>
+ <li>
+ <a href="#RunTestExamples">Instrument examples</a>
+ </li>
+ </ol>
+ </li>
+ </ol>
+ <h2>See Also</h2>
+ <ol>
+ <li>
+ <a href="{@docRoot}tools/testing/testing_android.html">
+ Testing Fundamentals</a>
+ </li>
+ <li>
+ <a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a>
+ </li>
+ </ol>
+ </div>
+</div>
+<p>
+ This document describes how to create and run tests directly from the command line.
+ You can use the techniques described here if you are developing in an IDE other than Eclipse
+ or if you prefer to work from the command line. This document assumes that you already know how
+ to create a Android application in your programming environment. Before you start this
+ document, you should read the topic
+ <a href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ which provides an overview of Android testing.
+</p>
+<p>
+ If you are developing in Eclipse with ADT, you can set up and run your tests
+ directly in Eclipse. For more information, please read
+ <a href="{@docRoot}tools/testing/testing_eclipse.html">
+ Testing from Eclipse with ADT</a>.
+</p>
+<h2 id="CreateTestProjectCommand">Working with Test Projects</h2>
+<p>
+ You use the <code>android</code> tool to create test projects.
+ You also use <code>android</code> to convert existing test code into an Android test project,
+ or to add the <code>run-tests</code> Ant target to an existing Android test project.
+ These operations are described in more detail in the section <a href="#UpdateTestProject">
+ Updating a test project</a>. The <code>run-tests</code> target is described in
+ <a href="#RunTestsAnt">Quick build and run with Ant</a>.
+</p>
+<h3 id="CreateTestProject">Creating a test project</h3>
+<p>
+ To create a test project with the <code>android</code> tool, enter:
+</p>
+<pre>
+android create test-project -m <main_path> -n <project_name> -p <test_path>
+</pre>
+<p>
+ You must supply all the flags. The following table explains them in detail:
+</p>
+<table>
+ <tr>
+ <th>Flag</th>
+ <th>Value</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td><code>-m, --main</code></td>
+ <td>
+ Path to the project of the application under test, relative to the test package
+ directory.
+ </td>
+ <td>
+ For example, if the application under test is in <code>source/HelloAndroid</code>, and
+ you want to create the test project in <code>source/HelloAndroidTest</code>, then the
+ value of <code>--main</code> should be <code>../HelloAndroid</code>.
+ <p>
+ To learn more about choosing the location of test projects, please read
+ <a href="{@docRoot}tools/testing/testing_android.html#TestProjects">
+ Testing Fundamentals</a>.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>-n, --name</code></td>
+ <td>Name that you want to give the test project.</td>
+ <td> </td>
+ </tr>
+ <tr>
+ <td><code>-p, --path</code></td>
+ <td>Directory in which you want to create the new test project.</td>
+ <td>
+ The <code>android</code> tool creates the test project files and directory structure
+ in this directory. If the directory does not exist, <code>android</code> creates it.
+ </td>
+ </tr>
+</table>
+<p>
+ If the operation is successful, <code>android</code> lists to STDOUT the names of the files
+ and directories it has created.
+</p>
+<p>
+ This creates a new test project with the appropriate directories and build files. The directory
+ structure and build file contents are identical to those in a regular Android application
+ project. They are described in detail in the topic
+ <a href="{@docRoot}tools/projects/index.html">Managing Projects</a>.
+</p>
+<p>
+ The operation also creates an <code>AndroidManifest.xml</code> file with instrumentation
+ information. When you run the test, Android uses this information to load the application you
+ are testing and control it with instrumentation.
+</p>
+<p>
+ For example, suppose you create a project in the directory <code>~/source/HelloAndroid</code>,
+with the package name <code>com.example.helloandroid</code>,
+ and the activity name <code>HelloAndroid</code>. You can to create the test for this in
+ <code>~/source/HelloAndroidTest</code>. To do so, you enter:
+</p>
+<pre>
+$ cd ~/source
+$ android create test-project -m ../HelloAndroid -n HelloAndroidTest -p HelloAndroidTest
+</pre>
+<p>
+ This creates a directory called <code>~/src/HelloAndroidTest</code>. In the new directory you
+ see the file <code>AndroidManifest.xml</code>. This file contains the following
+ instrumentation-related elements and attributes:
+</p>
+<ul>
+ <li>
+ <code><application></code>: to contain the
+ <code><uses-library></code> element.
+ </li>
+ <li>
+ <code><uses-library android:name="android.test.runner"</code>:
+ specifies this testing application uses the <code>android.test.runner</code> library.
+ </li>
+ <li>
+ <code><instrumentation></code>: contains attributes that control Android
+ instrumentation. The attributes are:
+ <ul>
+ <li>
+ <code>android:name="android.test.InstrumentationTestRunner"</code>:
+ {@link android.test.InstrumentationTestRunner} runs test cases. It extends both
+ JUnit test case runner classes and Android instrumentation classes.
+ </li>
+ <li>
+ <code>android:targetPackage="com.example.helloandroid"</code>: specifies
+ that the tests in HelloAndroidTest should be run against the application with the
+ <em>Android</em> package name <code>com.example.helloandroid</code>.
+ </li>
+ <li>
+ <code>android:label="Tests for .HelloAndroid"</code>: specifies a
+ user-readable label for the instrumentation class. By default,
+ the <code>android</code> tool gives it the value "Tests for " plus
+ the name of the main Activity of the application under test.
+ </li>
+ </ul>
+ </li>
+</ul>
+<h3 id="UpdateTestProject">Updating a test project</h3>
+<p>
+ You use the <code>android</code> tool when you need to change the path to the
+ project of the application under test. If you are changing an existing test project created in
+ Eclipse with ADT so that you can also build and run it from the command line, you must use the
+ "create" operation. See the section <a href="#CreateTestProject">Creating a test project</a>.
+</p>
+<p class="note">
+ <strong>Note:</strong> If you change the Android package name of the application under test,
+ you must <em>manually</em> change the value of the <code><android:targetPackage></code>
+ attribute within the <code>AndroidManifest.xml</code> file of the test package.
+ Running <code>android update test-project</code> does not do this.
+</p>
+<p>
+ To update a test project with the <code>android</code> tool, enter:
+</p>
+<pre>android update test-project -m <main_path> -p <test_path></pre>
+
+<table>
+ <tr>
+ <th>Flag</th>
+ <th>Value</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td><code>-m, --main</code></td>
+ <td>The path to the project of the application under test, relative to the test project</td>
+ <td>
+ For example, if the application under test is in <code>source/HelloAndroid</code>, and
+ the test project is in <code>source/HelloAndroidTest</code>, then the value for
+ <code>--main</code> is <code>../HelloAndroid</code>.
+ </td>
+ </tr>
+ <tr>
+ <td><code>-p, --path</code></td>
+ <td>The of the test project.</td>
+ <td>
+ For example, if the test project is in <code>source/HelloAndroidTest</code>, then the
+ value for <code>--path</code> is <code>HelloAndroidTest</code>.
+ </td>
+ </tr>
+</table>
+<p>
+ If the operation is successful, <code>android</code> lists to STDOUT the names of the files
+ and directories it has created.
+</p>
+<h2 id="CreateTestApp">Creating a Test Package</h2>
+<p>
+ Once you have created a test project, you populate it with a test package.
+ The application does not require an {@link android.app.Activity Activity},
+ although you can define one if you wish. Although your test package can
+ combine Activities, Android test class extensions, JUnit extensions, or
+ ordinary classes, you should extend one of the Android test classes or JUnit classes,
+ because these provide the best testing features.
+</p>
+<p>
+ If you run your tests with {@link android.test.InstrumentationTestRunner}
+ (or a related test runner), then it will run all the methods in each class. You can modify
+ this behavior by using the {@link junit.framework.TestSuite TestSuite} class.
+</p>
+
+<p>
+ To create a test package, start with one of Android's test classes in the Java package
+ {@link android.test android.test}. These extend the JUnit
+ {@link junit.framework.TestCase TestCase} class. With a few exceptions, the Android test
+ classes also provide instrumentation for testing.
+</p>
+<p>
+ For test classes that extend {@link junit.framework.TestCase TestCase}, you probably want to
+ override the <code>setUp()</code> and <code>tearDown()</code> methods:
+</p>
+<ul>
+ <li>
+ <code>setUp()</code>: This method is invoked before any of the test methods in the class.
+ Use it to set up the environment for the test. You can use <code>setUp()</code>
+ to instantiate a new <code>Intent</code> object with the action <code>ACTION_MAIN</code>.
+ You can then use this intent to start the Activity under test.
+ <p class="note">
+ <strong>Note:</strong> If you override this method, call
+ <code>super.setUp()</code> as the first statement in your code.
+ </p>
+ </li>
+ <li>
+ <code>tearDown()</code>: This method is invoked after all the test methods in the class. Use
+ it to do garbage collection and re-setting before moving on to the next set of tests.
+ <p class="note"><strong>Note:</strong> If you override this method, you must call
+ <code>super.tearDown()</code> as the <em>last</em> statement in your code.</p>
+ </li>
+</ul>
+<p>
+ Another useful convention is to add the method <code>testPreConditions()</code> to your test
+ class. Use this method to test that the application under test is initialized correctly. If this
+ test fails, you know that that the initial conditions were in error. When this happens, further
+ test results are suspect, regardless of whether or not the tests succeeded.
+</p>
+<p>
+ To learn more about creating test packages, see the topic <a
+ href="{@docRoot}tools/testing/testing_android.html">Testing Fundamentals</a>,
+ which provides an overview of Android testing. If you prefer to follow a tutorial,
+ try the <a href="{@docRoot}tools/testing/activity_test.html">Activity Testing</a>
+ tutorial, which leads you through the creation of tests for an actual Android application.
+</p>
+<h2 id="RunTestsCommand">Running Tests</h2>
+<p>
+ You run tests from the command line, either with Ant or with an
+ <a href="{@docRoot}tools/help/adb.html">
+ Android Debug Bridge (adb)</a> shell.
+</p>
+<h3 id="RunTestsAnt">Quick build and run with Ant</h3>
+<p>
+ You can use Ant to run all the tests in your test project, using the target
+ <code>run-tests</code>, which is created automatically when you create a test project with
+ the <code>android</code> tool.
+</p>
+<p>
+ This target re-builds your main project and test project if necessary, installs the test
+ application to the current AVD or device, and then runs all the test classes in the test
+ application. The results are directed to <code>STDOUT</code>.
+</p>
+<p>
+ You can update an existing test project to use this feature. To do this, use the
+ <code>android</code> tool with the <code>update test-project</code> option. This is described
+ in the section <a href="#UpdateTestProject">Updating a test project</a>.
+</p>
+<h3 id="RunTestsDevice">Running tests on a device or emulator</h3>
+<p>
+ When you run tests from the command line with
+ <a href="{@docRoot}tools/help/adb.html">
+ Android Debug Bridge (adb)</a>, you get more options for choosing the tests
+ to run than with any other method. You can select individual test methods, filter tests
+ according to their annotation, or specify testing options. Since the test run is controlled
+ entirely from a command line, you can customize your testing with shell scripts in various ways.
+</p>
+<p>
+ To run a test from the command line, you run <code>adb shell</code> to start a command-line
+ shell on your device or emulator, and then in the shell run the <code>am instrument</code>
+ command. You control <code>am</code> and your tests with command-line flags.
+</p>
+<p>
+ As a shortcut, you can start an <code>adb</code> shell, call <code>am instrument</code>, and
+ specify command-line flags all on one input line. The shell opens on the device or emulator,
+ runs your tests, produces output, and then returns to the command line on your computer.
+</p>
+<p>
+ To run a test with <code>am instrument</code>:
+</p>
+<ol>
+ <li>
+ If necessary, rebuild your main application and test package.
+ </li>
+ <li>
+ Install your test package and main application Android package files
+ (<code>.apk</code> files) to your current Android device or emulator</li>
+ <li>
+ At the command line, enter:
+<pre>
+$ adb shell am instrument -w <test_package_name>/<runner_class>
+</pre>
+ <p>
+ where <code><test_package_name></code> is the Android package name of your test
+ application, and <code><runner_class></code> is the name of the Android test
+ runner class you are using. The Android package name is the value of the
+ <code>package</code> attribute of the <code>manifest</code> element in the manifest file
+ (<code>AndroidManifest.xml</code>) of your test package. The Android test runner
+ class is usually {@link android.test.InstrumentationTestRunner}.
+ </p>
+ <p>
+ Your test results appear in <code>STDOUT</code>.
+ </p>
+ </li>
+</ol>
+<p>
+ This operation starts an <code>adb</code> shell, then runs <code>am instrument</code>
+ with the specified parameters. This particular form of the command will run all of the tests
+ in your test package. You can control this behavior with flags that you pass to
+ <code>am instrument</code>. These flags are described in the next section.
+</p>
+<h2 id="AMSyntax">Using the am instrument Command</h2>
+<p>
+ The general syntax of the <code>am instrument</code> command is:
+</p>
+<pre>
+ am instrument [flags] <test_package>/<runner_class>
+</pre>
+<p>
+ The main input parameters to <code>am instrument</code> are described in the following table:
+</p>
+<table>
+ <tr>
+ <th>
+ Parameter
+ </th>
+ <th>
+ Value
+ </th>
+ <th>
+ Description
+ </th>
+ </tr>
+ <tr>
+ <td>
+ <code><test_package></code>
+ </td>
+ <td>
+ The Android package name of the test package.
+ </td>
+ <td>
+ The value of the <code>package</code> attribute of the <code>manifest</code>
+ element in the test package's manifest file.
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <code><runner_class></code>
+ </td>
+ <td>
+ The class name of the instrumented test runner you are using.
+ </td>
+ <td>
+ This is usually {@link android.test.InstrumentationTestRunner}.
+ </td>
+ </tr>
+</table>
+<p>
+ The flags for <code>am instrument</code> are described in the following table:
+</p>
+<table>
+ <tr>
+ <th>
+ Flag
+ </th>
+ <th>
+ Value
+ </th>
+ <th>
+ Description
+ </th>
+ </tr>
+ <tr>
+ <td>
+ <code>-w</code>
+ </td>
+ <td>
+ (none)
+ </td>
+ <td>
+ Forces <code>am instrument</code> to wait until the instrumentation terminates
+ before terminating itself. The net effect is to keep the shell open until the tests
+ have finished. This flag is not required, but if you do not use it, you will not
+ see the results of your tests.
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <code>-r</code>
+ </td>
+ <td>
+ (none)
+ </td>
+ <td>
+ Outputs results in raw format. Use this flag when you want to collect
+ performance measurements, so that they are not formatted as test results. This flag is
+ designed for use with the flag <code>-e perf true</code> (documented in the section
+ <a href="#AMOptionsSyntax">Instrument options</a>).
+ </td>
+ </tr>
+ <tr>
+ <td>
+ <code>-e</code>
+ </td>
+ <td>
+ <test_options>
+ </td>
+ <td>
+ Provides testing options as key-value pairs. The
+ <code>am instrument</code> tool passes these to the specified instrumentation class
+ via its <code>onCreate()</code> method. You can specify multiple occurrences of
+ <code>-e <test_options></code>. The keys and values are described in the
+ section <a href="#AMOptionsSyntax">am instrument options</a>.
+ <p>
+ The only instrumentation class that uses these key-value pairs is
+ {@link android.test.InstrumentationTestRunner} (or a subclass). Using them with
+ any other class has no effect.
+ </p>
+ </td>
+ </tr>
+</table>
+
+<h3 id="AMOptionsSyntax">am instrument options</h3>
+<p>
+ The <code>am instrument</code> tool passes testing options to
+ <code>InstrumentationTestRunner</code> or a subclass in the form of key-value pairs,
+ using the <code>-e</code> flag, with this syntax:
+</p>
+<pre>
+ -e <key> <value>
+</pre>
+<p>
+ Some keys accept multiple values. You specify multiple values in a comma-separated list.
+ For example, this invocation of <code>InstrumentationTestRunner</code> provides multiple
+ values for the <code>package</code> key:
+</p>
+<pre>
+$ adb shell am instrument -w -e package com.android.test.package1,com.android.test.package2 \
+> com.android.test/android.test.InstrumentationTestRunner
+</pre>
+<p>
+ The following table describes the key-value pairs and their result. Please review the
+ <strong>Usage Notes</strong> following the table.
+</p>
+<table>
+ <tr>
+ <th>Key</th>
+ <th>Value</th>
+ <th>Description</th>
+ </tr>
+ <tr>
+ <td>
+ <code>package</code>
+ </td>
+ <td>
+ <Java_package_name>
+ </td>
+ <td>
+ The fully-qualified <em>Java</em> package name for one of the packages in the test
+ application. Any test case class that uses this package name is executed. Notice that
+ this is not an <em>Android</em> package name; a test package has a single
+ Android package name but may have several Java packages within it.
+ </td>
+ </tr>
+ <tr>
+ <td rowspan="2"><code>class</code></td>
+ <td><class_name></td>
+ <td>
+ The fully-qualified Java class name for one of the test case classes. Only this test
+ case class is executed.
+ </td>
+ </tr>
+ <tr>
+ <td><class_name><strong>#</strong>method name</td>
+ <td>
+ A fully-qualified test case class name, and one of its methods. Only this method is
+ executed. Note the hash mark (#) between the class name and the method name.
+ </td>
+ </tr>
+ <tr>
+ <td><code>func</code></td>
+ <td><code>true</code></td>
+ <td>
+ Runs all test classes that extend {@link android.test.InstrumentationTestCase}.
+ </td>
+ </tr>
+ <tr>
+ <td><code>unit</code></td>
+ <td><code>true</code></td>
+ <td>
+ Runs all test classes that do <em>not</em> extend either
+ {@link android.test.InstrumentationTestCase} or
+ {@link android.test.PerformanceTestCase}.
+ </td>
+ </tr>
+ <tr>
+ <td><code>size</code></td>
+ <td>
+ [<code>small</code> | <code>medium</code> | <code>large</code>]
+ </td>
+ <td>
+ Runs a test method annotated by size. The annotations are <code>@SmallTest</code>,
+ <code>@MediumTest</code>, and <code>@LargeTest</code>.
+ </td>
+ </tr>
+ <tr>
+ <td><code>perf</code></td>
+ <td><code>true</code></td>
+ <td>
+ Runs all test classes that implement {@link android.test.PerformanceTestCase}.
+ When you use this option, also specify the <code>-r</code> flag for
+ <code>am instrument</code>, so that the output is kept in raw format and not
+ re-formatted as test results.
+ </td>
+ </tr>
+ <tr>
+ <td><code>debug</code></td>
+ <td><code>true</code></td>
+ <td>
+ Runs tests in debug mode.
+ </td>
+ </tr>
+ <tr>
+ <td><code>log</code></td>
+ <td><code>true</code></td>
+ <td>
+ Loads and logs all specified tests, but does not run them. The test
+ information appears in <code>STDOUT</code>. Use this to verify combinations of other
+ filters and test specifications.
+ </td>
+ </tr>
+ <tr>
+ <td><code>emma</code></td>
+ <td><code>true</code></td>
+ <td>
+ Runs an EMMA code coverage analysis and writes the output to
+ <code>/data//coverage.ec</code> on the device. To override the file location, use the
+ <code>coverageFile</code> key that is described in the following entry.
+ <p class="note">
+ <strong>Note:</strong> This option requires an EMMA-instrumented build of the test
+ application, which you can generate with the <code>coverage</code> target.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>coverageFile</code></td>
+ <td><code><filename></code></td>
+ <td>
+ Overrides the default location of the EMMA coverage file on the device. Specify this
+ value as a path and filename in UNIX format. The default filename is described in the
+ entry for the <code>emma</code> key.
+ </td>
+ </tr>
+</table>
+<strong><code>-e</code> Flag Usage Notes</strong>
+<ul>
+ <li>
+ <code>am instrument</code> invokes
+ {@link android.test.InstrumentationTestRunner#onCreate(Bundle)}
+ with a {@link android.os.Bundle} containing the key-value pairs.
+ </li>
+ <li>
+ The <code>package</code> key takes precedence over the <code>class</code> key. If you
+ specifiy a package, and then separately specify a class within that package, Android
+ will run all the tests in the package and ignore the <code>class</code> key.
+ </li>
+ <li>
+ The <code>func</code> key and <code>unit</code> key are mutually exclusive.
+ </li>
+</ul>
+<h3 id="RunTestExamples">Usage examples</h3>
+<p>
+The following sections provide examples of using <code>am instrument</code> to run tests.
+They are based on the following structure:</p>
+<ul>
+ <li>
+ The test package has the Android package name <code>com.android.demo.app.tests</code>
+ </li>
+ <li>
+ There are three test classes:
+ <ul>
+ <li>
+ <code>UnitTests</code>, which contains the methods
+ <code>testPermissions</code> and <code>testSaveState</code>.
+ </li>
+ <li>
+ <code>FunctionTests</code>, which contains the methods
+ <code>testCamera</code>, <code>testXVGA</code>, and <code>testHardKeyboard</code>.
+ </li>
+ <li>
+ <code>IntegrationTests</code>,
+ which contains the method <code>testActivityProvider</code>.
+ </li>
+ </ul>
+ </li>
+ <li>
+ The test runner is {@link android.test.InstrumentationTestRunner}.
+ </li>
+</ul>
+<h4>Running the entire test package</h4>
+<p>
+ To run all of the test classes in the test package, enter:
+</p>
+<pre>
+$ adb shell am instrument -w com.android.demo.app.tests/android.test.InstrumentationTestRunner
+</pre>
+<h4>Running all tests in a test case class</h4>
+<p>
+ To run all of the tests in the class <code>UnitTests</code>, enter:
+</p>
+<pre>
+$ adb shell am instrument -w \
+> -e class com.android.demo.app.tests.UnitTests \
+> com.android.demo.app.tests/android.test.InstrumentationTestRunner
+</pre>
+<p>
+ <code>am instrument</code> gets the value of the <code>-e</code> flag, detects the
+ <code>class</code> keyword, and runs all the methods in the <code>UnitTests</code> class.
+</p>
+<h4>Selecting a subset of tests</h4>
+<p>
+ To run all of the tests in <code>UnitTests</code>, and the <code>testCamera</code> method in
+ <code>FunctionTests</code>, enter:
+</p>
+<pre>
+$ adb shell am instrument -w \
+> -e class com.android.demo.app.tests.UnitTests,com.android.demo.app.tests.FunctionTests#testCamera \
+> com.android.demo.app.tests/android.test.InstrumentationTestRunner
+</pre>
+<p>
+ You can find more examples of the command in the documentation for
+ {@link android.test.InstrumentationTestRunner}.
+</p>
diff --git a/docs/html/tools/testing/what_to_test.jd b/docs/html/tools/testing/what_to_test.jd
new file mode 100644
index 0000000..77ae211
--- /dev/null
+++ b/docs/html/tools/testing/what_to_test.jd
@@ -0,0 +1,86 @@
+page.title=What To Test
+parent.title=Testing
+parent.link=index.html
+@jd:body
+<p>
+ As you develop Android applications, knowing what to test is as important as knowing how to
+ test. This document lists some most common Android-related situations that you should consider
+ when you test, even at the unit test level. This is not an exhaustive list, and you consult the
+ documentation for the features that you use for more ideas. The
+ <a href="http://groups.google.com/group/android-developers">android-developers</a> Google Groups
+ site is another resource for information about testing.
+</p>
+<h2 id="Tests">Ideas for Testing</h2>
+<p>
+ The following sections are organized by behaviors or situations that you should test. Each
+ section contains a scenario that further illustrates the situation and the test or tests you
+ should do.
+</p>
+<h4>Change in orientation</h4>
+<p>
+ For devices that support multiple orientations, Android detects a change in orientation when
+ the user turns the device so that the display is "landscape" (long edge is horizontal) instead
+ of "portrait" (long edge is vertical).
+</p>
+<p>
+ When Android detects a change in orientation, its default behavior is to destroy and then
+ re-start the foreground Activity. You should consider testing the following:
+</p>
+<ul>
+ <li>
+ Is the screen re-drawn correctly? Any custom UI code you have should handle changes in the
+ orientation.
+ </li>
+ <li>
+ Does the application maintain its state? The Activity should not lose anything that the
+ user has already entered into the UI. The application should not "forget" its place in the
+ current transaction.
+ </li>
+</ul>
+<h4>Change in configuration</h4>
+<p>
+ A situation that is more general than a change in orientation is a change in the device's
+ configuration, such as a change in the availability of a keyboard or a change in system
+ language.
+</p>
+<p>
+ A change in configuration also triggers the default behavior of destroying and then restarting
+ the foreground Activity. Besides testing that the application maintains the UI and its
+ transaction state, you should also test that the application updates itself to respond
+ correctly to the new configuration.
+</p>
+<h4>Battery life</h4>
+<p>
+ Mobile devices primarily run on battery power. A device has finite "battery budget", and when it
+ is gone, the device is useless until it is recharged. You need to write your application to
+ minimize battery usage, you need to test its battery performance, and you need to test the
+ methods that manage battery usage.
+</p>
+<p>
+ Techniques for minimizing battery usage were presented at the 2010 Google I/O conference in the
+ presentation
+ <a href="http://code.google.com/events/io/2009/sessions/CodingLifeBatteryLife.html">
+ Coding for Life -- Battery Life, That Is</a>. This presentation describes the impact on battery
+ life of various operations, and the ways you can design your application to minimize these
+ impacts. When you code your application to reduce battery usage, you also write the
+ appropriate unit tests.
+</p>
+<h4>Dependence on external resources</h4>
+<p>
+ If your application depends on network access, SMS, Bluetooth, or GPS, then you should
+ test what happens when the resource or resources are not available.
+</p>
+<p>
+ For example, if your application uses the network,it can notify the user if access is
+ unavailable, or disable network-related features, or do both. For GPS, it can switch to
+ IP-based location awareness. It can also wait for WiFi access before doing large data transfers,
+ since WiFi transfers maximize battery usage compared to transfers over 3G or EDGE.
+</p>
+<p>
+ You can use the emulator to test network access and bandwidth. To learn more, please see
+ <a href="{@docRoot}tools/help/emulator.html#netspeed">Network Speed Emulation</a>.
+ To test GPS, you can use the emulator console and {@link android.location.LocationManager}. To
+ learn more about the emulator console, please see
+ <a href="{@docRoot}tools/help/emulator.html#console">
+ Using the Emulator Console</a>.
+</p>
diff --git a/docs/html/tools/tools_toc.cs b/docs/html/tools/tools_toc.cs
new file mode 100644
index 0000000..27fbd2d
--- /dev/null
+++ b/docs/html/tools/tools_toc.cs
@@ -0,0 +1,214 @@
+<ul id="nav">
+
+ <li class="nav-section">
+ <div class="nav-section-header empty">
+ <a href="<?cs var:toroot ?>tools/index.html"><span class="en">Developer Tools</span></a>
+ </div>
+ </li>
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot
+?>sdk/index.html"><span class="en">Download</span></a></div>
+ <ul>
+ <li class="nav-section">
+ <div class="nav-section-header">
+ <a href="<?cs var:toroot ?>sdk/installing/index.html"><span class="en">Installing
+ the SDK</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>sdk/installing/adding-packages.html">
+ <span class="en">Adding Platforms and Packages</span></a></li>
+ <li><a href="<?cs var:toroot ?>sdk/installing/installing-adt.html">
+ <span class="en">Installing the Eclipse Plugin</span></a></li>
+ <li><a href="<?cs var:toroot ?>sdk/installing/next.html">
+ <span class="en">Next Steps</span></a></li>
+ </ul>
+ </li>
+ <li><a href="<?cs var:toroot ?>sdk/exploring.html">
+ <span class="en">Exploring the SDK</span></a></li>
+ </ul>
+ </li>
+
+ <li class="nav-section">
+ <div class="nav-section-header">
+ <a href="/tools/workflow/index.html"><span class="en">Workflow</span></a>
+ </div>
+ <ul>
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="/tools/devices/index.html"><span class="en">Setting Up Virtual Devices</span></a></div>
+ <ul>
+ <li><a href="/tools/devices/managing-avds.html"><span class="en">With AVD Manager</span></a></li>
+ <li><a href="/tools/devices/managing-avds-cmdline.html"><span class="en">From the Command Line</span></a></li>
+ <li><a href="/tools/devices/emulator.html"><span class="en">Using the Android Emulator</span></a></li>
+ </ul>
+ </li>
+ <li><a href="/tools/device.html"><span class="en">Using Hardware Devices</span></a></li>
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="/tools/projects/index.html"><span class="en">Setting Up Projects</span></a></div>
+ <ul>
+ <li><a href="/tools/projects/projects-eclipse.html"><span class="en">From Eclipse with ADT</span></a></li>
+ <li><a href="/tools/projects/projects-cmdline.html"><span class="en">From the Command Line</span></a></li>
+ </ul>
+ </li>
+
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="/tools/building/index.html"><span class="en">Building and Running</span></a></div>
+ <ul>
+ <li><a href="/tools/building/building-eclipse.html"><span class="en">From Eclipse with ADT</span></a></li>
+ <li><a href="/tools/building/building-cmdline.html"><span class="en">From the Command Line</span></a></li>
+ </ul>
+ </li>
+
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot?>tools/testing/index.html">
+ <span class="en">Testing</span>
+ </a></div>
+ <ul>
+ <li>
+ <a href="<?cs var:toroot?>tools/testing/testing_android.html">
+ <span class="en">Fundamentals</span></a>
+ </li>
+ <li><a href="<?cs var:toroot ?>tools/testing/testing_eclipse.html">
+ <span class="en">From Eclipse</span></a>
+ </li>
+ <li><a href="<?cs var:toroot ?>tools/testing/testing_otheride.html">
+ <span class="en">From Other IDEs</span></a>
+ </li>
+ <li>
+ <a href="<?cs var:toroot?>tools/testing/activity_testing.html">
+ <span class="en">Activity Testing</span></a>
+ </li>
+ <li>
+ <a href="<?cs var:toroot?>tools/testing/service_testing.html">
+ <span class="en">Service Testing</span></a>
+ </li>
+ <li>
+ <a href="<?cs var:toroot?>tools/testing/contentprovider_testing.html">
+ <span class="en">Content Provider Testing</span></a>
+ </li>
+ <li>
+ <a href="<?cs var:toroot ?>tools/testing/what_to_test.html">
+ <span class="en">What To Test</span></a>
+ </li>
+ <li>
+ <a href="<?cs var:toroot ?>tools/testing/activity_test.html">
+ <span class="en">Activity Testing Tutorial</span></a>
+ </li>
+ </ul>
+ </li><!-- end of testing -->
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot ?>tools/debugging/index.html"><span class="en">Debugging</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-projects.html"><span class="en">From Eclipse with ADT</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-projects-cmdline.html"><span class="en">From Other IDEs</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/ddms.html"><span class="en">Using DDMS</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-log.html"><span class="en">Reading and Writing Logs</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-ui.html"><span class="en">Optimizing your UI</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-tracing.html"><span class="en">Profiling with Traceview and dmtracedump</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/debugging/debugging-devtools.html"><span class="en">Using the Dev Tools App</span></a></li>
+ </ul>
+ </li>
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot ?>tools/publishing/publishing_overview.html"><span class="en">Publishing</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/publishing/preparing.html"><span class="en">Preparing for Release</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/publishing/versioning.html"><span class="en">Versioning Your Apps</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/publishing/app-signing.html"><span class="en">Signing Your Apps</span></a></li>
+ </ul>
+ </li>
+</ul>
+</li>
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot ?>tools/help/index.html"><span
+class="en">Tools Help</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/help/adb.html">adb</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/adt.html">ADT</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/android.html">android</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/bmgr.html">bmgr</a>
+ <li><a href="<?cs var:toroot ?>tools/help/dmtracedump.html">dmtracedump</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/draw9patch.html">Draw 9-Patch</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/emulator.html">Emulator</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/etc1tool.html">etc1tool</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/hierarchy-viewer.html">Hierarchy Viewer</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/hprof-conv.html">hprof-conv</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/layoutopt.html">layoutopt</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/logcat.html">logcat</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/mksdcard.html">mksdcard</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/monkey.html">monkey</a></li>
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot
+?>tools/help/monkeyrunner_concepts.html"><span class="en">monkeyrunner</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/help/MonkeyDevice.html"><span
+class="en">MonkeyDevice</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/MonkeyImage.html"><span
+class="en">MonkeyImage</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/MonkeyRunner.html"><span
+class="en">MonkeyRunner</span></a></li>
+ </ul>
+ </li>
+ <li><a href="<?cs var:toroot ?>tools/help/proguard.html">ProGuard</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/traceview.html">Traceview</a></li>
+ <li><a href="<?cs var:toroot ?>tools/help/zipalign.html">zipalign</a></li>
+ </ul>
+ </li>
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot
+?>tools/revisions/index.html"><span class="en">Revisions</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/sdk/tools-notes.html">
+ <span class="en">Tools</span>
+ </a></li>
+ <li><a href="<?cs var:toroot ?>tools/sdk/eclipse-adt.html">
+ <span class="en">ADT Plugin</span>
+ </a></li>
+ <!--
+ <li><a href="<?cs var:toroot ?>tools/sdk/addons.html"><span class="en">Add-ons</span></a></li>
+ -->
+ <li class="nav-section">
+ <div class="nav-section-header">
+ <a href="<?cs var:toroot ?>tools/sdk/ndk/index.html">
+ <span class="en">NDK</span></a>
+ </div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/sdk/ndk/overview.html">What is the NDK?</a></li>
+ </ul>
+ </li>
+ <li><a href="<?cs var:toroot ?>tools/revisions/platforms.html"><span
+class="en">Platforms</span></a></li>
+ </ul>
+ </li>
+
+
+ <li class="nav-section">
+ <div class="nav-section-header"><a href="<?cs var:toroot
+?>tools/extras/index.html"><span class="en">Extras</span></a></div>
+ <ul>
+ <li><a href="<?cs var:toroot ?>tools/extras/support-library.html"><span class="en">Support
+Library</span></a></li>
+ <li><a href="<?cs var:toroot ?>tools/extras/oem-usb.html"><span
+class="en">USB Drivers</span></a>
+ </li>
+ </ul>
+ </li>
+
+
+
+ <li class="nav-section">
+ <div class="nav-section-header empty"><a href="<?cs var:toroot
+?>tools/samples/index.html"><span class="en">Samples</span></a></div>
+ </li>
+
+
+</ul><!-- nav -->
+
+<script type="text/javascript">
+<!--
+ buildToggleLists();
+ changeNavLang(getLangPref());
+//-->
+</script>
diff --git a/docs/html/tools/workflow.jd b/docs/html/tools/workflow.jd
new file mode 100644
index 0000000..4eb5ada
--- /dev/null
+++ b/docs/html/tools/workflow.jd
@@ -0,0 +1,150 @@
+page.title=Introduction
+@jd:body
+
+<p>Developing applications for Android devices is facilitated by a group of tools that are
+ provided with the SDK. You can access these tools through an Eclipse plugin called ADT (Android
+ Development Tools) or from the command line. Developing with Eclipse is the preferred method because
+ it can directly invoke the tools that you need while developing applications.</p>
+
+ <p>However, you may choose to develop with another IDE or a simple text editor and invoke the
+ tools on the command line or with scripts. This is a less streamlined way to develop because you
+ will sometimes have to call command line tools manually, but you will have access to the same
+ number of features that you would have in Eclipse.</p>
+
+<div class="figure" style="width:461px">
+ <img src="{@docRoot}images/developing/developing_overview.png"
+ alt="Development process for Android applications"
+ height="738" />
+ <p class="img-caption">
+ <strong>Figure 1.</strong> The development process for Android applications.
+ </p>
+</div>
+
+<p>The basic steps for developing applications (with or without Eclipse) are shown in figure 1. The
+development steps encompass four development phases, which include:</p>
+
+<ul>
+ <li><strong>Setup</strong>
+ <p>During this phase you install and set up your development environment. You also create
+ Android Virtual Devices (AVDs) and connect hardware devices on which you can install your
+ applications.</p>
+ <p>See <a href="{@docRoot}tools/devices/index.html">Managing Virtual Devices</a>
+ and <a href="{@docRoot}tools/device.html">Using Hardware Devices</a> for more
+ information.
+ </li>
+ <li><strong>Development</strong>
+ <p>During this phase you set up and develop your Android project, which contains all of the
+ source code and resource files for your application. For more informations, see
+ <a href="{@docRoot}tools/projects/index.html">Create an Android project</a>.</p>
+ </li>
+ <li><strong>Debugging and Testing</strong>
+ <p>During this phase you build your project into a debuggable <code>.apk</code> package that you
+ can install and run on the emulator or an Android-powered device. If you are using Eclipse,
+ builds are generated each time you project is saved. If you're using another IDE,
+ you can build your project using Ant and install it on a device using
+ <a href="{@docRoot}tools/help/adb.html">adb</a>. For more information, see
+ <a href="{@docRoot}tools/building/index.html">Build and run your application</a>.</p>
+ <p>Next, you debug your application using a JDWP-compliant debugger along with the debugging
+ and logging tools that are provided with the Android SDK. Eclipse already comes packaged with
+ a compatible debugger. For more information see,
+ <a href="{@docRoot}tools/debugging/index.html">Debug your application with the
+ SDK debugging and logging tools</a>.</p>
+ <p>Last, you test your application using various Android SDK testing tools. For more
+ information, see <a href="{@docRoot}tools/testing/index.html">Test your application
+ with the Testing and Instrumentation framework</a>.</p>
+ </li>
+ <li><strong>Publishing</strong>
+ <p>During this phase you configure and build your application for release and distribute your
+ application to users. For more information, see
+ <a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing Overview</a>.</p>
+ </li>
+</ul>
+
+<h2 id="EssentialTools">Essential command line tools</h2>
+
+ <p>When developing in IDEs or editors other than Eclipse, be familiar with
+ all of the tools below, because you will have to run them from the command line.</p>
+
+ <dl>
+ <dt><a href="{@docRoot}tools/help/android.html">android</a></dt>
+
+ <dd>Create and update Android projects and create, move, and delete AVDs.</dd>
+
+ <dt><a href="{@docRoot}tools/devices/emulator.html">Android Emulator</a></dt>
+
+ <dd>Run your Android applications on an emulated Android platform.</dd>
+
+ <dt><a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a></dt>
+
+ <dd>Interface with your emulator or connected device (install apps, shell the device, issue
+ commands, etc.).</dd>
+ </dl>
+
+ <p>In addition to the above tools that are included with the SDK, you need the following open
+ source and third-party tools:</p>
+
+ <dl>
+ <dt>Ant</dt>
+
+ <dd>To compile and build your Android project into an installable .apk file.</dd>
+
+ <dt>Keytool</dt>
+
+ <dd>To generate a keystore and private key, used to sign your .apk file. Keytool is part of the
+ JDK.</dd>
+
+ <dt>Jarsigner (or similar signing tool)</dt>
+
+ <dd>To sign your .apk file with a private key generated by Keytool. Jarsigner is part of the
+ JDK.</dd>
+ </dl>
+
+ <p>If you are using Eclipse and ADT, tools such as <code>adb</code> and <code>android</code>
+ are automatically called by Eclipse and ADT so you don't have to manually invoke these tools.
+ You need to be familiar with <code>adb</code>, however, because certain functions are not
+accessible from
+ Eclipse, such as the <code>adb</code> shell commands. You might also need to call Keytool and
+Jarsigner to
+ sign your applications, but you can set up Eclipse to do this automatically as well.</p>
+
+<p>For more information on the tools provided with the Android SDK, see the
+ <a href="{@docRoot}tools/index.html">Tools</a> section of the documentation.</p>
+
+<h2 id="ThirdParty">Other Third-Party Development Tools</h2>
+<p>
+ The tools described in this section are not developed by the Android SDK team. The Android Dev Guide
+ does not provide documentation for these tools. Please refer to the linked documents in each
+ section for documentation.
+</p>
+<h3 id="IntelliJ">Developing in IntelliJ IDEA</h3>
+<div style="float: right">
+<img alt="The IntelliJ graphical user interface" height="500px"
+src="{@docRoot}images/developing/intellijidea_android_ide.png"/>
+</div>
+<p>
+ IntelliJ IDEA is a powerful Java IDE from JetBrains that provides
+ full-cycle Android development support in both the free Community
+ Edition and the Ultimate edition.
+</p>
+<p>
+ The IDE ensures compatibility with the latest Android SDK and offers a
+ smart code editor with completion, quick navigation between code and
+ resources, a graphical debugger, unit testing support using Android
+ Testing Framework, and the ability to run applications in either the
+ emulator or a USB-connected device.
+</p>
+<p>
+ <strong>Links:</strong>
+</p>
+<ul>
+ <li>
+ <a href="http://www.jetbrains.com/idea">IntelliJ IDEA official website</a>
+</li>
+ <li>
+ <a href="http://www.jetbrains.com/idea/features/google_android.html">Android support in IntelliJ IDEA</a>
+</li>
+ <li>
+ <a href="http://wiki.jetbrains.net/intellij/Android">IntelliJ IDEA Android Tutorials</a>
+ </li>
+</ul>
+
diff --git a/docs/html/tools/workflow/app-signing.jd b/docs/html/tools/workflow/app-signing.jd
new file mode 100644
index 0000000..ac45242
--- /dev/null
+++ b/docs/html/tools/workflow/app-signing.jd
@@ -0,0 +1,618 @@
+page.title=Signing Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>All Android apps <em>must</em> be signed</li>
+<li>You can sign with a self-signed key</li>
+<li>How you sign your apps is critical — read this document carefully</li>
+<li>Determine your signing strategy early in the development process</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#signing">Signing Process</a></li>
+<li><a href="#strategies">Signing Strategies</a></li>
+<li><a href="#setup">Basic Setup for Signing</a></li>
+<li><a href="#debugmode">Signing in Debug Mode</a></li>
+<li><a href="#releasemode">Signing Release Mode</a>
+ <ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+ <li><a href="#ExportWizard">Compile and sign with Eclipse ADT</a></li>
+ </ol>
+</li>
+<li><a href="#secure-key">Securing Your Private Key</a></li>
+
+</ol>
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/versioning.html">Versioning Your Applications</a></li>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>The Android system requires that all installed applications be digitally signed with a
+certificate whose private key is held by the application's developer. The Android system uses the
+certificate as a means of identifying the author of an application and establishing trust
+relationships between applications. The certificate is not used to control which applications the
+user can install. The certificate does not need to be signed by a certificate authority: it is
+perfectly allowable, and typical, for Android applications to use self-signed certificates.</p>
+
+<p>The important points to understand about signing Android applications are:</p>
+
+<ul>
+ <li>All applications <em>must</em> be signed. The system will not install an application
+on an emulator or a device if it is not signed.</li>
+ <li>To test and debug your application, the build tools sign your application with a special debug
+ key that is created by the Android SDK build tools.</li>
+ <li>When you are ready to release your application for end-users, you must sign it with a suitable
+ private key. You cannot publish an application that is signed with the debug key generated
+ by the SDK tools.</li>
+ <li>You can use self-signed certificates to sign your applications. No certificate authority is
+ needed.</li>
+ <li>The system tests a signer certificate's expiration date only at install time. If an
+application's signer certificate expires after the application is installed, the application
+will continue to function normally.</li>
+ <li>You can use standard tools — Keytool and Jarsigner — to generate keys and
+sign your application {@code .apk} files.</li>
+ <li>After you sign your application for release, we recommend that you use the
+ <code>zipalign</code> tool to optimize the final APK package.</li>
+</ul>
+
+<p>The Android system will not install or run an application that is not signed appropriately. This
+applies wherever the Android system is run, whether on an actual device or on the emulator.
+For this reason, you must <a href="#setup">set up signing</a> for your application before you can
+run it or debug it on an emulator or device.</p>
+
+<h2 id="signing">Signing Process</h3>
+
+<p>The Android build process signs your application differently depending on which build mode you
+use to build your application. There are two build modes: <em>debug mode</em> and <em>release
+mode</em>. You use debug mode when you are developing and testing your application. You use
+release mode when you want to build a release version of your application that you can
+distribute directly to users or publish on an application marketplace such as Google Play.</p>
+
+<p>When you build in <em>debug mode</em> the Android SDK build tools use the Keytool utility
+(included in the JDK) to create a debug key. Because the SDK build tools created the debug key,
+they know the debug key's alias and password. Each time you compile your application in debug mode,
+the build tools use the debug key along with the Jarsigner utility (also included in the JDK) to
+sign your application's <code>.apk</code> file. Because the alias and password are known to the SDK
+build tools, the tools don't need to prompt you for the debug key's alias and password each time
+you compile.</p>
+
+<p>When you build in <em>release mode</em> you use your own private key to sign your application. If
+you don't have a private key, you can use the Keytool utility to create one for you. When you
+compile your application in release mode, the build tools use your private key along with the
+Jarsigner utility to sign your application's <code>.apk</code> file. Because the certificate and
+private key you use are your own, you will have to provide the password for the keystore and key
+alias.</p>
+
+<p>The debug signing process happens automatically when you run or debug your application using
+Eclipse with the ADT plugin. Debug signing also happens automatically when you use the Ant build
+script with the <code>debug</code> option. You can automate the release signing process by using the
+Eclipse Export Wizard or by modifying the Ant build script and building with the
+<code>release</code> option.</p>
+
+<h2 id="strategies">Signing Strategies</h2>
+
+<p>Some aspects of application signing may affect how you approach the development
+of your application, especially if you are planning to release multiple
+applications. </p>
+
+<p>In general, the recommended strategy for all developers is to sign
+all of your applications with the same certificate, throughout the expected
+lifespan of your applications. There are several reasons why you should do so: </p>
+
+<ul>
+<li>Application upgrade – As you release updates to your application, you
+will want to continue to sign the updates with the same certificate or set of
+certificates, if you want users to upgrade seamlessly to the new version. When
+the system is installing an update to an application, it compares the
+certificate(s) in the new version with those in the existing version. If the
+certificates match exactly, including both the certificate data and order, then
+the system allows the update. If you sign the new version without using matching
+certificates, you will also need to assign a different package name to the
+application — in this case, the user installs the new version as a
+completely new application. </li>
+
+<li>Application modularity – The Android system allows applications that
+are signed by the same certificate to run in the same process, if the
+applications so requests, so that the system treats them as a single application.
+In this way you can deploy your application in modules, and users can update
+each of the modules independently if needed.</li>
+
+<li>Code/data sharing through permissions – The Android system provides
+signature-based permissions enforcement, so that an application can expose
+functionality to another application that is signed with a specified
+certificate. By signing multiple applications with the same certificate and
+using signature-based permissions checks, your applications can share code and
+data in a secure manner. </li>
+
+</ul>
+
+<p>Another important consideration in determining your signing strategy is
+how to set the validity period of the key that you will use to sign your
+applications.</p>
+
+<ul>
+<li>If you plan to support upgrades for a single application, you should ensure
+that your key has a validity period that exceeds the expected lifespan of
+that application. A validity period of 25 years or more is recommended.
+When your key's validity period expires, users will no longer be
+able to seamlessly upgrade to new versions of your application.</li>
+
+<li>If you will sign multiple distinct applications with the same key,
+you should ensure that your key's validity period exceeds the expected
+lifespan of <em>all versions of all of the applications</em>, including
+dependent applications that may be added to the suite in the future. </li>
+
+<li>If you plan to publish your application(s) on Google Play, the
+key you use to sign the application(s) must have a validity period
+ending after 22 October 2033. Google Play enforces this requirement
+to ensure that users can seamlessly upgrade applications when
+new versions are available. </li>
+</ul>
+
+<p>As you design your application, keep these points in mind and make sure to
+use a <a href="#cert">suitable certificate</a> to sign your applications. </p>
+
+<h2 id="setup">Basic Setup for Signing</h2>
+
+<p>Before you begin, make sure that the Keytool utility and Jarsigner utility are available to
+the SDK build tools. Both of these tools are available in the JDK. In most cases, you can tell
+the SDK build tools how to find these utilities by setting your <code>JAVA_HOME</code> environment
+variable so it references a suitable JDK. Alternatively, you can add the JDK version of Keytool and
+Jarsigner to your <code>PATH</code> variable.</p>
+
+<p>If you are developing on a version of Linux that originally came with GNU Compiler for
+Java, make sure that the system is using the JDK version of Keytool, rather than the gcj
+version. If Keytool is already in your <code>PATH</code>, it might be pointing to a symlink at
+<code>/usr/bin/keytool</code>. In this case, check the symlink target to be sure it points
+to the Keytool in the JDK.</p>
+
+<h2 id="debugmode">Signing in Debug Mode</h2>
+
+<p>The Android build tools provide a debug signing mode that makes it easier for you
+to develop and debug your application, while still meeting the Android system
+requirement for signing your APK.
+When using debug mode to build your app, the SDK tools invoke Keytool to automatically create
+a debug keystore and key. This debug key is then used to automatically sign the APK, so
+you do not need to sign the package with your own key.</p>
+
+<p>The SDK tools create the debug keystore/key with predetermined names/passwords:</p>
+<ul>
+<li>Keystore name: "debug.keystore"</li>
+<li>Keystore password: "android"</li>
+<li>Key alias: "androiddebugkey"</li>
+<li>Key password: "android"</li>
+<li>CN: "CN=Android Debug,O=Android,C=US"</li>
+</ul>
+
+<p>If necessary, you can change the location/name of the debug keystore/key or
+supply a custom debug keystore/key to use. However, any custom debug
+keystore/key must use the same keystore/key names and passwords as the default
+debug key (as described above). (To do so in Eclipse/ADT, go to
+<strong>Windows</strong> > <strong>Preferences</strong> >
+<strong>Android</strong> > <strong>Build</strong>.) </p>
+
+<p class="caution"><strong>Caution:</strong> You <em>cannot</em> release your application
+to the public when signed with the debug certificate.</p>
+
+<h3>Eclipse Users</h3>
+
+<p>If you are developing in Eclipse/ADT (and have set up Keytool and Jarsigner as described above in
+<a href="#setup">Basic Setup for Signing</a>),
+signing in debug mode is enabled by default. When you run or debug your
+application, ADT signs the {@code .apk} file with the debug certificate, runs {@code zipalign} on
+the package, then installs it on
+the selected emulator or connected device. No specific action on your part is needed,
+provided ADT has access to Keytool.</p>
+
+<h3>Ant Users</h3>
+
+<p>If you are using Ant to build your {@code .apk} file, debug signing mode
+is enabled by using the <code>debug</code> option with the <code>ant</code> command
+(assuming that you are using a <code>build.xml</code> file generated by the
+<code>android</code> tool). When you run <code>ant debug</code> to
+compile your app, the build script generates a keystore/key and signs the APK for you.
+The script then also aligns the APK with the <code>zipalign</code> tool.
+No other action on your part is needed. Read
+<a href="{@docRoot}tools/building/building-cmdline.html#DebugMode">Building and Running Apps
+on the Command Line</a> for more information.</p>
+
+
+<h3 id="debugexpiry">Expiry of the Debug Certificate</h3>
+
+<p>The self-signed certificate used to sign your application in debug mode (the default on
+Eclipse/ADT and Ant builds) will have an expiration date of 365 days from its creation date.</p>
+
+<p>When the certificate expires, you will get a build error. On Ant builds, the error
+looks like this:</p>
+
+<pre>debug:
+[echo] Packaging bin/samples-debug.apk, and signing it with a debug key...
+[exec] Debug Certificate expired on 8/4/08 3:43 PM</pre>
+
+<p>In Eclipse/ADT, you will see a similar error in the Android console.</p>
+
+<p>To fix this problem, simply delete the <code>debug.keystore</code> file.
+The default storage location for AVDs is in <code>~/.android/</code> on OS X and Linux,
+in <code>C:\Documents and Settings\<user>\.android\</code> on Windows XP, and in
+<code>C:\Users\<user>\.android\</code> on Windows Vista and Windows 7.</p>
+
+
+<p>The next time you build, the build tools will regenerate a new keystore and debug key.</p>
+
+<p>Note that, if your development machine is using a non-Gregorian locale, the build
+tools may erroneously generate an already-expired debug certificate, so that you get an
+error when trying to compile your application. For workaround information, see the
+troubleshooting topic <a href="{@docRoot}resources/faq/troubleshooting.html#signingcalendar">
+I can't compile my app because the build tools generated an expired debug
+certificate</a>. </p>
+
+
+<h2 id="releasemode">Signing in Release Mode</h2>
+
+<p>When your application is ready for release to other users, you must:</p>
+<ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+</ol>
+
+<p>If you are developing in Eclipse with the ADT plugin, you can use the Export Wizard
+to perform the compile, sign, and align procedures. The Export Wizard even allows you to
+generate a new keystore and private key in the process. So if you use Eclipse, you can
+skip to <a href="#ExportWizard">Compile and sign with Eclipse ADT</a>.</p>
+
+
+
+<h3 id="cert">1. Obtain a suitable private key</h3>
+
+<p>In preparation for signing your application, you must first ensure that
+you have a suitable private key with which to sign. A suitable private
+key is one that:</p>
+
+<ul>
+<li>Is in your possession</li>
+<li>Represents the personal, corporate, or organizational entity to be identified
+with the application</li>
+<li>Has a validity period that exceeds the expected lifespan of the application
+or application suite. A validity period of more than 25 years is recommended.
+<p>If you plan to publish your application(s) on Google Play, note that a
+validity period ending after 22 October 2033 is a requirement. You can not upload an
+application if it is signed with a key whose validity expires before that date.
+</p></li>
+<li>Is not the debug key generated by the Android SDK tools. </li>
+</ul>
+
+<p>The key may be self-signed. If you do not have a suitable key, you must
+generate one using Keytool. Make sure that you have Keytool available, as described
+in <a href="#setup">Basic Setup</a>.</p>
+
+<p>To generate a self-signed key with Keytool, use the <code>keytool</code>
+command and pass any of the options listed below (and any others, as
+needed). </p>
+
+<p class="warning"><strong>Warning:</strong> Keep your private key secure.
+Before you run Keytool, make sure to read
+<a href="#secure-key">Securing Your Private Key</a> for a discussion of how to keep
+your key secure and why doing so is critically important to you and to users. In
+particular, when you are generating your key, you should select strong passwords
+for both the keystore and key.</p>
+
+<table>
+<tr>
+<th>Keytool Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-genkey</code></td><td>Generate a key pair (public and private
+keys)</td>
+</tr>
+<tr>
+<td><code>-v</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-alias <alias_name></code></td><td>An alias for the key. Only
+the first 8 characters of the alias are used.</td>
+</tr>
+<tr>
+<td><code>-keyalg <alg></code></td><td>The encryption algorithm to use
+when generating the key. Both DSA and RSA are supported.</td>
+</tr>
+<tr>
+<td><code>-keysize <size></code></td><td>The size of each generated key
+(bits). If not supplied, Keytool uses a default key size of 1024 bits. In
+general, we recommend using a key size of 2048 bits or higher. </td>
+</tr>
+<tr>
+<td><code>-dname <name></code></td><td><p>A Distinguished Name that describes
+who created the key. The value is used as the issuer and subject fields in the
+self-signed certificate. </p><p>Note that you do not need to specify this option
+in the command line. If not supplied, Jarsigner prompts you to enter each
+of the Distinguished Name fields (CN, OU, and so on).</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the
+key.</p> <p>As a security precaution, do not include this option in your command
+line. If not supplied, Keytool prompts you to enter the password. In this way,
+your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-validity <valdays></code></td><td><p>The validity period for the
+key, in days. </p><p><strong>Note:</strong> A value of 10000 or greater is recommended.</p></td>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>A name
+for the keystore containing the private key.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>A password for the
+keystore.</p><p>As a security precaution, do not include this option in your
+command line. If not supplied, Keytool prompts you to enter the password. In
+this way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's an example of a Keytool command that generates a private key:</p>
+
+<pre>$ keytool -genkey -v -keystore my-release-key.keystore
+-alias alias_name -keyalg RSA -keysize 2048 -validity 10000</pre>
+
+<p>Running the example command above, Keytool prompts you to provide
+passwords for the keystore and key, and to provide the Distinguished
+Name fields for your key. It then generates the keystore as a file called
+<code>my-release-key.keystore</code>. The keystore and key are
+protected by the passwords you entered. The keystore contains
+a single key, valid for 10000 days. The alias is a name that you —
+will use later, to refer to this keystore when signing your application. </p>
+
+<p>For more information about Keytool, see the documentation at
+<a
+href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html</a></p>
+
+
+
+<h3 id="releasecompile">2. Compile the application in release mode</h3>
+
+<p>In order to release your application to users, you must compile it in release mode.
+In release mode, the compiled application is not signed by default and you will need
+to sign it with your private key.</p>
+
+<p class="caution"><strong>Caution:</strong>
+You can not release your application unsigned, or signed with the debug key.</p>
+
+<h4>With Eclipse</h4>
+
+<p>To export an <em>unsigned</em> APK from Eclipse, right-click the project in the Package
+Explorer and select <strong>Android Tools</strong> > <strong>Export Unsigned Application
+Package</strong>. Then specify the file location for the unsigned APK.
+(Alternatively, open your <code>AndroidManifest.xml</code> file in Eclipse, select
+the <strong>Manifest</strong> tab, and click <strong>Export an unsigned APK</strong>.)</p>
+
+<p>Note that you can combine the compiling and signing steps with the Export Wizard. See
+<a href="#ExportWizard">Compiling and signing with Eclipse ADT</a>.</p>
+
+<h4>With Ant</h4>
+
+<p>If you are using Ant, you can enable release mode by using the <code>release</code> option
+with the <code>ant</code> command. For example, if you are running Ant from the
+directory containing your {@code build.xml} file, the command would look like this:</p>
+
+<pre>$ ant release</pre>
+
+<p>By default, the build script compiles the application APK without signing it. The output file
+in your project {@code bin/} will be <code><em><your_project_name></em>-unsigned.apk</code>.
+Because the application APK is still unsigned, you must manually sign it with your private
+key and then align it using {@code zipalign}.</p>
+
+<p>However, the Ant build script can also perform the signing
+and aligning for you, if you have provided the path to your keystore and the name of
+your key alias in the project's {@code ant.properties} file. With this information provided,
+the build script will prompt you for your keystore and alias password when you perform
+<code>ant release</code>, it will sign the package and then align it. The final output
+file in {@code bin/} will instead be
+<code><em><your_project_name></em>-release.apk</code>. With these steps
+automated for you, you're able to skip the manual procedures below (steps 3 and 4).
+To learn how to specify your keystore and alias in the {@code ant.properties} file,
+see <a href="{@docRoot}tools/building/building-cmdline.html#ReleaseMode">
+Building and Running Apps on the Command Line</a>.</p>
+
+
+
+<h3 id="signapp">3. Sign your application with your private key</h3>
+
+<p>When you have an application package that is ready to be signed, you can do sign it
+using the Jarsigner tool. Make sure that you have Jarsigner available on your
+machine, as described in <a href="#setup">Basic Setup</a>. Also, make sure that
+the keystore containing your private key is available.</p>
+
+<p>To sign your application, you run Jarsigner, referencing both the
+application's APK and the keystore containing the private key with which to
+sign the APK. The table below shows the options you could use. </p>
+
+<table>
+<tr>
+<th>Jarsigner Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>The name of
+the keystore containing your private key.</td>
+</tr>
+<tr>
+<td><code>-verbose</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-sigalg</code></td><td>The name of the signature algorithim to use in signing the APK.
+Use the value {@code MD5withRSA}.</td>
+</tr>
+<tr>
+<td><code>-digestalg</code></td><td>The message digest algorithim to use in processing the entries
+of an APK. Use the value {@code SHA1}.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>The password for the
+keystore. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the private
+key. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's how you would use Jarsigner to sign an application package called
+<code>my_application.apk</code>, using the example keystore created above.
+</p>
+
+<pre>$ jarsigner -verbose -sigalg MD5withRSA -digestalg SHA1 -keystore my-release-key.keystore
+my_application.apk alias_name</pre>
+
+<p>Running the example command above, Jarsigner prompts you to provide
+passwords for the keystore and key. It then modifies the APK
+in-place, meaning the APK is now signed. Note that you can sign an
+APK multiple times with different keys.</p>
+
+<p class="caution"><strong>Caution:</strong> As of JDK 7, the default signing algorithim has
+changed, requiring you to specify the signature and digest algorithims ({@code -sigalg} and {@code
+-digestalg}) when you sign an APK.</p>
+
+<p>To verify that your APK is signed, you can use a command like this:</p>
+
+<pre>$ jarsigner -verify my_signed.apk</pre>
+
+<p>If the APK is signed properly, Jarsigner prints "jar verified".
+If you want more details, you can try one of these commands:</p>
+
+<pre>$ jarsigner -verify -verbose my_application.apk</pre>
+
+<p>or</p>
+
+<pre>$ jarsigner -verify -verbose -certs my_application.apk</pre>
+
+<p>The command above, with the <code>-certs</code> option added, will show you the
+"CN=" line that describes who created the key.</p>
+
+<p class="note"><strong>Note:</strong> If you see "CN=Android Debug", this means the APK was
+signed with the debug key generated by the Android SDK. If you intend to release
+your application, you must sign it with your private key instead of the debug
+key.</p>
+
+<p>For more information about Jarsigner, see the documentation at
+<a href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html</a></p>
+
+
+<h3 id="align">4. Align the final APK package</h3>
+
+<p>Once you have signed the APK with your private key, run <code>zipalign</code> on the file.
+This tool ensures that all uncompressed data starts with a particular byte alignment,
+relative to the start of the file. Ensuring alignment at 4-byte boundaries provides
+a performance optimization when installed on a device. When aligned, the Android
+system is able to read files with {@code mmap()}, even if
+they contain binary data with alignment restrictions, rather than copying all
+of the data from the package. The benefit is a reduction in the amount of
+RAM consumed by the running application.</p>
+
+<p>The <code>zipalign</code> tool is provided with the Android SDK, inside the
+<code>tools/</code> directory. To align your signed APK, execute:</p>
+
+<pre>$ zipalign -v 4 <em>your_project_name</em>-unaligned.apk <em>your_project_name</em>.apk</pre>
+
+<p>The {@code -v} flag turns on verbose output (optional). {@code 4} is the
+byte-alignment (don't use anything other than 4). The first file argument is
+your signed {@code .apk} file (the input) and the second file is the destination {@code .apk} file
+(the output). If you're overriding an existing APK, add the {@code -f} flag.</p>
+
+<p class="caution"><strong>Caution:</strong> Your input APK must be signed with your
+private key <strong>before</strong> you optimize the package with {@code zipalign}.
+If you sign it after using {@code zipalign}, it will undo the alignment.</p>
+
+<p>For more information, read about the
+<a href="{@docRoot}tools/help/zipalign.html">zipalign</a> tool.
+
+
+<h3 id="ExportWizard">Compile and sign with Eclipse ADT</h3>
+
+<p>If you are using Eclipse with the ADT plugin, you can use the Export Wizard to
+export a <em>signed</em> APK (and even create a new keystore,
+if necessary). The Export Wizard performs all the interaction with
+the Keytool and Jarsigner for you, which allows you to sign the package using a GUI
+instead of performing the manual procedures to compile, sign,
+and align, as discussed above. Once the wizard has compiled and signed your package,
+it will also perfom package alignment with {@code zipalign}.
+Because the Export Wizard uses both Keytool and Jarsigner, you should
+ensure that they are accessible on your computer, as described above
+in the <a href="#setup">Basic Setup for Signing</a>.</p>
+
+<p>To create a signed and aligned APK in Eclipse:</p>
+
+<ol>
+ <li>Select the project in the Package
+Explorer and select <strong>File > Export</strong>.</li>
+ <li>Open the Android folder, select Export Android Application,
+ and click <strong>Next</strong>.
+ <p>The Export Android Application wizard now starts, which will
+ guide you through the process of signing your application,
+ including steps for selecting the private key with which to sign the APK
+ (or creating a new keystore and private key).</p>
+ <li>Complete the Export Wizard and your application will be compiled,
+ signed, aligned, and ready for distribution.</li>
+</ol>
+
+
+
+<h2 id="secure-key">Securing Your Private Key</h2>
+
+<p>Maintaining the security of your private key is of critical importance, both
+to you and to the user. If you allow someone to use your key, or if you leave
+your keystore and passwords in an unsecured location such that a third-party
+could find and use them, your authoring identity and the trust of the user
+are compromised. </p>
+
+<p>If a third party should manage to take your key without your knowledge or
+permission, that person could sign and distribute applications that maliciously
+replace your authentic applications or corrupt them. Such a person could also
+sign and distribute applications under your identity that attack other
+applications or the system itself, or corrupt or steal user data. </p>
+
+<p>Your reputation as a developer entity depends on your securing your private
+key properly, at all times, until the key is expired. Here are some tips for
+keeping your key secure: </p>
+
+<ul>
+<li>Select strong passwords for the keystore and key.</li>
+<li>When you generate your key with Keytool, <em>do not</em> supply the
+<code>-storepass</code> and <code>-keypass</code> options at the command line.
+If you do so, your passwords will be available in your shell history,
+which any user on your computer could access.</li>
+<li>Similarly, when signing your applications with Jarsigner,
+<em>do not</em> supply the <code>-storepass</code> and <code>-keypass</code>
+options at the command line. </li>
+<li>Do not give or lend anyone your private key, and do not let unauthorized
+persons know your keystore and key passwords.</li>
+</ul>
+
+<p>In general, if you follow common-sense precautions when generating, using,
+and storing your key, it will remain secure. </p>
\ No newline at end of file
diff --git a/docs/html/tools/workflow/index.jd b/docs/html/tools/workflow/index.jd
new file mode 100644
index 0000000..5ae06e6
--- /dev/null
+++ b/docs/html/tools/workflow/index.jd
@@ -0,0 +1,150 @@
+page.title=Introduction
+@jd:body
+
+<p>To develop apps for Android devices, you use a set of tools that are included in the Android SDK.
+Once you've downloaded and installed the SDK, you can access these tools right from your Eclipse IDE,
+through the ADT plugin, or from the command line. Developing with Eclipse is the preferred method because
+it can directly invoke the tools that you need while developing applications.</p>
+
+ <p>However, you may choose to develop with another IDE or a simple text editor and invoke the
+ tools on the command line or with scripts. This is a less streamlined way to develop because you
+ will sometimes have to call command line tools manually, but you will have access to the same
+ number of features that you would have in Eclipse.</p>
+
+<div class="figure" style="width:461px">
+ <img src="{@docRoot}images/developing/developing_overview.png"
+ alt="Development process for Android applications"
+ height="738" />
+ <p class="img-caption">
+ <strong>Figure 1.</strong> The development process for Android applications.
+ </p>
+</div>
+
+<p>The basic steps for developing applications (with or without Eclipse) are shown in figure 1. The
+development steps encompass four development phases, which include:</p>
+
+<ul>
+ <li><strong>Setup</strong>
+ <p>During this phase you install and set up your development environment. You also create
+ Android Virtual Devices (AVDs) and connect hardware devices on which you can install your
+ applications.</p>
+ <p>See <a href="{@docRoot}tools/devices/index.html">Managing Virtual Devices</a>
+ and <a href="{@docRoot}tools/device.html">Using Hardware Devices</a> for more
+ information.
+ </li>
+ <li><strong>Development</strong>
+ <p>During this phase you set up and develop your Android project, which contains all of the
+ source code and resource files for your application. For more informations, see
+ <a href="{@docRoot}tools/projects/index.html">Create an Android project</a>.</p>
+ </li>
+ <li><strong>Debugging and Testing</strong>
+ <p>During this phase you build your project into a debuggable <code>.apk</code> package that you
+ can install and run on the emulator or an Android-powered device. If you are using Eclipse,
+ builds are generated each time you project is saved. If you're using another IDE,
+ you can build your project using Ant and install it on a device using
+ <a href="{@docRoot}tools/help/adb.html">adb</a>. For more information, see
+ <a href="{@docRoot}tools/building/index.html">Build and run your application</a>.</p>
+ <p>Next, you debug your application using a JDWP-compliant debugger along with the debugging
+ and logging tools that are provided with the Android SDK. Eclipse already comes packaged with
+ a compatible debugger. For more information see,
+ <a href="{@docRoot}tools/debugging/index.html">Debug your application with the
+ SDK debugging and logging tools</a>.</p>
+ <p>Last, you test your application using various Android SDK testing tools. For more
+ information, see <a href="{@docRoot}tools/testing/index.html">Test your application
+ with the Testing and Instrumentation framework</a>.</p>
+ </li>
+ <li><strong>Publishing</strong>
+ <p>During this phase you configure and build your application for release and distribute your
+ application to users. For more information, see
+ <a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing Overview</a>.</p>
+ </li>
+</ul>
+
+<h2 id="EssentialTools">Essential command line tools</h2>
+
+ <p>When developing in IDEs or editors other than Eclipse, be familiar with
+ all of the tools below, because you will have to run them from the command line.</p>
+
+ <dl>
+ <dt><a href="{@docRoot}tools/help/android.html">android</a></dt>
+
+ <dd>Create and update Android projects and create, move, and delete AVDs.</dd>
+
+ <dt><a href="{@docRoot}tools/devices/emulator.html">Android Emulator</a></dt>
+
+ <dd>Run your Android applications on an emulated Android platform.</dd>
+
+ <dt><a href="{@docRoot}tools/help/adb.html">Android Debug Bridge</a></dt>
+
+ <dd>Interface with your emulator or connected device (install apps, shell the device, issue
+ commands, etc.).</dd>
+ </dl>
+
+ <p>In addition to the above tools that are included with the SDK, you need the following open
+ source and third-party tools:</p>
+
+ <dl>
+ <dt>Ant</dt>
+
+ <dd>To compile and build your Android project into an installable .apk file.</dd>
+
+ <dt>Keytool</dt>
+
+ <dd>To generate a keystore and private key, used to sign your .apk file. Keytool is part of the
+ JDK.</dd>
+
+ <dt>Jarsigner (or similar signing tool)</dt>
+
+ <dd>To sign your .apk file with a private key generated by Keytool. Jarsigner is part of the
+ JDK.</dd>
+ </dl>
+
+ <p>If you are using Eclipse and ADT, tools such as <code>adb</code> and <code>android</code>
+ are automatically called by Eclipse and ADT so you don't have to manually invoke these tools.
+ You need to be familiar with <code>adb</code>, however, because certain functions are not
+accessible from
+ Eclipse, such as the <code>adb</code> shell commands. You might also need to call Keytool and
+Jarsigner to
+ sign your applications, but you can set up Eclipse to do this automatically as well.</p>
+
+<p>For more information on the tools provided with the Android SDK, see the
+ <a href="{@docRoot}tools/index.html">Tools</a> section of the documentation.</p>
+
+<h2 id="ThirdParty">Other Third-Party Development Tools</h2>
+<p>
+ The tools described in this section are not developed by the Android SDK team. The Android Dev Guide
+ does not provide documentation for these tools. Please refer to the linked documents in each
+ section for documentation.
+</p>
+<h3 id="IntelliJ">Developing in IntelliJ IDEA</h3>
+<div style="float: right">
+<img alt="The IntelliJ graphical user interface" height="500px"
+src="{@docRoot}images/developing/intellijidea_android_ide.png"/>
+</div>
+<p>
+ IntelliJ IDEA is a powerful Java IDE from JetBrains that provides
+ full-cycle Android development support in both the free Community
+ Edition and the Ultimate edition.
+</p>
+<p>
+ The IDE ensures compatibility with the latest Android SDK and offers a
+ smart code editor with completion, quick navigation between code and
+ resources, a graphical debugger, unit testing support using Android
+ Testing Framework, and the ability to run applications in either the
+ emulator or a USB-connected device.
+</p>
+<p>
+ <strong>Links:</strong>
+</p>
+<ul>
+ <li>
+ <a href="http://www.jetbrains.com/idea">IntelliJ IDEA official website</a>
+</li>
+ <li>
+ <a href="http://www.jetbrains.com/idea/features/google_android.html">Android support in IntelliJ IDEA</a>
+</li>
+ <li>
+ <a href="http://wiki.jetbrains.net/intellij/Android">IntelliJ IDEA Android Tutorials</a>
+ </li>
+</ul>
+
diff --git a/docs/html/tools/workflow/publishing/app-signing.jd b/docs/html/tools/workflow/publishing/app-signing.jd
new file mode 100644
index 0000000..ac45242
--- /dev/null
+++ b/docs/html/tools/workflow/publishing/app-signing.jd
@@ -0,0 +1,618 @@
+page.title=Signing Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>All Android apps <em>must</em> be signed</li>
+<li>You can sign with a self-signed key</li>
+<li>How you sign your apps is critical — read this document carefully</li>
+<li>Determine your signing strategy early in the development process</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#signing">Signing Process</a></li>
+<li><a href="#strategies">Signing Strategies</a></li>
+<li><a href="#setup">Basic Setup for Signing</a></li>
+<li><a href="#debugmode">Signing in Debug Mode</a></li>
+<li><a href="#releasemode">Signing Release Mode</a>
+ <ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+ <li><a href="#ExportWizard">Compile and sign with Eclipse ADT</a></li>
+ </ol>
+</li>
+<li><a href="#secure-key">Securing Your Private Key</a></li>
+
+</ol>
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/versioning.html">Versioning Your Applications</a></li>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>The Android system requires that all installed applications be digitally signed with a
+certificate whose private key is held by the application's developer. The Android system uses the
+certificate as a means of identifying the author of an application and establishing trust
+relationships between applications. The certificate is not used to control which applications the
+user can install. The certificate does not need to be signed by a certificate authority: it is
+perfectly allowable, and typical, for Android applications to use self-signed certificates.</p>
+
+<p>The important points to understand about signing Android applications are:</p>
+
+<ul>
+ <li>All applications <em>must</em> be signed. The system will not install an application
+on an emulator or a device if it is not signed.</li>
+ <li>To test and debug your application, the build tools sign your application with a special debug
+ key that is created by the Android SDK build tools.</li>
+ <li>When you are ready to release your application for end-users, you must sign it with a suitable
+ private key. You cannot publish an application that is signed with the debug key generated
+ by the SDK tools.</li>
+ <li>You can use self-signed certificates to sign your applications. No certificate authority is
+ needed.</li>
+ <li>The system tests a signer certificate's expiration date only at install time. If an
+application's signer certificate expires after the application is installed, the application
+will continue to function normally.</li>
+ <li>You can use standard tools — Keytool and Jarsigner — to generate keys and
+sign your application {@code .apk} files.</li>
+ <li>After you sign your application for release, we recommend that you use the
+ <code>zipalign</code> tool to optimize the final APK package.</li>
+</ul>
+
+<p>The Android system will not install or run an application that is not signed appropriately. This
+applies wherever the Android system is run, whether on an actual device or on the emulator.
+For this reason, you must <a href="#setup">set up signing</a> for your application before you can
+run it or debug it on an emulator or device.</p>
+
+<h2 id="signing">Signing Process</h3>
+
+<p>The Android build process signs your application differently depending on which build mode you
+use to build your application. There are two build modes: <em>debug mode</em> and <em>release
+mode</em>. You use debug mode when you are developing and testing your application. You use
+release mode when you want to build a release version of your application that you can
+distribute directly to users or publish on an application marketplace such as Google Play.</p>
+
+<p>When you build in <em>debug mode</em> the Android SDK build tools use the Keytool utility
+(included in the JDK) to create a debug key. Because the SDK build tools created the debug key,
+they know the debug key's alias and password. Each time you compile your application in debug mode,
+the build tools use the debug key along with the Jarsigner utility (also included in the JDK) to
+sign your application's <code>.apk</code> file. Because the alias and password are known to the SDK
+build tools, the tools don't need to prompt you for the debug key's alias and password each time
+you compile.</p>
+
+<p>When you build in <em>release mode</em> you use your own private key to sign your application. If
+you don't have a private key, you can use the Keytool utility to create one for you. When you
+compile your application in release mode, the build tools use your private key along with the
+Jarsigner utility to sign your application's <code>.apk</code> file. Because the certificate and
+private key you use are your own, you will have to provide the password for the keystore and key
+alias.</p>
+
+<p>The debug signing process happens automatically when you run or debug your application using
+Eclipse with the ADT plugin. Debug signing also happens automatically when you use the Ant build
+script with the <code>debug</code> option. You can automate the release signing process by using the
+Eclipse Export Wizard or by modifying the Ant build script and building with the
+<code>release</code> option.</p>
+
+<h2 id="strategies">Signing Strategies</h2>
+
+<p>Some aspects of application signing may affect how you approach the development
+of your application, especially if you are planning to release multiple
+applications. </p>
+
+<p>In general, the recommended strategy for all developers is to sign
+all of your applications with the same certificate, throughout the expected
+lifespan of your applications. There are several reasons why you should do so: </p>
+
+<ul>
+<li>Application upgrade – As you release updates to your application, you
+will want to continue to sign the updates with the same certificate or set of
+certificates, if you want users to upgrade seamlessly to the new version. When
+the system is installing an update to an application, it compares the
+certificate(s) in the new version with those in the existing version. If the
+certificates match exactly, including both the certificate data and order, then
+the system allows the update. If you sign the new version without using matching
+certificates, you will also need to assign a different package name to the
+application — in this case, the user installs the new version as a
+completely new application. </li>
+
+<li>Application modularity – The Android system allows applications that
+are signed by the same certificate to run in the same process, if the
+applications so requests, so that the system treats them as a single application.
+In this way you can deploy your application in modules, and users can update
+each of the modules independently if needed.</li>
+
+<li>Code/data sharing through permissions – The Android system provides
+signature-based permissions enforcement, so that an application can expose
+functionality to another application that is signed with a specified
+certificate. By signing multiple applications with the same certificate and
+using signature-based permissions checks, your applications can share code and
+data in a secure manner. </li>
+
+</ul>
+
+<p>Another important consideration in determining your signing strategy is
+how to set the validity period of the key that you will use to sign your
+applications.</p>
+
+<ul>
+<li>If you plan to support upgrades for a single application, you should ensure
+that your key has a validity period that exceeds the expected lifespan of
+that application. A validity period of 25 years or more is recommended.
+When your key's validity period expires, users will no longer be
+able to seamlessly upgrade to new versions of your application.</li>
+
+<li>If you will sign multiple distinct applications with the same key,
+you should ensure that your key's validity period exceeds the expected
+lifespan of <em>all versions of all of the applications</em>, including
+dependent applications that may be added to the suite in the future. </li>
+
+<li>If you plan to publish your application(s) on Google Play, the
+key you use to sign the application(s) must have a validity period
+ending after 22 October 2033. Google Play enforces this requirement
+to ensure that users can seamlessly upgrade applications when
+new versions are available. </li>
+</ul>
+
+<p>As you design your application, keep these points in mind and make sure to
+use a <a href="#cert">suitable certificate</a> to sign your applications. </p>
+
+<h2 id="setup">Basic Setup for Signing</h2>
+
+<p>Before you begin, make sure that the Keytool utility and Jarsigner utility are available to
+the SDK build tools. Both of these tools are available in the JDK. In most cases, you can tell
+the SDK build tools how to find these utilities by setting your <code>JAVA_HOME</code> environment
+variable so it references a suitable JDK. Alternatively, you can add the JDK version of Keytool and
+Jarsigner to your <code>PATH</code> variable.</p>
+
+<p>If you are developing on a version of Linux that originally came with GNU Compiler for
+Java, make sure that the system is using the JDK version of Keytool, rather than the gcj
+version. If Keytool is already in your <code>PATH</code>, it might be pointing to a symlink at
+<code>/usr/bin/keytool</code>. In this case, check the symlink target to be sure it points
+to the Keytool in the JDK.</p>
+
+<h2 id="debugmode">Signing in Debug Mode</h2>
+
+<p>The Android build tools provide a debug signing mode that makes it easier for you
+to develop and debug your application, while still meeting the Android system
+requirement for signing your APK.
+When using debug mode to build your app, the SDK tools invoke Keytool to automatically create
+a debug keystore and key. This debug key is then used to automatically sign the APK, so
+you do not need to sign the package with your own key.</p>
+
+<p>The SDK tools create the debug keystore/key with predetermined names/passwords:</p>
+<ul>
+<li>Keystore name: "debug.keystore"</li>
+<li>Keystore password: "android"</li>
+<li>Key alias: "androiddebugkey"</li>
+<li>Key password: "android"</li>
+<li>CN: "CN=Android Debug,O=Android,C=US"</li>
+</ul>
+
+<p>If necessary, you can change the location/name of the debug keystore/key or
+supply a custom debug keystore/key to use. However, any custom debug
+keystore/key must use the same keystore/key names and passwords as the default
+debug key (as described above). (To do so in Eclipse/ADT, go to
+<strong>Windows</strong> > <strong>Preferences</strong> >
+<strong>Android</strong> > <strong>Build</strong>.) </p>
+
+<p class="caution"><strong>Caution:</strong> You <em>cannot</em> release your application
+to the public when signed with the debug certificate.</p>
+
+<h3>Eclipse Users</h3>
+
+<p>If you are developing in Eclipse/ADT (and have set up Keytool and Jarsigner as described above in
+<a href="#setup">Basic Setup for Signing</a>),
+signing in debug mode is enabled by default. When you run or debug your
+application, ADT signs the {@code .apk} file with the debug certificate, runs {@code zipalign} on
+the package, then installs it on
+the selected emulator or connected device. No specific action on your part is needed,
+provided ADT has access to Keytool.</p>
+
+<h3>Ant Users</h3>
+
+<p>If you are using Ant to build your {@code .apk} file, debug signing mode
+is enabled by using the <code>debug</code> option with the <code>ant</code> command
+(assuming that you are using a <code>build.xml</code> file generated by the
+<code>android</code> tool). When you run <code>ant debug</code> to
+compile your app, the build script generates a keystore/key and signs the APK for you.
+The script then also aligns the APK with the <code>zipalign</code> tool.
+No other action on your part is needed. Read
+<a href="{@docRoot}tools/building/building-cmdline.html#DebugMode">Building and Running Apps
+on the Command Line</a> for more information.</p>
+
+
+<h3 id="debugexpiry">Expiry of the Debug Certificate</h3>
+
+<p>The self-signed certificate used to sign your application in debug mode (the default on
+Eclipse/ADT and Ant builds) will have an expiration date of 365 days from its creation date.</p>
+
+<p>When the certificate expires, you will get a build error. On Ant builds, the error
+looks like this:</p>
+
+<pre>debug:
+[echo] Packaging bin/samples-debug.apk, and signing it with a debug key...
+[exec] Debug Certificate expired on 8/4/08 3:43 PM</pre>
+
+<p>In Eclipse/ADT, you will see a similar error in the Android console.</p>
+
+<p>To fix this problem, simply delete the <code>debug.keystore</code> file.
+The default storage location for AVDs is in <code>~/.android/</code> on OS X and Linux,
+in <code>C:\Documents and Settings\<user>\.android\</code> on Windows XP, and in
+<code>C:\Users\<user>\.android\</code> on Windows Vista and Windows 7.</p>
+
+
+<p>The next time you build, the build tools will regenerate a new keystore and debug key.</p>
+
+<p>Note that, if your development machine is using a non-Gregorian locale, the build
+tools may erroneously generate an already-expired debug certificate, so that you get an
+error when trying to compile your application. For workaround information, see the
+troubleshooting topic <a href="{@docRoot}resources/faq/troubleshooting.html#signingcalendar">
+I can't compile my app because the build tools generated an expired debug
+certificate</a>. </p>
+
+
+<h2 id="releasemode">Signing in Release Mode</h2>
+
+<p>When your application is ready for release to other users, you must:</p>
+<ol>
+ <li><a href="#cert">Obtain a suitable private key</a></li>
+ <li><a href="#releasecompile">Compile the application in release mode</a></li>
+ <li><a href="#signapp">Sign your application with your private key</a></li>
+ <li><a href="#align">Align the final APK package</a></li>
+</ol>
+
+<p>If you are developing in Eclipse with the ADT plugin, you can use the Export Wizard
+to perform the compile, sign, and align procedures. The Export Wizard even allows you to
+generate a new keystore and private key in the process. So if you use Eclipse, you can
+skip to <a href="#ExportWizard">Compile and sign with Eclipse ADT</a>.</p>
+
+
+
+<h3 id="cert">1. Obtain a suitable private key</h3>
+
+<p>In preparation for signing your application, you must first ensure that
+you have a suitable private key with which to sign. A suitable private
+key is one that:</p>
+
+<ul>
+<li>Is in your possession</li>
+<li>Represents the personal, corporate, or organizational entity to be identified
+with the application</li>
+<li>Has a validity period that exceeds the expected lifespan of the application
+or application suite. A validity period of more than 25 years is recommended.
+<p>If you plan to publish your application(s) on Google Play, note that a
+validity period ending after 22 October 2033 is a requirement. You can not upload an
+application if it is signed with a key whose validity expires before that date.
+</p></li>
+<li>Is not the debug key generated by the Android SDK tools. </li>
+</ul>
+
+<p>The key may be self-signed. If you do not have a suitable key, you must
+generate one using Keytool. Make sure that you have Keytool available, as described
+in <a href="#setup">Basic Setup</a>.</p>
+
+<p>To generate a self-signed key with Keytool, use the <code>keytool</code>
+command and pass any of the options listed below (and any others, as
+needed). </p>
+
+<p class="warning"><strong>Warning:</strong> Keep your private key secure.
+Before you run Keytool, make sure to read
+<a href="#secure-key">Securing Your Private Key</a> for a discussion of how to keep
+your key secure and why doing so is critically important to you and to users. In
+particular, when you are generating your key, you should select strong passwords
+for both the keystore and key.</p>
+
+<table>
+<tr>
+<th>Keytool Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-genkey</code></td><td>Generate a key pair (public and private
+keys)</td>
+</tr>
+<tr>
+<td><code>-v</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-alias <alias_name></code></td><td>An alias for the key. Only
+the first 8 characters of the alias are used.</td>
+</tr>
+<tr>
+<td><code>-keyalg <alg></code></td><td>The encryption algorithm to use
+when generating the key. Both DSA and RSA are supported.</td>
+</tr>
+<tr>
+<td><code>-keysize <size></code></td><td>The size of each generated key
+(bits). If not supplied, Keytool uses a default key size of 1024 bits. In
+general, we recommend using a key size of 2048 bits or higher. </td>
+</tr>
+<tr>
+<td><code>-dname <name></code></td><td><p>A Distinguished Name that describes
+who created the key. The value is used as the issuer and subject fields in the
+self-signed certificate. </p><p>Note that you do not need to specify this option
+in the command line. If not supplied, Jarsigner prompts you to enter each
+of the Distinguished Name fields (CN, OU, and so on).</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the
+key.</p> <p>As a security precaution, do not include this option in your command
+line. If not supplied, Keytool prompts you to enter the password. In this way,
+your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-validity <valdays></code></td><td><p>The validity period for the
+key, in days. </p><p><strong>Note:</strong> A value of 10000 or greater is recommended.</p></td>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>A name
+for the keystore containing the private key.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>A password for the
+keystore.</p><p>As a security precaution, do not include this option in your
+command line. If not supplied, Keytool prompts you to enter the password. In
+this way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's an example of a Keytool command that generates a private key:</p>
+
+<pre>$ keytool -genkey -v -keystore my-release-key.keystore
+-alias alias_name -keyalg RSA -keysize 2048 -validity 10000</pre>
+
+<p>Running the example command above, Keytool prompts you to provide
+passwords for the keystore and key, and to provide the Distinguished
+Name fields for your key. It then generates the keystore as a file called
+<code>my-release-key.keystore</code>. The keystore and key are
+protected by the passwords you entered. The keystore contains
+a single key, valid for 10000 days. The alias is a name that you —
+will use later, to refer to this keystore when signing your application. </p>
+
+<p>For more information about Keytool, see the documentation at
+<a
+href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/keytool.html</a></p>
+
+
+
+<h3 id="releasecompile">2. Compile the application in release mode</h3>
+
+<p>In order to release your application to users, you must compile it in release mode.
+In release mode, the compiled application is not signed by default and you will need
+to sign it with your private key.</p>
+
+<p class="caution"><strong>Caution:</strong>
+You can not release your application unsigned, or signed with the debug key.</p>
+
+<h4>With Eclipse</h4>
+
+<p>To export an <em>unsigned</em> APK from Eclipse, right-click the project in the Package
+Explorer and select <strong>Android Tools</strong> > <strong>Export Unsigned Application
+Package</strong>. Then specify the file location for the unsigned APK.
+(Alternatively, open your <code>AndroidManifest.xml</code> file in Eclipse, select
+the <strong>Manifest</strong> tab, and click <strong>Export an unsigned APK</strong>.)</p>
+
+<p>Note that you can combine the compiling and signing steps with the Export Wizard. See
+<a href="#ExportWizard">Compiling and signing with Eclipse ADT</a>.</p>
+
+<h4>With Ant</h4>
+
+<p>If you are using Ant, you can enable release mode by using the <code>release</code> option
+with the <code>ant</code> command. For example, if you are running Ant from the
+directory containing your {@code build.xml} file, the command would look like this:</p>
+
+<pre>$ ant release</pre>
+
+<p>By default, the build script compiles the application APK without signing it. The output file
+in your project {@code bin/} will be <code><em><your_project_name></em>-unsigned.apk</code>.
+Because the application APK is still unsigned, you must manually sign it with your private
+key and then align it using {@code zipalign}.</p>
+
+<p>However, the Ant build script can also perform the signing
+and aligning for you, if you have provided the path to your keystore and the name of
+your key alias in the project's {@code ant.properties} file. With this information provided,
+the build script will prompt you for your keystore and alias password when you perform
+<code>ant release</code>, it will sign the package and then align it. The final output
+file in {@code bin/} will instead be
+<code><em><your_project_name></em>-release.apk</code>. With these steps
+automated for you, you're able to skip the manual procedures below (steps 3 and 4).
+To learn how to specify your keystore and alias in the {@code ant.properties} file,
+see <a href="{@docRoot}tools/building/building-cmdline.html#ReleaseMode">
+Building and Running Apps on the Command Line</a>.</p>
+
+
+
+<h3 id="signapp">3. Sign your application with your private key</h3>
+
+<p>When you have an application package that is ready to be signed, you can do sign it
+using the Jarsigner tool. Make sure that you have Jarsigner available on your
+machine, as described in <a href="#setup">Basic Setup</a>. Also, make sure that
+the keystore containing your private key is available.</p>
+
+<p>To sign your application, you run Jarsigner, referencing both the
+application's APK and the keystore containing the private key with which to
+sign the APK. The table below shows the options you could use. </p>
+
+<table>
+<tr>
+<th>Jarsigner Option</th>
+<th>Description</th>
+</tr>
+<tr>
+<td><code>-keystore <keystore-name>.keystore</code></td><td>The name of
+the keystore containing your private key.</td>
+</tr>
+<tr>
+<td><code>-verbose</code></td><td>Enable verbose output.</td>
+</tr>
+<tr>
+<td><code>-sigalg</code></td><td>The name of the signature algorithim to use in signing the APK.
+Use the value {@code MD5withRSA}.</td>
+</tr>
+<tr>
+<td><code>-digestalg</code></td><td>The message digest algorithim to use in processing the entries
+of an APK. Use the value {@code SHA1}.</td>
+</tr>
+<tr>
+<td><code>-storepass <password></code></td><td><p>The password for the
+keystore. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+<tr>
+<td><code>-keypass <password></code></td><td><p>The password for the private
+key. </p><p>As a security precaution, do not include this option
+in your command line unless you are working at a secure computer.
+If not supplied, Jarsigner prompts you to enter the password. In this
+way, your password is not stored in your shell history.</p></td>
+</tr>
+</table>
+
+<p>Here's how you would use Jarsigner to sign an application package called
+<code>my_application.apk</code>, using the example keystore created above.
+</p>
+
+<pre>$ jarsigner -verbose -sigalg MD5withRSA -digestalg SHA1 -keystore my-release-key.keystore
+my_application.apk alias_name</pre>
+
+<p>Running the example command above, Jarsigner prompts you to provide
+passwords for the keystore and key. It then modifies the APK
+in-place, meaning the APK is now signed. Note that you can sign an
+APK multiple times with different keys.</p>
+
+<p class="caution"><strong>Caution:</strong> As of JDK 7, the default signing algorithim has
+changed, requiring you to specify the signature and digest algorithims ({@code -sigalg} and {@code
+-digestalg}) when you sign an APK.</p>
+
+<p>To verify that your APK is signed, you can use a command like this:</p>
+
+<pre>$ jarsigner -verify my_signed.apk</pre>
+
+<p>If the APK is signed properly, Jarsigner prints "jar verified".
+If you want more details, you can try one of these commands:</p>
+
+<pre>$ jarsigner -verify -verbose my_application.apk</pre>
+
+<p>or</p>
+
+<pre>$ jarsigner -verify -verbose -certs my_application.apk</pre>
+
+<p>The command above, with the <code>-certs</code> option added, will show you the
+"CN=" line that describes who created the key.</p>
+
+<p class="note"><strong>Note:</strong> If you see "CN=Android Debug", this means the APK was
+signed with the debug key generated by the Android SDK. If you intend to release
+your application, you must sign it with your private key instead of the debug
+key.</p>
+
+<p>For more information about Jarsigner, see the documentation at
+<a href="http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html">
+http://docs.oracle.com/javase/6/docs/technotes/tools/windows/jarsigner.html</a></p>
+
+
+<h3 id="align">4. Align the final APK package</h3>
+
+<p>Once you have signed the APK with your private key, run <code>zipalign</code> on the file.
+This tool ensures that all uncompressed data starts with a particular byte alignment,
+relative to the start of the file. Ensuring alignment at 4-byte boundaries provides
+a performance optimization when installed on a device. When aligned, the Android
+system is able to read files with {@code mmap()}, even if
+they contain binary data with alignment restrictions, rather than copying all
+of the data from the package. The benefit is a reduction in the amount of
+RAM consumed by the running application.</p>
+
+<p>The <code>zipalign</code> tool is provided with the Android SDK, inside the
+<code>tools/</code> directory. To align your signed APK, execute:</p>
+
+<pre>$ zipalign -v 4 <em>your_project_name</em>-unaligned.apk <em>your_project_name</em>.apk</pre>
+
+<p>The {@code -v} flag turns on verbose output (optional). {@code 4} is the
+byte-alignment (don't use anything other than 4). The first file argument is
+your signed {@code .apk} file (the input) and the second file is the destination {@code .apk} file
+(the output). If you're overriding an existing APK, add the {@code -f} flag.</p>
+
+<p class="caution"><strong>Caution:</strong> Your input APK must be signed with your
+private key <strong>before</strong> you optimize the package with {@code zipalign}.
+If you sign it after using {@code zipalign}, it will undo the alignment.</p>
+
+<p>For more information, read about the
+<a href="{@docRoot}tools/help/zipalign.html">zipalign</a> tool.
+
+
+<h3 id="ExportWizard">Compile and sign with Eclipse ADT</h3>
+
+<p>If you are using Eclipse with the ADT plugin, you can use the Export Wizard to
+export a <em>signed</em> APK (and even create a new keystore,
+if necessary). The Export Wizard performs all the interaction with
+the Keytool and Jarsigner for you, which allows you to sign the package using a GUI
+instead of performing the manual procedures to compile, sign,
+and align, as discussed above. Once the wizard has compiled and signed your package,
+it will also perfom package alignment with {@code zipalign}.
+Because the Export Wizard uses both Keytool and Jarsigner, you should
+ensure that they are accessible on your computer, as described above
+in the <a href="#setup">Basic Setup for Signing</a>.</p>
+
+<p>To create a signed and aligned APK in Eclipse:</p>
+
+<ol>
+ <li>Select the project in the Package
+Explorer and select <strong>File > Export</strong>.</li>
+ <li>Open the Android folder, select Export Android Application,
+ and click <strong>Next</strong>.
+ <p>The Export Android Application wizard now starts, which will
+ guide you through the process of signing your application,
+ including steps for selecting the private key with which to sign the APK
+ (or creating a new keystore and private key).</p>
+ <li>Complete the Export Wizard and your application will be compiled,
+ signed, aligned, and ready for distribution.</li>
+</ol>
+
+
+
+<h2 id="secure-key">Securing Your Private Key</h2>
+
+<p>Maintaining the security of your private key is of critical importance, both
+to you and to the user. If you allow someone to use your key, or if you leave
+your keystore and passwords in an unsecured location such that a third-party
+could find and use them, your authoring identity and the trust of the user
+are compromised. </p>
+
+<p>If a third party should manage to take your key without your knowledge or
+permission, that person could sign and distribute applications that maliciously
+replace your authentic applications or corrupt them. Such a person could also
+sign and distribute applications under your identity that attack other
+applications or the system itself, or corrupt or steal user data. </p>
+
+<p>Your reputation as a developer entity depends on your securing your private
+key properly, at all times, until the key is expired. Here are some tips for
+keeping your key secure: </p>
+
+<ul>
+<li>Select strong passwords for the keystore and key.</li>
+<li>When you generate your key with Keytool, <em>do not</em> supply the
+<code>-storepass</code> and <code>-keypass</code> options at the command line.
+If you do so, your passwords will be available in your shell history,
+which any user on your computer could access.</li>
+<li>Similarly, when signing your applications with Jarsigner,
+<em>do not</em> supply the <code>-storepass</code> and <code>-keypass</code>
+options at the command line. </li>
+<li>Do not give or lend anyone your private key, and do not let unauthorized
+persons know your keystore and key passwords.</li>
+</ul>
+
+<p>In general, if you follow common-sense precautions when generating, using,
+and storing your key, it will remain secure. </p>
\ No newline at end of file
diff --git a/docs/html/tools/workflow/publishing/preparing.jd b/docs/html/tools/workflow/publishing/preparing.jd
new file mode 100644
index 0000000..4633d7e
--- /dev/null
+++ b/docs/html/tools/workflow/publishing/preparing.jd
@@ -0,0 +1,358 @@
+page.title=Preparing for Release
+@jd:body
+
+<div id="qv-wrapper">
+ <div id="qv">
+ <h2>Quickview</h2>
+ <ul>
+ <li>Learn which resources you'll need to release your app.</li>
+ <li>Find out how to configure and build your app for release.</li>
+ <li>Learn best practices for releasing your app.</li>
+ </ul>
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#publishing-intro">Introduction</a></li>
+ <li><a href="#publishing-gather">Gathering Materials and Resources</a></li>
+ <li><a href="#publishing-configure">Configuring Your Application</a></li>
+ <li><a href="#publishing-build">Building Your Application</a></li>
+ <li><a href="#publishing-resources">Preparing External Servers and Resources</a></li>
+ <li><a href="#publishing-test">Testing Your Application for Release</a></li>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing Overview</a></li>
+ <li><a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a></li>
+ <li><a href="{@docRoot}tools/publishing/publishing.html">Publishing on Google Play</a></li>
+ </ol>
+ </div>
+</div>
+
+<p>Before you distribute your Android application to users you need to prepare it for release. The
+preparation process is a required <a href="{@docRoot}tools/workflow/index.html">development
+task</a> for all Android applications and is the first step in the publishing process (see figure
+1).</p>
+
+<p>When you prepare your application for release, you configure, build, and test a release
+version of your application. The configuration tasks are straightforward, involving basic code
+cleanup and code modification tasks that help optimize your application. The build process is
+similar to the debug build process and can be done using JDK and Android SDK tools. The testing
+tasks serve as a final check, ensuring that your application performs as expected under real-world
+conditions. When you are finished preparing your application for release you have a signed
+<code>.apk</code> file, which you can distribute directly to users or distribute through an
+application marketplace such as Google Play.</p>
+
+<p>This document summarizes the main tasks you need to perform to prepare your application for
+release. The tasks that are described in this document apply to all Android applications regardless
+how they are released or distributed to users. If you are releasing your application through Google
+Play, you should also read <a href="{@docRoot}tools/publishing/publishing.html">Publishing on
+Google Play</a> to be sure your release-ready application satisfies all Google Play
+requirements.</p>
+
+<p class="note"><strong>Note:</strong> As a best practice, your application should meet all of your
+release criteria for functionality, performance, and stability before you perform the tasks outlined
+in this document.</p>
+
+<img src="{@docRoot}images/publishing/publishing_overview_prep.png"
+ alt="Shows how the preparation process fits into the development process"
+ height="190"
+ id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> Preparing for release is a required <a
+href="{@docRoot}tools/workflow/index.html">development
+task</a> and is the first step in the publishing process.
+</p>
+
+<h2 id="publishing-intro">Introduction</h2>
+
+<p>To release your application to users you need to create a release-ready package that users can
+install and run on their Android-powered devices. The release-ready package contains the same
+components as the debug <code>.apk</code> file — compiled source code, resources, manifest
+file, and so on — and it is built using the same build tools. However, unlike the debug
+<code>.apk</code> file, the release-ready <code>.apk</code> file is signed with your own certificate
+and it is optimized with the zipalign tool.</p>
+
+<div class="figure" style="width:331px">
+ <img src="{@docRoot}images/publishing/publishing_preparing.png"
+ alt="Shows the five tasks you perform to prepare your app for release"
+ height="450" />
+ <p class="img-caption">
+ <strong>Figure 2.</strong> You perform five main tasks to prepare your application for
+ release.
+ </p>
+</div>
+
+<p>The signing and optimization tasks are usually seamless if you are building your application with
+Eclipse and the ADT plugin or with the Ant build script (included with the Android SDK). For
+example, you can use the Eclipse Export Wizard to compile, sign, and optimize your application all
+at once. You can also configure the Ant build script to do the same when you build from the command
+line.</p>
+
+<p>To prepare your application for release you typically perform five main tasks (see figure 2).
+Each main task may include one or more smaller tasks depending on how you are releasing your
+application. For example, if you are releasing your application through Google Play you may want
+to add special filtering rules to your manifest while you are configuring your application for
+release. Similarly, to meet Google Play publishing guidelines you may have to prepare screenshots
+and create promotional text while you are gathering materials for release.</p>
+
+<p>You usually perform the tasks listed in figure 2 after you have throroughly debugged and tested
+your application. The Android SDK contains several tools to help you test and debug your Android
+applications. For more information, see the <a
+href="{@docRoot}tools/debugging/index.html">Debugging</a> and <a
+href="{@docRoot}tools/testing/index.html">Testing</a> sections in the Dev Guide.</p>
+
+<h2 id="publishing-gather">Gathering Materials and Resources</h2>
+
+<p>To begin preparing your application for release you need to gather several supporting items. At a
+minimum this includes cryptographic keys for signing your application and an application icon. You
+might also want to include an end-user license agreement.</p>
+
+<h4 id="publishing-keys">Cryptographic keys</h4>
+
+<p>The Android system requires that each installed application be digitally signed with a
+certificate that is owned by the application's developer (that is, a certificate for which the
+developer holds the private key). The Android system uses the certificate as a means of identifying
+the author of an application and establishing trust relationships between applications. The
+certificate that you use for signing does not need to be signed by a certificate authority; the
+Android system allows you to sign your applications with a self-signed certificate. To learn about
+certificate requirements, see <a href="{@docRoot}tools/publishing/app-signing.html#cert">Obtain a
+suitable private key</a>.</p>
+
+<p class="caution"><strong>Important:</strong> Your application must be signed with a cryptographic
+key whose validity period ends after 22 October 2033.</p>
+
+<p>You may also have to obtain other release keys if your application accesses a service or uses a
+third-party library that requires you to use a key that is based on your private key. For example,
+if your application uses the <a
+href="http://code.google.com/android/add-ons/google-apis/reference/com/google/android/maps/MapView.html">MapView</a>
+class, which is part of the <a
+href="http://code.google.com/android/add-ons/google-apis/maps-overview.html">Google Maps external
+library</a>, you will need to register your application with the Google Maps service and obtain
+a Maps API key. For information about getting a Maps API key, see <a
+href="http://code.google.com/android/add-ons/google-apis/mapkey.html"> Obtaining a Maps API
+key</a>.</p>
+
+<h4>Application Icon</h4>
+
+<p>Be sure you have an application icon and that it meets the recommended <a
+href="{@docRoot}guide/practices/ui_guidelines/icon_design_launcher.html">icon guidelines</a>. Your
+application's icon helps users identify your application on a device's Home
+screen and in the Launcher window. It also appears in Manage Applications, My Downloads, and
+elsewhere. In addition, publishing services such as Google Play display your icon to users.</p>
+
+<p class="note"><strong>Note:</strong> If you are releasing your application on Google Play, you
+need to create a high resolution
+ version of your icon. See <a
+href="https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870">Graphic
+Assets for your Application</a> for more information.</p>
+
+<h4>End-user License Agreement</h4>
+
+<p>Consider preparing an End User License Agreement (EULA) for your application. A EULA can help
+protect your person, organization, and intellectual property, and we recommend that you provide one
+with your application.</p>
+
+<h4>Miscellaneous Materials</h4>
+
+<p>You might also have to prepare promotional and marketing materials to publicize your application.
+For example, if you are releasing your application on Google Play you will need to prepare some
+promotional text and you will need to create screenshots of your application. For more
+information, see
+<a href="https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870">
+Graphic Assets for your Application</a></p>
+
+<h2 id="publishing-configure">Configuring Your Application for Release</h2>
+
+<p>After you gather all of your supporting materials you can start configuring your application
+for release. This section provides a summary of the configuration changes we recommend that you make
+to your source code, resource files, and application manifest prior to releasing your application.
+Although most of the configuration changes listed in this section are optional, they are
+considered good coding practices and we encourage you to implement them. In some cases,
+you may have already made these configuration changes as part of your development process.</p>
+
+<h4>Choose a good package name</h4>
+
+<p>Make sure you choose a package name that is suitable over the life of your application. You
+cannot change the package name after you distribute your application to users. You can set the
+package name in application's manifest file. For more information, see the <a
+href="{@docRoot}guide/topics/manifest/manifest-element.html#package">package</a> attribute
+documentation.</p>
+
+<h4>Turn off logging and debugging</h4>
+
+<p>Make sure you deactivate logging and disable the debugging option before you build your
+application for release. You can deactivate logging by removing calls to
+{@link android.util.Log} methods in your source files. You can disable debugging by removing the
+<code>android:debuggable</code> attribute from the <code><application></code> tag in your
+manifest file, or by setting the <code>android:debuggable</code> attribute to
+<code>false</code> in your manifest file. Also, remove any log files or static test files that
+were created in your project.</p>
+
+<p>Also, you should remove all {@link android.os.Debug} tracing calls that you
+added to your code, such as {@link android.os.Debug#startMethodTracing()} and
+{@link android.os.Debug#stopMethodTracing()} method calls.</p>
+
+<h4>Clean up your project directories</h4>
+
+<p>Clean up your project and make sure it conforms to the directory structure described in <a
+href="{@docRoot}tools/projects/index.html#ApplicationProjects">Android Projects</a>.
+Leaving stray or orphaned files in your project can prevent your application from compiling and
+cause your application to behave unpredictably. At a minimum you should do the following cleanup
+tasks:</p>
+
+<ul>
+ <li>Review the contents of your <code>jni/</code>, <code>lib/</code>, and <code>src/</code>
+ directories. The <code>jni/</code> directory should contain only source files associated with the
+ <a href="{@docRoot}tools/sdk/ndk/index.html">Android NDK</a>, such as
+ <code>.c</code>, <code>.cpp</code>, <code>.h</code>, and <code>.mk</code> files. The
+ <code>lib/</code> directory should contain only third-party library files or private library
+ files, including prebuilt shared and static libraries (for example, <code>.so</code> files). The
+ <code>src/</code> directory should contain only the source files for your application
+ (<code>.java</code> and <code>.aidl</code> files). The <code>src/</code> directory should not
+ contain any <code>.jar</code> files.</li>
+ <li>Check your project for private or proprietary data files that your application does not use
+ and remove them. For example, look in your project's <code>res/</code> directory for old
+ drawable files, layout files, and values files that you are no longer using and delete them.</li>
+ <li>Check your <code>lib/</code> directory for test libraries and remove them if they are no
+ longer being used by your application.</li>
+ <li>Review the contents of your <code>assets/</code> directory and your <code>res/raw/</code>
+ directory for raw asset files and static files that you need to update or remove prior to
+ release.</li>
+</ul>
+
+<h4>Review and update your manifest settings</h4>
+
+<p>Verify that the following manifest items are set correctly:</p>
+
+<ul>
+ <li><a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">
+ <uses-permission></a> element
+ <p>You should specify only those permissions that are relevant and required for your application.</p>
+ </li>
+ <li><code>android:icon</code> and <code>android:label</code> attributes
+ <p>You must specify values for these attributes, which are located in the
+ <a href="{@docRoot}guide/topics/manifest/application-element.html"><application></a>
+ element.</p>
+ </li>
+ <li><code>android:versionCode</code> and <code>android:versionName</code> attributes.
+ <p>We recommend that you specify values for these attributes, which are located in the
+ <a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a>
+ element. For more information see
+ <a href="{@docRoot}tools/publishing/versioning.html">Versioning your Application</a>.</p>
+ </li>
+</ul>
+
+<p>There are several additional manifest elements that you can set if you are releasing your
+application on Google Play. For example, the <code>android:minSdkVersion</code> and
+<code>android:targetSdkVersion</code> attributes, which are located in the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"> <uses-sdk></a> element. For more
+information about these and other Google Play settings, see <a
+href="{@docRoot}/guide//appendix/market-filters.html">Filters on Google Play</a>.</p>
+
+<h4>Address compatibility issues</h4>
+
+<p>Android provides several tools and techniques to make your application compatible with a wide
+range of devices. To make your application available to the largest number of users, consider
+doing the following:</p>
+
+<ul>
+ <li><strong>Add support for multiple screen configurations</strong>
+ <p>Make sure you meet the
+ <a href="{@docRoot}guide/practices/screens_support.html#screen-independence">
+ best practices for supporting multiple screens</a>. By supporting multiple screen configurations
+ you can create an application that functions properly and looks good on any of the screen sizes
+ supported by Android.</p>
+ </li>
+ <li><strong>Optimize your application for Android 3.0 devices.</strong>
+ <p>If your application is designed for devices older than Android 3.0, make it compatible
+ with Android 3.0 devices by following the guidelines and best practices described in
+ <a href="{@docRoot}guide/practices/optimizing-for-3.0.html">Optimizing Apps for Android 3.0
+ </a>.</p>
+ </li>
+ <li><strong>Consider using the Support Library</strong>
+ <p>If your application is designed for devices running Android 3.x, make your application
+ compatible with older versions of Android by adding the
+ <a href="{@docRoot}tools/extras/support-library.html">Support Library</a> to your
+ application project. The Support Library provides static support libraries that you can add to
+ your Android application, which enables you to use APIs that are either not available on
+ older platform versions or use utility APIs that are not part of the framework APIs.</p>
+ </li>
+</ul>
+
+<h4>Update URLs for servers and services</h4>
+
+<p>If your application accesses remote servers or services, make sure you are using the production
+URL or path for the server or service and not a test URL or path.</p>
+
+<h4>Implement Licensing (if you are releasing on Google Play)</h4>
+
+<p>If you are releasing a paid application through Google Play, consider adding support for
+Google Play Licensing. Licensing lets you control access to your application based on whether the
+current user has purchased it. Using Google Play Licensing is optional even if you are
+releasing your app through Google Play.</p>
+
+<p>For more information about Google Play Licensing Service and how to use it in your
+application, see <a href="{@docRoot}guide/google/play/licensing/index.html">Application Licensing</a>.</p>
+
+<h2 id="publishing-build">Building Your Application for Release</h2>
+
+<p>After you finish configuring your application you can build it into a release-ready
+<code>.apk</code> fle that is signed and optimized. The JDK includes the tools for signing the
+<code>.apk</code> file (Keytool and Jarsigner); the Android SDK includes the tools for compiling and
+optimizing the <code>.apk</code> file. If you are using Eclipse with the ADT plugin or you are using
+the Ant build script from the command line, you can automate the entire build process.</p>
+
+<h3>Building with Eclipse</h3>
+
+<p>You can use the Eclipse Export Wizard to build a release-ready <code>.apk</code> file that is
+signed with your private key and optimized. To learn how to run the Export Wizard, see
+<a href="{@docRoot}tools/publishing/app-signing.html#ExportWizard">Compile and sign with Eclipse
+ADT</a>. The Export Wizard compiles your application for release, signs your application with your
+private key, and optimizes your application with the zipalign tool. The Export Wizard should run
+successfully if you have run or debugged your application from Eclipse and you have no errors in
+your application (see <a href="{@docRoot}tools/building/building-eclipse.html">Building
+and Running from Eclipse with ADT</a> for more information.</p>
+
+<p>The Export Wizard assumes that you have a <a href="#billing-keys">certificate and private key</a>
+suitable for signing your application. If you do not have a suitable certificate and private key,
+the Export Wizard will help you generate one (see
+<a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a> for more
+information about the signing process and signing guidelines.</p>
+
+<h3>Building with Ant</h3>
+
+<p>You can use the Ant build script (included in the Android SDK) to build a release-ready
+<code>.apk</code> file that is signed with your private key and optimized. To learn how to do this,
+see <a href="{@docRoot}tools/building/building-cmdline.html#ReleaseMode">Building in
+Release Mode</a>. This build method assumes you have a <a href="#billing-keys">certificate and
+private key</a> suitable for signing your application. If you do not have a suitable certificate and
+private key, the Export Wizard will help you generate one (see
+<a href="{@docRoot}tools/publishing/app-signing.html">Signing Your Applications</a> for more
+information about the signing process and signing guidelines.</p>
+
+<h2 id="publishing-resources">Preparing External Servers and Resources</h2>
+
+<p>If your application relies on a remote server, make sure the server is secure and that it is
+configured for production use. This is particularly important if you are implementing <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> in your application and you are
+performing the signature verification step on a remote server.</p>
+
+<p>Also, if your application fetches content from a remote server or a real-time service (such as a
+content feed), be sure the content you are providing is up to date and production-ready.</p>
+
+<h2 id="publishing-test">Testing Your Application for Release</h2>
+
+<p>Testing the release version of your application helps ensure that your application runs properly
+under realistic device and network conditions. Ideally, you should test your application on at least
+one handset-sized device and one tablet-sized device to verify that your user interface elements are
+sized correctly and that your application's performance and battery efficiency are acceptable.</p>
+
+<p>As a starting point for testing, see
+<a href="{@docRoot}tools/testing/what_to_test.html">What to Test</a>. This article provides
+a summary of common Android situations that you should consider when you are testing. When you are
+done testing and you are satisfied that the release version of your application
+behaves correctly, you can release your application to users. For more information, see
+<a href="{@docRoot}tools/publishing/publishing_overview.html#publishing-release">Releasing Your
+Application to Users</a>. If you are publishing your application on Google Play, see
+<a href="{@docRoot}tools/publishing/publishing.html">Publishing on Google Play</a>.</p>
+
+
diff --git a/docs/html/tools/workflow/publishing/publishing.jd b/docs/html/tools/workflow/publishing/publishing.jd
new file mode 100644
index 0000000..a54b030
--- /dev/null
+++ b/docs/html/tools/workflow/publishing/publishing.jd
@@ -0,0 +1,703 @@
+page.title=Publishing on Google Play
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>Learn how to publish and update apps on Google Play.</li>
+<li>Find out how to create links to apps that are published on Google Play.</li>
+<li>Learn about Google Play features.</li>
+</ul>
+
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#overview">About Google Play</a>
+<li><A href="#marketpublish">Publishing Apps on Google Play</a></li>
+<li><a href="#marketupgrade">Publishing Updates on Google Play</a></li>
+<li><a href="#marketLicensing">Using Google Play Licensing Service</a></li>
+<li><a href="#marketinappbilling">Using Google Play In-app Billing</a></li>
+<li><a href="#marketintent">Linking to Your Apps on Google Play</a>
+ <ol>
+ <li><a href="#OpeningDetails">Opening an app's details page</a></li>
+ <li><a href="#PerformingSearch">Performing a search</a></li>
+ <li><a href="#BuildaButton">Build a Google Play button</a></li>
+ <li><a href="#UriSummary">Summary of URI formats</a></li>
+ </ol>
+</li>
+</ol>
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/publishing_overview.html">Publishing Overview</a></li>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing for Release</a></li>
+</ol>
+
+<div id="qv-extra">
+ <img id="rule" src="{@docRoot}assets/images/grad-rule-qv.png">
+ <div id="qv-sub-rule">
+ <img src="{@docRoot}assets/images/icon_play.png" style="float:left;margin:0;padding:0 5px;">
+ <h2 style="color:#669999;">Already know about Google Play and want to get started?</h2>
+ <p>Go to <a href="http://play.google.com/apps/publish">Google Play</a>, create a developer
+account, and upload your application. For more information about required assets, listing details,
+and publishing options, see <a
+href="http://market.android.com/support/bin/answer.py?answer=113469">Upload
+Applications</a>.</p>
+ </div>
+</div>
+
+</div>
+</div>
+
+<p>One of the most effective ways to get your application into users' hands is to
+publish it on an application marketplace like Google Play. Publishing on Google Play is a
+straightforward process that you can do in just a few simple steps—register, configure,
+upload, and publish. Registration takes only a few minutes and needs to be done only once.
+The configuration and publishing steps can all be done through the Google Play Android Developer Console
+after you register as a Google Play developer.</p>
+
+<p>To start publishing on Google Play, first read this topic and then go to the <a
+href="https://play.google.com/apps/publish">Google Play Android Developer Console</a> and register as
+a Google Play developer.</p>
+
+
+<h2 id="overview">About Google Play</h2>
+
+<p>Google Play is a robust publishing platform that helps you publicize, sell, and distribute
+your Android applications to users around the world. When you release your applications through
+Google Play you have access to a suite of developer tools that let you analyze your sales,
+identify market trends, and control who your applications are being distributed to. You also have
+access to several revenue-enhancing features, such as <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> and
+<a href="{@docRoot}guide/google/play/licensing/index.html">application licensing</a>.</p>
+
+<p>Before you can publish applications on Google Play, you need to <a
+href="http://play.google.com/apps/publish">register</a> as a Google Play developer. During the
+registration process you will need to create a developer profile, pay a registration fee, and agree
+to the <a href="http://www.android.com/us/developer-distribution-agreement.html">Google Play
+Developer Distribution Agreement</a>. After you register you can access the Developer
+Console, where you can upload applications, configure publishing options, and monitor publishing
+data. If you want to sell your applications or use the in-app billing feature, you will also need
+to set up a Google Checkout merchant account. For more information about the registration process,
+see <a href="https://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=113468">
+Developer Registration</a>.</p>
+
+<h2 id="marketpublish">Publishing Apps on Google Play</h2>
+
+<p>Publishing your application on Google Play is a simple process that involves three basic
+tasks (see figure 1):</p>
+
+<ul>
+ <li>Creating various graphical assets that
+accompany your app on Google Play.</li>
+ <li>Using the Google Play <a
+href="http://play.google.com/apps/publish">Developer Console</a> to configure publishing options,
+specify listing details, and upload your app and graphical assets to Google Play.</li>
+ <li>Reviewing your publishing settings and changing the release
+status of your app from Unpublished to Published.</li>
+</ul>
+
+<img src="{@docRoot}images/publishing/publishing_android_market.png"
+ alt="Shows the three steps that are required to publish on Google Play"
+ height="168"
+ id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> To publish apps on Google Play you must first <a
+href="{@docRoot}tools/publishing/preparing.html">prepare your app for release</a> and then perform
+three simple tasks.
+</p>
+
+<p class="caution"><strong>Important:</strong> You must <a
+href="{@docRoot}tools/publishing/preparing.html">prepare your application for release</a> before you
+can publish it on Google Play. When you prepare your application for release you configure it for
+release and build it in release mode. Building in release mode signs your application's {@code .apk}
+file with your private release key. You cannot publish an application on Google Play unless it is
+signed with your own private release key.</p>
+
+<h3>Preparing promotional materials</h3>
+
+<p>To fully leverage the marketing and publicity capabilities of Google Play, you need to create
+several graphical assets that accompany your app on Google Play, such as screenshots, videos,
+promotional graphics, and promotional text. At a minimum you must provide two screenshots of your
+application and a high resolution application icon. The screenshots are displayed on the details
+page for your application on Google Play, and the high resolution application icon is displayed
+in various locations throughout Google Play. The high resolution icon does not replace the
+launcher icon for your application, rather, it serves as a supplemental icon and should look
+the same as your launcher icon. Promotional video,
+graphics, and text are optional, although we strongly recommended that you prepare these for your
+app. For more information about the graphic assets that accompany your application, see <a
+href="http://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=1078870">Graphic
+Assets for your Application</a>.</p>
+
+<h3>Configuring options and uploading assets</h3>
+
+<p>Google Play lets you target your application to a worldwide pool of users and devices. To
+reach these users you can use the Developer Console to configure various publishing
+options and listing details for your app. For example, you can choose the <a
+href="http://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=138294&topic=
+2365624&ctx=topic">countries</a> you want to reach, the listing languages you want to use, and the
+<a
+href="http://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=138412&topic=
+15867&ctx=topic">price</a> you want to charge in each country. You can also configure listing
+details such as the application type, <a
+href="https://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=113475&topic=
+2365760&ctx=topic">category</a>, and <a
+href="http://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=188189&topic=
+2364761&ctx=topic">content rating</a>. In addition, if you want to sell items within your app using
+the in-app billing feature, you can use the Developer Console to <a
+href="http://grendel.sea.corp.google.com:48014/guide/google/play/billing/billing_admin.html#billing-list
+- setup">create a product list</a> and control which items are available for purchase in your
+app.</p>
+
+<p>When you are finished setting publishing options and listing details, you can upload your assets
+and your application to Google Play. You can also upload your application as a draft
+(unpublished) application, which lets you do final testing before you publish it for final
+release.</p>
+
+<p>To learn more about Google Play publishing settings, see the following resources:</p>
+
+<ul>
+ <li><a
+href="http://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=113469&topic=
+236562&ctx=topic">Upload Applications</a>—provides a summary of the publishing settings
+you can configure for an app.</li>
+ <li><a
+href="http://support.google.com/androidmarket/developer/bin/topic.py?hl=en&topic=15867">Selling
+Your Apps</a>—provides guidance about pricing, supported currencies, tax rates, and many
+other topics related to selling apps.</li>
+ <li><a
+href="https://support.google.com/androidmarket/developer/bin/answer.py?hl=en&answer=1169947&topic=
+15867&ctx=topic">Selling Apps in Multiple Currencies</a>—provides a description of how
+pricing, payouts, and exchange rates work.</li>
+</ul>
+
+<h3>Publishing your application</h3>
+
+<p>When you are satisfied that your publishing settings are correctly configured and your uploaded
+application is ready to be released to the public, you can simply click <strong>Publish</strong> in
+the Developer Console to make your app available for download
+around the world. Keep in mind, it can take several hours for your app to appear on Google
+Play after you click <strong>Publish</strong> in the Developer Console.</p>
+
+<h3>Controlling Distribution to Devices</h3>
+
+<p>If your application targets different device configurations, you can control which Android-powered
+devices have access to your application on Google Play by
+using Google Play filters. Filtering compares device configurations that you declare in your
+app's manifest file to the configuration defined by a device. For example, if you declare the camera
+filter in your manifest, only those devices that have a camera will see your app on Google
+Play. Filters must be configured in your application's manifest file when you are <a
+href="{@docRoot}tools/publishing/preparing.html">preparing your app for release</a> (that is, before
+you upload your app to Google Play). For more information, see <a
+href="{@docRoot}guide/google/play/filters.html">Filters on Google Play</a>.</p>
+
+<p>You can also use the multiple APK feature to distribute different {@code .apk} files under the same
+application listing and the same package name; however, you should use this option only as a last
+resort. Android applications usually run on most compatible devices with a single APK, by supplying
+alternative resources for different configurations (for example, different layouts for different screen
+sizes) and the Android system selects the appropriate resources for the device at runtime. In a
+few cases, however, a single APK is unable to support all device configurations, because alternative
+resources make the APK file too big (greater than 50MB) or other technical challenges prevent a
+single APK from working on all devices. Although we encourage you to develop and publish a single
+APK that supports as many device configurations as possible, doing so is sometimes
+not possible. To help you publish your application for as many devices as possible, Google Play
+allows you to publish multiple APKs under the same application listing. Google Play then supplies
+each APK to the appropriate devices based on configuration support you've declared in the manifest
+file of each APK. To use this feature, you need to build your separate {@code .apk} files when you are <a
+href="{@docRoot}tools/publishing/preparing.html">preparing your app for release</a> (that is, before
+you upload your app to Google Play). For more information, see <a
+href="{@docRoot}guide/google/play/publishing/multiple-apks.html">Multiple APK Support</a>.</p>
+
+<h2 id="marketupgrade">Publishing Updates on Google Play</h2>
+
+<p>At any time after publishing an application on Google Play, you can upload
+and publish an update to the same application package. When you publish an
+update to an application, users who have already installed the
+application may receive a notification that an update is
+available for the application. They can then choose to update the application
+to the latest version.</p>
+
+<p>Before uploading the updated application, be sure that you have incremented
+the <code>android:versionCode</code> and <code>android:versionName</code>
+attributes in the <a
+href="{@docRoot}guide/topics/manifest/manifest-element.html"><code><manifest></code></a>
+element of the manifest file. Also, the package name must be the same as the existing version and
+the {@code .apk} file must be signed with the same private key. If the package name and signing
+certificate do <em>not</em> match those of the existing version, Google Play will
+consider it a new application, publish it as such, and will not offer it to existing users as an
+update.</p>
+
+<p>If you plan to publish your application on Google Play, you must make sure
+ that it meets the requirements listed below, which are enforced by Google Play
+ when you upload the application.</p>
+
+<h2 id="marketLicensing">Using Google Play Licensing Service</h2>
+
+<p>Google Play offers a licensing service that lets you enforce licensing
+policies for paid applications that you publish through Google Play. With
+Google Play Licensing, your applications can query Google Play at runtime
+to obtain the licensing status for the current user, then allow or disallow
+further use of the application as appropriate. Using the service, you can apply a flexible
+licensing policy on an application-by-application basis—each
+application can enforce its licensing status in the way most appropriate
+for it. </p>
+
+<p>Any application that you publish through Google Play can use the Google
+Play Licensing Service. The service uses no dedicated framework APIs, so you can
+add licensing to any application that uses a minimum API Level of 3 or
+higher.</p>
+
+<p>For complete information about Google Play Licensing Service and how to
+use it in your application, read <a
+href="{@docRoot}guide/google/play/licensing/index.html">Application Licensing</a>.</p>
+
+<h2 id="marketinappbilling">Using Google Play In-app Billing</h2>
+
+<p><a href="{@docRoot}guide/google/play/billing/billing_overview.html">Google Play In-app Billing</a>
+is a Google Play service that lets you sell digital content in your applications. You can use
+the service to sell a wide range of content, including downloadable content such as media files or
+photos, and virtual content such as game levels or potions.</p>
+
+<p>When you use Google Play's in-app billing service to sell an item, Google Play handles all
+billing details so your application never has to directly process any financial transactions.
+Google Play uses the same checkout service that is used for application purchases, so your users
+experience a consistent and familiar purchase flow (see figure 1). Also, the transaction fee for
+in-app purchases is the same as the transaction fee for application purchases (30%).</p>
+
+<p>Any application that you publish through Google Play can implement in-app billing. No special
+account or registration is required other than a Google Play publisher account and a Google
+Checkout Merchant account. Also, because the service uses no dedicated framework APIs, you can add
+in-app billing to any application that uses a minimum API level of 4 or higher.</p>
+
+<p>To help you integrate in-app billing into your application, the Android SDK provides a <a
+href="{@docRoot}guide/google/play/billing/billing_integrate.html#billing-download">sample application</a>
+that demonstrates a simple implementation of in-app billing. The sample application contains
+examples of billing-related classes you can use to implement in-app billing in your application. It
+also contains examples of the database, user interface, and business logic you might use to
+implement in-app billing. For more information about the in-app billing feature, see the
+<a href="{@docRoot}guide/google/play/billing/index.html">In-app Billing documentation</a>.</p>
+
+<h2 id="marketintent">Linking to Your Apps on Google Play</h2>
+
+<p>To help users discover your published applications, you can use two special Google Play URIs
+that direct users to your application's details page or perform a search for all of your published
+applications on Google Play. You can use these URIs to create a button in your application or a
+link on a web page that:</p>
+
+<ul>
+ <li>Opens your application's details page in the Google Play application or web site.</li>
+ <li>Searches for all your published applications in the Google Play application or web
+site.</li>
+</ul>
+
+<p>You can launch the Google Play application or web site in the following ways:</p>
+<ul>
+ <li>Initiate an {@link android.content.Intent} from your application that launches the
+Google Play application on the user's device.</li>
+ <li>Provide a link on a web page that opens the Google Play web site (but will also
+open the Google Play application if clicked from a device).</li>
+</ul>
+
+<p>In both cases, whether you want to initiate the action from your application or from a web
+page, the URIs are quite similar. The only difference is the URI prefix.</p>
+
+<p>To open the Google Play application from your application, the prefix for the intent's data
+URI is:</p>
+
+<p style="margin-left:2em"><code>market://</code></p>
+
+<p>To open Google Play store from your web site, the prefix for the link URI is:</p>
+
+<p style="margin-left:2em"><code>http://play.google.com/store/</code></p>
+
+<p>The following sections describe how to create a complete URI for each action.</p>
+
+<p class="note"><strong>Note:</strong> If you create a link to open Google Play from your web
+site and the user selects it from an Android-powered device, the device's Google Play application will
+resolve the link so the user can use the Google Play application on the device instead of opening the web
+site. As such, you should always use {@code http://play.google.com/store/apps/...} URIs when
+creating a link on
+a web page. When pointing to your apps from within your Android app, use the
+{@code market://} URIs in an intent, so that the Google Play application always opens.</p>
+
+
+<h3 id="OpeningDetails">Opening an app's details page</h3>
+
+<p>As described above, you can open the details page for a specific application either on the
+Google Play application or the Google Play web site. The details page allows the user to see
+the application description, screenshots, reviews and more, and choose to install it.</p>
+
+<p>The format for the URI that opens the details page is:</p>
+
+<p style="margin-left:2em"><code><URI_prefix><b>apps/details?id=</b><package_name></code></p>
+
+<p>The <code><package_name></code> is a placeholder for the target application's
+fully-qualified package name, as declared in the <a
+href="{@docRoot}guide/topics/manifest/manifest-element.html#package">{@code
+package}</a> attribute of the <a href="{@docRoot}guide/topics/manifest/manifest-element.html">{@code
+<manifest>}</a> element.</p>
+
+<p>For example: <code>http://play.google.com/store/apps/details?id=com.example.myapp</code></p>
+
+
+<h4>Opening the app details page from your Android app</h4>
+
+<p>To open the Google Play details page from your application,
+create an intent with the {@link android.content.Intent#ACTION_VIEW} action and include a data URI
+in this format:</p>
+
+<p style="margin-left:2em"><code>market://details?id=<package_name></code></p>
+
+<p>For example, here's how you can create an intent and open an application's details page in
+Google Play:</p>
+
+<pre>
+Intent intent = new Intent(Intent.ACTION_VIEW);
+intent.setData(Uri.parse("market://details?id=com.example.android"));
+startActivity(intent);
+</pre>
+
+<p>This will open the Google Play application on the device to view the {@code
+com.example.android} application.</p>
+
+
+<h4>Opening the app details page from a web site</h4>
+
+<p>To open the details page from your web site, create a link with a URI in this
+format:</p>
+
+<p style="margin-left:2em">
+ <code>http://play.google.com/store/apps/details?id=<package_name></code>
+</p>
+
+<p>For example, here's a link that opens an application's details page on Google Play:</p>
+
+<pre>
+<a href="http://play.google.com/store/apps/details?id=com.example.android">App Link</a>
+</pre>
+
+<p>When clicked from a desktop web browser, this opens the Google Play web site to view the
+{@code com.example.android} application. When clicked from an Android-powered device, users are
+given the option to use either their web browser or the Google Play application to view the
+application.</p>
+
+
+
+<h3 id="PerformingSearch">Performing a search</h3>
+
+<p>To initiate a search on Google Play, the format for the URI is:</p>
+
+<p style="margin-left:2em">
+ <code><URI_prefix><b>search?q=</b><query></code>
+</p>
+
+<p>The <code><query></code> is a placeholder for the search query to execute in Google
+Play. The query can be a raw text string or you can include a parameter that performs a search
+based on the publisher name:</p>
+
+<ul>
+ <li>To perform a raw text search, append the query string:
+ <p><code><URI_prefix><b>search?q=</b><search_query></code></p></li>
+
+ <li>To search based on the publisher name, use the {@code pub:} parameter in the query, followed
+by the publisher name:
+ <p><code><URI_prefix><b>search?q=pub:</b><publisher_name></code></p>
+ <p>You can use this type of search to show all of your published applications.</p></li>
+</ul>
+
+
+<h4>Searching from your Android app</h4>
+
+<p>To initiate a search on Google Play from your application, create an intent with the
+{@link android.content.Intent#ACTION_VIEW} action and include a data URI in this format:</p>
+
+<p style="margin-left:2em"><code>market://search?q=<query></code></p>
+
+<p>The query may include the {@code pub:} parameter described above.</p>
+
+<p>For example, here's how you can initiate a search in the Google Play application, based on the
+publisher name:</p>
+
+<pre>
+Intent intent = new Intent(Intent.ACTION_VIEW);
+intent.setData(Uri.parse("market://search?q=pub:Your Publisher Name"));
+startActivity(intent);
+</pre>
+
+<p>This opens the Google Play application to perform the search. The search result shows all
+applications published by the publisher that are compatible with the current device.</p>
+
+
+<h4>Searching from a web site</h4>
+
+<p>To initiate a search on Google Play from your web site, create a link with a URI in this
+format:</p>
+
+<p style="margin-left:2em">
+ <code>http://play.google.com/store/search?q=<query></code>
+</p>
+
+<p>The query may include the {@code pub:} parameter described above.</p>
+
+<p>For example, here's a link that initiates a search on Google Play, based on the
+publisher name:</p>
+
+<pre>
+<a href="http://play.google.com/store/search?q=pub:Your Publisher Name">Search Link</a>
+</pre>
+
+<p>When clicked from a desktop web browser, this opens the Google Play web site and performs the
+search. When clicked from an Android-powered device, users are given the option to use either their
+web browser or the Google Play application to perform the search.</p>
+
+
+
+<h3 id="BuildaButton">Build a Google Play button</h3>
+
+<p>Use the following form to create a button for your web site that takes users to your application
+on Google Play. Input either your application's package name or your publisher name and the button
+will take users to Google Play to either view your application's information or view a list of your
+published apps. If users click the button while on an Android-powered device, the Google Play
+application will respond to show users your application(s).</p>
+
+<p>This form offers two styles of the official brand badge each at recommended sizes. You can pick
+between either "Get it on Google Play" or "Android app on Google Play." You should not modify the
+badge images in any way. For more usage guidelines,
+see the <a href="http://www.android.com/branding.html">Android Brand Guidelines</a>.</p>
+
+<style type="text/css">
+
+form.button-form {
+ margin-top:2em;
+}
+
+/* the label and input elements are blocks that float left in order to
+ keep the left edgets of the input aligned, and IE 6/7 do not fully support "inline-block" */
+label.block {
+ display: block;
+ float: left;
+ width: 100px;
+ padding-right: 10px;
+}
+
+input.text {
+ display: block;
+ float: left;
+ width: 250px;
+}
+
+div.button-row {
+ white-space:nowrap;
+ min-height:80px;
+}
+
+div.button-row input {
+ vertical-align:120%;
+}
+
+#jd-content div.button-row img {
+ margin: 0;
+}
+
+</style>
+
+<script type="text/javascript">
+
+// variables for creating 'try it out' demo button
+var imagePath = "http://www.android.com/images/brand/"
+var linkStart = "<a href=\"http://play.google.com/store/";
+var imageStart = "\">\n"
+ + " <img alt=\"";
+ // leaves opening for the alt text value
+var imageSrc = "\"\n src=\"" + imagePath;
+ // leaves opening for the image file name
+var imageEnd = ".png\" />\n</a>";
+
+// variables for creating code snippet
+var linkStartCode = "<a href=\"http://play.google.com/store/";
+var imageStartCode = "\">\n"
+ + " <img alt=\"";
+ // leaves opening for the alt text value
+var imageSrcCode = "\"\n src=\"" + imagePath;
+ // leaves opening for the image file name
+var imageEndCode = ".png\" />\n</a>";
+
+/** Generate the HTML snippet and demo based on form values */
+function buildButton(form) {
+ var selectedValue = $('form input[type=radio]:checked').val();
+ var altText = selectedValue.indexOf("get_it") != -1 ? "Get it on Google Play" : "Android app on Google Play";
+
+ if (form["package"].value != "com.example.android") {
+ $("#preview").show();
+ $("#snippet").show().html(linkStartCode + "apps/details?id=" + form["package"].value
+ + imageStartCode + altText + imageSrcCode
+ + selectedValue + imageEndCode);
+ $("#button-preview").html(linkStart + "apps/details?id=" + form["package"].value
+ + imageStart + altText + imageSrc
+ + selectedValue + imageEnd);
+ } else if (form["publisher"].value != "Example, Inc.") {
+ $("#preview").show();
+ $("#snippet").show().html(linkStartCode + "search?q=pub:" + form["publisher"].value
+ + imageStartCode + altText + imageSrcCode
+ + selectedValue + imageEndCode);
+ $("#button-preview").html(linkStart + "search?q=pub:" + form["publisher"].value
+ + imageStart + altText + imageSrc
+ + selectedValue + imageEnd);
+ } else {
+ alert("Please enter your package name or publisher name");
+ }
+ return false;
+}
+
+/** Listen for Enter key */
+function onTextEntered(event, form, me) {
+ // 13 = enter
+ if (event.keyCode == 13) {
+ buildButton(form);
+ }
+}
+
+/** When input is focused, remove example text and disable other input */
+function onInputFocus(object, example) {
+ if (object.value == example) {
+ $(object).val('').css({'color' : '#000'});
+ }
+ $('input[type="text"]:not(input[name='+object.name+'])',
+ object.parentNode).attr('disabled','true');
+ $('#'+object.name+'-clear').show();
+}
+
+/** When input is blured, restore example text if appropriate and enable other input */
+function onInputBlur(object, example) {
+ if (object.value.length < 1) {
+ $(object).attr('value',example).css({'color':'#ccc'});
+ $('input[type="text"]', object.parentNode).removeAttr('disabled');
+ $('#'+object.name+'-clear').hide();
+ }
+}
+
+/** Clear the form to start over */
+function clearLabel(id, example) {
+ $("#preview").hide();
+ $('#'+id+'').html('').attr('value',example).css({'color':'#ccc'});
+ $('input[type="text"]', $('#'+id+'').parent()).removeAttr('disabled');
+ $('#'+id+'-clear').hide();
+ return false;
+}
+
+/** When the doc is ready, find the inputs and color the input grey if the value is the example
+ text. This is necessary to handle back-navigation, which can auto-fill the form with previous
+ values (and text should not be grey) */
+$(document).ready(function() {
+ $(".button-form input.text").each(function(index) {
+ if ($(this).val() == $(this).attr("default")) {
+ $(this).css("color","#ccc");
+ } else {
+ /* This is necessary to handle back-navigation to the page after form was filled */
+ $('input[type="text"]:not(input[name='+this.name+'])',
+ this.parentNode).attr('disabled','true');
+ $('#'+this.name+'-clear').show();
+ }
+ });
+});
+
+</script>
+
+<form class="button-form">
+ <label class="block" for="package">Package name:</label>
+ <input class="text" type="text" id="package" name="package"
+ value="com.example.android"
+ default="com.example.android"
+ onfocus="onInputFocus(this, 'com.example.android')"
+ onblur="onInputBlur(this, 'com.example.android')"
+ onkeyup="return onTextEntered(event, this.parentNode, this)"/>
+ <a id="package-clear" style="display:none" href="#"
+ onclick="return clearLabel('package','com.example.android');">clear</a>
+ <p style="clear:both;margin:0"> <em>or</em></p>
+ <label class="block" style="margin-top:5px" for="publisher">Publisher name:</label>
+ <input class="text" type="text" id="publisher" name="publisher"
+ value="Example, Inc."
+ default="Example, Inc."
+ onfocus="onInputFocus(this, 'Example, Inc.')"
+ onblur="onInputBlur(this, 'Example, Inc.')"
+ onkeyup="return onTextEntered(event, this.parentNode, this)"/>
+ <a id="publisher-clear" style="display:none" href="#"
+ onclick="return clearLabel('publisher','Example, Inc.');">clear</a>
+ <br/><br/>
+
+<div class="button-row">
+ <input type="radio" name="buttonStyle" value="get_it_on_play_logo_small" id="ns" checked="checked" />
+ <label for="ns"><img src="http://www.android.com/images/brand/get_it_on_play_logo_small.png"
+alt="Get it on Google Play (small)" /></label>
+
+ <input type="radio" name="buttonStyle" value="get_it_on_play_logo_large" id="nm" />
+ <label for="nm"><img src="http://www.android.com/images/brand/get_it_on_play_logo_large.png"
+alt="Get it on Google Play (large)" /></label>
+</div>
+
+<div class="button-row">
+ <input type="radio" name="buttonStyle" value="android_app_on_play_logo_small" id="ws" />
+ <label for="ws"><img src="http://www.android.com/images/brand/android_app_on_play_logo_small.png"
+alt="Android app on Google Play (small)" /></label>
+
+ <input type="radio" name="buttonStyle" value="android_app_on_play_logo_large" id="wm" />
+ <label for="wm"><img src="http://www.android.com/images/brand/android_app_on_play_logo_large.png"
+alt="Android app on Google Play (large)" /></label>
+</div>
+
+ <input type="button" onclick="return buildButton(this.parentNode)" value="Build my button"
+style="padding:5px" />
+ <br/>
+</form>
+
+<div id="preview" style="display:none">
+ <p>Copy and paste this HTML into your web site:</p>
+ <textarea id="snippet" cols="100" rows="5" onclick="this.select()"
+style="font-family:monospace;background-color:#efefef;padding:5px;display:none;margin-bottom:1em">
+ </textarea >
+
+<p>Try it out:</p>
+<div id="button-preview" style="margin-top:1em"></div>
+</div>
+
+
+
+
+
+
+<h3 id="UriSummary">Summary of URI formats</h3>
+
+<p>The table below provides a summary of the URIs currently supported by the Google Play (both on
+the web and in the Android application), as discussed in the previous sections.</p>
+
+<table>
+<tr>
+<th>For this result</th>
+<th>Use this URI in a web page link</th>
+<th>Or this URI in an {@link android.content.Intent#ACTION_VIEW} intent</th>
+</tr>
+
+<tr>
+<td>Display the details screen for a specific application</td>
+<td><code>http://play.google.com/store/apps/details?id=<package_name></code>
+<td><code>market://details?id=<package_name></code></td>
+</tr>
+
+<tr>
+<td>Search for applications using a general string query.</td>
+<td><code>http://play.google.com/store/search?q=<query></code></td>
+<td><code>market://search?q=<query></code></td>
+</tr>
+
+<tr>
+<td>Search for applications by publisher name</td>
+<td><nobr><code>http://play.google.com/store/search?q=pub:<publisher_name></code></nobr></td>
+<td><nobr><code>market://search?q=pub:<publisher_name></code></nobr></td>
+</tr>
+
+</table>
diff --git a/docs/html/tools/workflow/publishing/publishing_overview.jd b/docs/html/tools/workflow/publishing/publishing_overview.jd
new file mode 100755
index 0000000..ca0dca8
--- /dev/null
+++ b/docs/html/tools/workflow/publishing/publishing_overview.jd
@@ -0,0 +1,231 @@
+page.title=Publishing Overview
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>Quickview</h2>
+ <ul>
+ <li>Learn how to publish Android apps.</li>
+ <li>Find out how to prepare apps for release.</li>
+ <li>Learn how to release apps to users.</li>
+ </ul>
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#publishing-prepare">Preparing Your Application for Release</a></li>
+ <li><a href="#publishing-release">Releasing Your Application to Users</a>
+ <ol>
+ <li><a href="#publishing-market">Releasing on Google Play</a></li>
+ <li><a href="#publishing-website">Releasing on your own website</a></li>
+ <li><a href="#publishing-email">Releasing through email</a></li>
+ </ol>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/publishing/preparing.html">Preparing for
+ Release</a></li>
+ <li><a href="{@docRoot}tools/publishing/publishing.html">Publishing on Google Play</a></li>
+ </ol>
+</div>
+</div>
+
+<p>Publishing is the process that makes your Android applications available to users. When you
+publish an Android application you perform two main tasks:</p>
+
+<ul>
+ <li>You prepare the application for release.
+ <p>During the preparation step you build a release version of your application, which users can
+ download and install on their Android-powered devices.</p>
+ </li>
+ <li>You release the application to users.
+ <p>During the release step you publicize, sell, and distribute the release version of your
+ application to users.</p>
+ </li>
+</ul>
+
+<p>Usually, you release your application through an application marketplace, such as Google Play.
+However, you can also release applications by sending them directly to users or by letting users
+download them from your own website.</p>
+
+<p>Figure 1 shows how the publishing process fits into the overall Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+The publishing process is typically performed after you finish testing your application in a debug
+environment. Also, as a best practice, your application should meet all of your release criteria for
+functionality, performance, and stability before you begin the publishing process.</p>
+
+<img src="{@docRoot}images/publishing/publishing_overview.png" alt="Shows where the publishing
+ process fits into the overall development process" height="86" id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> Publishing is the last phase of the Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+</p>
+
+<h2 id="publishing-prepare">Preparing Your Application for Release</h2>
+
+<p>Preparing your application for release is a multi-step process that involves the following
+tasks:</p>
+
+<ul>
+
+ <li>Configuring your application for release.
+ <p>At a minimum you need to remove {@link android.util.Log} calls and remove the
+ <a href="{@docRoot}guide/topics/manifest/application-element.html#debug">android:debuggable</a>
+ attribute from your manifest file. You should also provide values for the
+ <code>android:versionCode</code> and <code>android:versionName</code> attributes, which are
+ located in the
+ <a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a>
+ element. You may also have to configure several other settings to meet Google Play
+ requirements or accomodate whatever method you're using to release your application.</p>
+ </li>
+ <li>Building and signing a release version of your application.
+ <p>The Android Development Tools (ADT) plugin and the Ant build script that are provided
+ with the Android SDK tools provide everything you need to build and sign a release version of
+ your application.</p>
+ </li>
+ <li>Testing the release version of your application.
+ <p>Before you distribute your application, you should thoroughly test the release version on at
+ least one target handset device and one target tablet device.</p>
+ </li>
+ <li>Updating application resources for release.
+ <p>You need to be sure that all application resources such as multimedia files and graphics
+ are updated and included with your application or staged on the proper production servers.</p>
+ </li>
+ <li>Preparing remote servers and services that your application depends on.
+ <p>If your application depends on external servers or services, you need to be sure they
+ are secure and production ready.</p>
+ </li>
+</ul>
+
+<p>You may have to perform several other tasks as part of the preparation process. For example, you
+will need to get a private key for signing your application, and you may need to get a Maps API
+release key if you are using the <a
+href="http://code.google.com/android/add-ons/google-apis/maps-overview.html">Google Maps external
+library</a>. You will also need to create an icon for your application, and you may want to prepare
+an End User License Agreement (EULA) to protect your person, organization, and intellectual
+property.</p>
+
+<p>When you are finished preparing your application for release you will have a signed
+<code>.apk</code> file that you can distribute to users.</p>
+
+<p>To learn how to prepare your application for release, see <a
+href="{@docRoot}tools/publishing/preparing.html">Preparing for Release</a> in the Dev Guide. This
+topic provides step-by-step instructions for configuring and building a release version of your
+application.</p>
+
+<h2 id="publishing-release">Releasing Your Application to Users</h2>
+
+<p>You can release your Android applications several ways. Usually, you release applications
+through an application marketplace, such as Google Play, but you can also release applications
+on your own website or by sending an application directly to a user. Google Play is the
+recommended marketplace for Android applications and is particularly useful if you want to
+distribute your applications to a large global audience. The other two release methods—server
+distribution and email distribution—are useful if you are releasing an application to a small
+group of users (for example, a work group in an enterprise environment), or if you do not want to
+make your application available to the general public.</p>
+
+<h3 id="publishing-market">Releasing Your Applications on Google Play</h3>
+
+<p>Google Play is a robust publishing platform that helps you publicize, sell, and distribute
+your Android applications to users around the world. When you release your applications through
+Google Play you have access to a suite of developer tools that let you analyze your sales,
+identify market trends, and control who your applications are being distributed to. You also have
+access to several revenue-enhancing features that are not available anywhere else, such as <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> and <a
+href="{@docRoot}guide/google/play/licensing.html">application licensing</a>. This rich array of tools
+and features, coupled with numerous end-user community features, makes Google Play the premier
+marketplace for selling and buying Android applications.</p>
+
+<p>Releasing your application on Google Play is a simple process that involves three basic
+ steps:</p>
+
+<div class="figure" style="width:275px">
+ <img src="{@docRoot}images/publishing/publishing_unknown_sources.png"
+ alt="Screenshot showing the graphical user interface element that allows unknown sources
+ to be installed" />
+ <p class="img-caption">
+ <strong>Figure 2.</strong> The <strong>Unknown sources</strong> setting lets you install
+ applications that are not published on Google Play .
+ </p>
+</div>
+
+<ul>
+ <li>Preparing promotional materials.
+ <p>To fully leverage the marketing and publicity capabilities of Google Play, you need to
+ create promotional materials for your application, such as screenshots, videos, graphics, and
+ promotional text.</p>
+ </li>
+ <li>Configuring options and uploading assets.
+ <p>Google Play lets you target your application to a worldwide pool of users and devices.
+ By configuring various Google Play settings, you can choose the countries you want to
+ reach, the listing languages you want to use, and the price you want to charge in each
+ country. You can also configure listing details such as the application type, category, and
+ content rating. When you are done configuring options you can upload your promotional materials
+ and your application as a draft (unpublished) application.</p>
+ </li>
+ <li>Publishing the release version of your application.
+ <p>If you are satisfied that your publishing settings are correctly configured and your
+ uploaded application is ready to be released to the public, you can simply click
+ <strong>Publish</strong > in the developer console and within minutes your application will be
+ live and available for download around the world.</p>
+ </li>
+</ul>
+
+<p>For information about Google Play, see <a
+href="{@docRoot}tools/publishing/publishing.html#market">Publishing on Google Play</a>. This
+topic provides an introduction to Google Play features and provides a step-by-step guide for
+distributing your applications on Google Play.</p>
+
+<h3 id="publishing-website">Releasing your application on your own website</h3>
+
+<p>If you do not want to release your application on an application marketplace like Google Play,
+you can release your application by making it available for download on your own website or server.
+To do this, you must first prepare your application for release (that is, you must build it for
+release and sign it). Then all you need to do is host the release-ready application on your website
+and provide a download link for the application. When users browse to your website with their
+Android-powered devices and download your application, the Android system will automatically start
+installing the application on the device. However, the installation process will start automatically
+only if the user has configured their device to allow the installation of non-Google Play
+applications.</p>
+
+<div class="figure" style="width:275px">
+ <img src="{@docRoot}images/publishing/publishing_via_email.png"
+ alt="Screenshot showing the graphical user interface users see when you send them an app"
+ height="453" />
+ <p class="img-caption">
+ <strong>Figure 3.</strong> Users can simply click <strong>Install</strong> when you send them
+ an application via email.
+ </p>
+</div>
+
+<p>By default, Android-powered devices allow users to install applications only if the applications
+have been downloaded from Google Play. To allow the installation of applications from other
+sources, users need to enable the <strong>Unknown sources</strong> setting on their devices, and
+they need to make this configuration change before they download your application to their
+device (see figure 2).</p>
+
+<p class="note"><strong>Note:</strong> Some network providers do not allow users to install
+applications from unknown sources.</p>
+
+<p>Although it is relatively easy to release your application on your own website, it can be
+inefficient and cumbersome. For example, if you want to monetize your application you will
+have to process and track all financial transactions yourself and you will not be able to use
+Google Play's in-app billing feature to sell in-app products. In addition, you will not be
+able to use the licensing feature to help prevent unauthorized installation and use of your
+application.</p>
+
+<h3 id="publishing-email">Releasing your application through email</h3>
+
+<p>The easiest and quickest way to release your application is to send it to a user through
+email. To do this, you prepare your application for release and then attach it to an email
+and send it to a user. When the user opens your email message on their Android-powered device
+the Android system will recognize the <code>.apk</code> and display an <strong>Install Now</strong>
+button in the email message (see figure 3). Users can install your application by touching the
+button.</p>
+
+<p class="note"><strong>Note:</strong> The <strong>Install Now</strong> button appears only if a
+user has configured their device to allow the installation of non-Google Play applications and
+they open your email with the native Gmail application.</p>
+
+<p>Releasing applications through email is convenient if you are sending your application to
+only a few trusted users, but it provides few protections from piracy and unauthorized
+distribution; that is, anyone you send your application to can simply forward it to someone else.
+else.
diff --git a/docs/html/tools/workflow/publishing/versioning.jd b/docs/html/tools/workflow/publishing/versioning.jd
new file mode 100644
index 0000000..e0b4435
--- /dev/null
+++ b/docs/html/tools/workflow/publishing/versioning.jd
@@ -0,0 +1,174 @@
+page.title=Versioning Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>Your application <em>must</em> be versioned</a></li>
+<li>You set the version in the application's manifest file</li>
+<li>How you version your applications affects how users upgrade </li>
+<li>Determine your versioning strategy early in the development process, including considerations for future releases.</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#appversioning">Setting Application Version</a></li>
+<li><a href="#minsdkversion">Specifying Your Application's System API Requirements</a>
+</ol>
+
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish Your Application</a></li>
+<li><a href="{@docRoot}tools/publishing/publishing.html#market">Publishing On Google Play</a></li>
+<li><a href="{@docRoot}guide/topics/manifest/manifest-intro.html">The AndroidManifest.xml File</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>Versioning is a critical component of your application upgrade and maintenance
+strategy. Versioning is important because:</p>
+
+<ul>
+<li>Users need to have specific information about the application version that
+is installed on their devices and the upgrade versions available for
+installation. </li>
+<li>Other applications — including other applications that you publish as
+a suite — need to query the system for your application's version, to
+determine compatibility and identify dependencies.</li>
+<li>Services through which you will publish your application(s) may also need to
+query your application for its version, so that they can display the version to
+users. A publishing service may also need to check the application version to
+determine compatibility and establish upgrade/downgrade relationships.</li>
+</ul>
+
+<p>The Android system does not use app version information to enforce
+restrictions on upgrades, downgrades, or compatibility of third-party apps. Instead, you (the
+developer) are responsible for enforcing version restrictions within your application or by
+informing users of the version restrictions and limitations. The Android system does, however,
+enforce system version compatibility as expressed by the <code>minSdkVersion</code> attribute in the
+manifest. This attribute allows an application to specify the minimum system API with which it is
+compatible. For more information see <a href="#minsdkversion">Specifying Minimum System API
+Version</a>.</p>
+
+<h2 id="appversioning">Setting Application Version</h2>
+<p>To define the version information for your application, you set attributes in
+the application's manifest file. Two attributes are available, and you should
+always define values for both of them: </p>
+
+<ul>
+<li><code>android:versionCode</code> — An integer value that represents
+the version of the application code, relative to other versions.
+
+<p>The value is an integer so that other applications can programmatically
+evaluate it, for example to check an upgrade or downgrade relationship. You can
+set the value to any integer you want, however you should make sure that each
+successive release of your application uses a greater value. The system does not
+enforce this behavior, but increasing the value with successive releases is
+normative. </p>
+
+<p>Typically, you would release the first version of your application with
+versionCode set to 1, then monotonically increase the value with each release,
+regardless whether the release constitutes a major or minor release. This means
+that the <code>android:versionCode</code> value does not necessarily have a
+strong resemblance to the application release version that is visible to the
+user (see <code>android:versionName</code>, below). Applications and publishing
+services should not display this version value to users.</p>
+</li>
+<li><code>android:versionName</code> — A string value that represents the
+release version of the application code, as it should be shown to users.
+<p>The value is a string so that you can describe the application version as a
+<major>.<minor>.<point> string, or as any other type of
+absolute or relative version identifier. </p>
+
+<p>As with <code>android:versionCode</code>, the system does not use this value
+for any internal purpose, other than to enable applications to display it to
+users. Publishing services may also extract the <code>android:versionName</code>
+value for display to users.</p>
+</li>
+</ul>
+
+<p>You define both of these version attributes in the
+<code><manifest></code> element of the manifest file. </p>
+
+<p>Here's an example manifest that shows the <code>android:versionCode</code>
+and <code>android:versionName</code> attributes in the
+<code><manifest></code> element. </p>
+
+<pre>
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.example.package.name"
+ android:versionCode="2"
+ android:versionName="1.1">
+ <application android:icon="@drawable/icon" android:label="@string/app_name">
+ ...
+ </application>
+</manifest>
+</pre>
+
+<p>In this example, note that <code>android:versionCode</code> value indicates
+that the current .apk contains the second release of the application code, which
+corresponds to a minor follow-on release, as shown by the
+<code>android:versionName</code> string. </p>
+
+<p>The Android framework provides an API to let applications query the system
+for version information about your application. To obtain version information,
+applications use the
+{@link android.content.pm.PackageManager#getPackageInfo(java.lang.String, int)}
+method of {@link android.content.pm.PackageManager PackageManager}. </p>
+
+<h2 id="minsdkversion">Specifying Your Application's System API Requirements</h2>
+
+<p>If your application requires a specific minimum version of the Android
+platform, or is designed only to support a certain range of Android platform
+versions, you can specify those version requirements as API Level identifiers
+in the application's manifest file. Doing so ensures that your
+application can only be installed on devices that
+are running a compatible version of the Android system. </p>
+
+<p>To specify API Level requirements, add a <code><uses-sdk></code>
+element in the application's manifest, with one or more of these attributes: </p>
+
+<ul>
+<li><code>android:minSdkVersion</code> — The minimum version
+of the Android platform on which the application will run, specified
+by the platform's API Level identifier. </li>
+<li><code>android:targetSdkVersion</code> — Specifies the API Level
+on which the application is designed to run. In some cases, this allows the
+application to use manifest elements or behaviors defined in the target
+API Level, rather than being restricted to using only those defined
+for the minimum API Level.</li>
+<li><code>android:maxSdkVersion</code> — The maximum version
+of the Android platform on which the application is designed to run,
+specified by the platform's API Level identifier. <strong>Important:</strong> Please read the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+documentation before using this attribute. </li>
+</ul>
+
+<p>When preparing to install your application, the system checks the value of this
+attribute and compares it to the system version. If the
+<code>android:minSdkVersion</code> value is greater than the system version, the
+system aborts the installation of the application. Similarly, the system
+installs your application only if its <code>android:maxSdkVersion</code>
+is compatible with the platform version.</p>
+
+<p>If you do not specify these attributes in your manifest, the system assumes
+that your application is compatible with all platform versions, with no
+maximum API Level. </p>
+
+<p>To specify a minimum platform version for your application, add a
+<code><uses-sdk></code> element as a child of
+<code><manifest></code>, then define the
+<code>android:minSdkVersion</code> as an attribute. </p>
+
+<p>For more information, see the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+manifest element documentation and the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Levels</a> document.</p>
diff --git a/docs/html/tools/workflow/publishing_overview.jd b/docs/html/tools/workflow/publishing_overview.jd
new file mode 100755
index 0000000..ca0dca8
--- /dev/null
+++ b/docs/html/tools/workflow/publishing_overview.jd
@@ -0,0 +1,231 @@
+page.title=Publishing Overview
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+ <h2>Quickview</h2>
+ <ul>
+ <li>Learn how to publish Android apps.</li>
+ <li>Find out how to prepare apps for release.</li>
+ <li>Learn how to release apps to users.</li>
+ </ul>
+ <h2>In this document</h2>
+ <ol>
+ <li><a href="#publishing-prepare">Preparing Your Application for Release</a></li>
+ <li><a href="#publishing-release">Releasing Your Application to Users</a>
+ <ol>
+ <li><a href="#publishing-market">Releasing on Google Play</a></li>
+ <li><a href="#publishing-website">Releasing on your own website</a></li>
+ <li><a href="#publishing-email">Releasing through email</a></li>
+ </ol>
+ </ol>
+ <h2>See also</h2>
+ <ol>
+ <li><a href="{@docRoot}tools/publishing/preparing.html">Preparing for
+ Release</a></li>
+ <li><a href="{@docRoot}tools/publishing/publishing.html">Publishing on Google Play</a></li>
+ </ol>
+</div>
+</div>
+
+<p>Publishing is the process that makes your Android applications available to users. When you
+publish an Android application you perform two main tasks:</p>
+
+<ul>
+ <li>You prepare the application for release.
+ <p>During the preparation step you build a release version of your application, which users can
+ download and install on their Android-powered devices.</p>
+ </li>
+ <li>You release the application to users.
+ <p>During the release step you publicize, sell, and distribute the release version of your
+ application to users.</p>
+ </li>
+</ul>
+
+<p>Usually, you release your application through an application marketplace, such as Google Play.
+However, you can also release applications by sending them directly to users or by letting users
+download them from your own website.</p>
+
+<p>Figure 1 shows how the publishing process fits into the overall Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+The publishing process is typically performed after you finish testing your application in a debug
+environment. Also, as a best practice, your application should meet all of your release criteria for
+functionality, performance, and stability before you begin the publishing process.</p>
+
+<img src="{@docRoot}images/publishing/publishing_overview.png" alt="Shows where the publishing
+ process fits into the overall development process" height="86" id="figure1" />
+<p class="img-caption">
+ <strong>Figure 1.</strong> Publishing is the last phase of the Android <a
+href="{@docRoot}tools/workflow/index.html">application development process</a>.
+</p>
+
+<h2 id="publishing-prepare">Preparing Your Application for Release</h2>
+
+<p>Preparing your application for release is a multi-step process that involves the following
+tasks:</p>
+
+<ul>
+
+ <li>Configuring your application for release.
+ <p>At a minimum you need to remove {@link android.util.Log} calls and remove the
+ <a href="{@docRoot}guide/topics/manifest/application-element.html#debug">android:debuggable</a>
+ attribute from your manifest file. You should also provide values for the
+ <code>android:versionCode</code> and <code>android:versionName</code> attributes, which are
+ located in the
+ <a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a>
+ element. You may also have to configure several other settings to meet Google Play
+ requirements or accomodate whatever method you're using to release your application.</p>
+ </li>
+ <li>Building and signing a release version of your application.
+ <p>The Android Development Tools (ADT) plugin and the Ant build script that are provided
+ with the Android SDK tools provide everything you need to build and sign a release version of
+ your application.</p>
+ </li>
+ <li>Testing the release version of your application.
+ <p>Before you distribute your application, you should thoroughly test the release version on at
+ least one target handset device and one target tablet device.</p>
+ </li>
+ <li>Updating application resources for release.
+ <p>You need to be sure that all application resources such as multimedia files and graphics
+ are updated and included with your application or staged on the proper production servers.</p>
+ </li>
+ <li>Preparing remote servers and services that your application depends on.
+ <p>If your application depends on external servers or services, you need to be sure they
+ are secure and production ready.</p>
+ </li>
+</ul>
+
+<p>You may have to perform several other tasks as part of the preparation process. For example, you
+will need to get a private key for signing your application, and you may need to get a Maps API
+release key if you are using the <a
+href="http://code.google.com/android/add-ons/google-apis/maps-overview.html">Google Maps external
+library</a>. You will also need to create an icon for your application, and you may want to prepare
+an End User License Agreement (EULA) to protect your person, organization, and intellectual
+property.</p>
+
+<p>When you are finished preparing your application for release you will have a signed
+<code>.apk</code> file that you can distribute to users.</p>
+
+<p>To learn how to prepare your application for release, see <a
+href="{@docRoot}tools/publishing/preparing.html">Preparing for Release</a> in the Dev Guide. This
+topic provides step-by-step instructions for configuring and building a release version of your
+application.</p>
+
+<h2 id="publishing-release">Releasing Your Application to Users</h2>
+
+<p>You can release your Android applications several ways. Usually, you release applications
+through an application marketplace, such as Google Play, but you can also release applications
+on your own website or by sending an application directly to a user. Google Play is the
+recommended marketplace for Android applications and is particularly useful if you want to
+distribute your applications to a large global audience. The other two release methods—server
+distribution and email distribution—are useful if you are releasing an application to a small
+group of users (for example, a work group in an enterprise environment), or if you do not want to
+make your application available to the general public.</p>
+
+<h3 id="publishing-market">Releasing Your Applications on Google Play</h3>
+
+<p>Google Play is a robust publishing platform that helps you publicize, sell, and distribute
+your Android applications to users around the world. When you release your applications through
+Google Play you have access to a suite of developer tools that let you analyze your sales,
+identify market trends, and control who your applications are being distributed to. You also have
+access to several revenue-enhancing features that are not available anywhere else, such as <a
+href="{@docRoot}guide/google/play/billing/index.html">in-app billing</a> and <a
+href="{@docRoot}guide/google/play/licensing.html">application licensing</a>. This rich array of tools
+and features, coupled with numerous end-user community features, makes Google Play the premier
+marketplace for selling and buying Android applications.</p>
+
+<p>Releasing your application on Google Play is a simple process that involves three basic
+ steps:</p>
+
+<div class="figure" style="width:275px">
+ <img src="{@docRoot}images/publishing/publishing_unknown_sources.png"
+ alt="Screenshot showing the graphical user interface element that allows unknown sources
+ to be installed" />
+ <p class="img-caption">
+ <strong>Figure 2.</strong> The <strong>Unknown sources</strong> setting lets you install
+ applications that are not published on Google Play .
+ </p>
+</div>
+
+<ul>
+ <li>Preparing promotional materials.
+ <p>To fully leverage the marketing and publicity capabilities of Google Play, you need to
+ create promotional materials for your application, such as screenshots, videos, graphics, and
+ promotional text.</p>
+ </li>
+ <li>Configuring options and uploading assets.
+ <p>Google Play lets you target your application to a worldwide pool of users and devices.
+ By configuring various Google Play settings, you can choose the countries you want to
+ reach, the listing languages you want to use, and the price you want to charge in each
+ country. You can also configure listing details such as the application type, category, and
+ content rating. When you are done configuring options you can upload your promotional materials
+ and your application as a draft (unpublished) application.</p>
+ </li>
+ <li>Publishing the release version of your application.
+ <p>If you are satisfied that your publishing settings are correctly configured and your
+ uploaded application is ready to be released to the public, you can simply click
+ <strong>Publish</strong > in the developer console and within minutes your application will be
+ live and available for download around the world.</p>
+ </li>
+</ul>
+
+<p>For information about Google Play, see <a
+href="{@docRoot}tools/publishing/publishing.html#market">Publishing on Google Play</a>. This
+topic provides an introduction to Google Play features and provides a step-by-step guide for
+distributing your applications on Google Play.</p>
+
+<h3 id="publishing-website">Releasing your application on your own website</h3>
+
+<p>If you do not want to release your application on an application marketplace like Google Play,
+you can release your application by making it available for download on your own website or server.
+To do this, you must first prepare your application for release (that is, you must build it for
+release and sign it). Then all you need to do is host the release-ready application on your website
+and provide a download link for the application. When users browse to your website with their
+Android-powered devices and download your application, the Android system will automatically start
+installing the application on the device. However, the installation process will start automatically
+only if the user has configured their device to allow the installation of non-Google Play
+applications.</p>
+
+<div class="figure" style="width:275px">
+ <img src="{@docRoot}images/publishing/publishing_via_email.png"
+ alt="Screenshot showing the graphical user interface users see when you send them an app"
+ height="453" />
+ <p class="img-caption">
+ <strong>Figure 3.</strong> Users can simply click <strong>Install</strong> when you send them
+ an application via email.
+ </p>
+</div>
+
+<p>By default, Android-powered devices allow users to install applications only if the applications
+have been downloaded from Google Play. To allow the installation of applications from other
+sources, users need to enable the <strong>Unknown sources</strong> setting on their devices, and
+they need to make this configuration change before they download your application to their
+device (see figure 2).</p>
+
+<p class="note"><strong>Note:</strong> Some network providers do not allow users to install
+applications from unknown sources.</p>
+
+<p>Although it is relatively easy to release your application on your own website, it can be
+inefficient and cumbersome. For example, if you want to monetize your application you will
+have to process and track all financial transactions yourself and you will not be able to use
+Google Play's in-app billing feature to sell in-app products. In addition, you will not be
+able to use the licensing feature to help prevent unauthorized installation and use of your
+application.</p>
+
+<h3 id="publishing-email">Releasing your application through email</h3>
+
+<p>The easiest and quickest way to release your application is to send it to a user through
+email. To do this, you prepare your application for release and then attach it to an email
+and send it to a user. When the user opens your email message on their Android-powered device
+the Android system will recognize the <code>.apk</code> and display an <strong>Install Now</strong>
+button in the email message (see figure 3). Users can install your application by touching the
+button.</p>
+
+<p class="note"><strong>Note:</strong> The <strong>Install Now</strong> button appears only if a
+user has configured their device to allow the installation of non-Google Play applications and
+they open your email with the native Gmail application.</p>
+
+<p>Releasing applications through email is convenient if you are sending your application to
+only a few trusted users, but it provides few protections from piracy and unauthorized
+distribution; that is, anyone you send your application to can simply forward it to someone else.
+else.
diff --git a/docs/html/tools/workflow/versioning.jd b/docs/html/tools/workflow/versioning.jd
new file mode 100644
index 0000000..e0b4435
--- /dev/null
+++ b/docs/html/tools/workflow/versioning.jd
@@ -0,0 +1,174 @@
+page.title=Versioning Your Applications
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+<h2>Quickview</h2>
+
+<ul>
+<li>Your application <em>must</em> be versioned</a></li>
+<li>You set the version in the application's manifest file</li>
+<li>How you version your applications affects how users upgrade </li>
+<li>Determine your versioning strategy early in the development process, including considerations for future releases.</li>
+</ul>
+
+<h2>In this document</h2>
+
+<ol>
+<li><a href="#appversioning">Setting Application Version</a></li>
+<li><a href="#minsdkversion">Specifying Your Application's System API Requirements</a>
+</ol>
+
+
+<h2>See also</h2>
+
+<ol>
+<li><a href="{@docRoot}tools/publishing/preparing.html">Preparing to Publish Your Application</a></li>
+<li><a href="{@docRoot}tools/publishing/publishing.html#market">Publishing On Google Play</a></li>
+<li><a href="{@docRoot}guide/topics/manifest/manifest-intro.html">The AndroidManifest.xml File</a></li>
+</ol>
+
+</div>
+</div>
+
+<p>Versioning is a critical component of your application upgrade and maintenance
+strategy. Versioning is important because:</p>
+
+<ul>
+<li>Users need to have specific information about the application version that
+is installed on their devices and the upgrade versions available for
+installation. </li>
+<li>Other applications — including other applications that you publish as
+a suite — need to query the system for your application's version, to
+determine compatibility and identify dependencies.</li>
+<li>Services through which you will publish your application(s) may also need to
+query your application for its version, so that they can display the version to
+users. A publishing service may also need to check the application version to
+determine compatibility and establish upgrade/downgrade relationships.</li>
+</ul>
+
+<p>The Android system does not use app version information to enforce
+restrictions on upgrades, downgrades, or compatibility of third-party apps. Instead, you (the
+developer) are responsible for enforcing version restrictions within your application or by
+informing users of the version restrictions and limitations. The Android system does, however,
+enforce system version compatibility as expressed by the <code>minSdkVersion</code> attribute in the
+manifest. This attribute allows an application to specify the minimum system API with which it is
+compatible. For more information see <a href="#minsdkversion">Specifying Minimum System API
+Version</a>.</p>
+
+<h2 id="appversioning">Setting Application Version</h2>
+<p>To define the version information for your application, you set attributes in
+the application's manifest file. Two attributes are available, and you should
+always define values for both of them: </p>
+
+<ul>
+<li><code>android:versionCode</code> — An integer value that represents
+the version of the application code, relative to other versions.
+
+<p>The value is an integer so that other applications can programmatically
+evaluate it, for example to check an upgrade or downgrade relationship. You can
+set the value to any integer you want, however you should make sure that each
+successive release of your application uses a greater value. The system does not
+enforce this behavior, but increasing the value with successive releases is
+normative. </p>
+
+<p>Typically, you would release the first version of your application with
+versionCode set to 1, then monotonically increase the value with each release,
+regardless whether the release constitutes a major or minor release. This means
+that the <code>android:versionCode</code> value does not necessarily have a
+strong resemblance to the application release version that is visible to the
+user (see <code>android:versionName</code>, below). Applications and publishing
+services should not display this version value to users.</p>
+</li>
+<li><code>android:versionName</code> — A string value that represents the
+release version of the application code, as it should be shown to users.
+<p>The value is a string so that you can describe the application version as a
+<major>.<minor>.<point> string, or as any other type of
+absolute or relative version identifier. </p>
+
+<p>As with <code>android:versionCode</code>, the system does not use this value
+for any internal purpose, other than to enable applications to display it to
+users. Publishing services may also extract the <code>android:versionName</code>
+value for display to users.</p>
+</li>
+</ul>
+
+<p>You define both of these version attributes in the
+<code><manifest></code> element of the manifest file. </p>
+
+<p>Here's an example manifest that shows the <code>android:versionCode</code>
+and <code>android:versionName</code> attributes in the
+<code><manifest></code> element. </p>
+
+<pre>
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.example.package.name"
+ android:versionCode="2"
+ android:versionName="1.1">
+ <application android:icon="@drawable/icon" android:label="@string/app_name">
+ ...
+ </application>
+</manifest>
+</pre>
+
+<p>In this example, note that <code>android:versionCode</code> value indicates
+that the current .apk contains the second release of the application code, which
+corresponds to a minor follow-on release, as shown by the
+<code>android:versionName</code> string. </p>
+
+<p>The Android framework provides an API to let applications query the system
+for version information about your application. To obtain version information,
+applications use the
+{@link android.content.pm.PackageManager#getPackageInfo(java.lang.String, int)}
+method of {@link android.content.pm.PackageManager PackageManager}. </p>
+
+<h2 id="minsdkversion">Specifying Your Application's System API Requirements</h2>
+
+<p>If your application requires a specific minimum version of the Android
+platform, or is designed only to support a certain range of Android platform
+versions, you can specify those version requirements as API Level identifiers
+in the application's manifest file. Doing so ensures that your
+application can only be installed on devices that
+are running a compatible version of the Android system. </p>
+
+<p>To specify API Level requirements, add a <code><uses-sdk></code>
+element in the application's manifest, with one or more of these attributes: </p>
+
+<ul>
+<li><code>android:minSdkVersion</code> — The minimum version
+of the Android platform on which the application will run, specified
+by the platform's API Level identifier. </li>
+<li><code>android:targetSdkVersion</code> — Specifies the API Level
+on which the application is designed to run. In some cases, this allows the
+application to use manifest elements or behaviors defined in the target
+API Level, rather than being restricted to using only those defined
+for the minimum API Level.</li>
+<li><code>android:maxSdkVersion</code> — The maximum version
+of the Android platform on which the application is designed to run,
+specified by the platform's API Level identifier. <strong>Important:</strong> Please read the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+documentation before using this attribute. </li>
+</ul>
+
+<p>When preparing to install your application, the system checks the value of this
+attribute and compares it to the system version. If the
+<code>android:minSdkVersion</code> value is greater than the system version, the
+system aborts the installation of the application. Similarly, the system
+installs your application only if its <code>android:maxSdkVersion</code>
+is compatible with the platform version.</p>
+
+<p>If you do not specify these attributes in your manifest, the system assumes
+that your application is compatible with all platform versions, with no
+maximum API Level. </p>
+
+<p>To specify a minimum platform version for your application, add a
+<code><uses-sdk></code> element as a child of
+<code><manifest></code>, then define the
+<code>android:minSdkVersion</code> as an attribute. </p>
+
+<p>For more information, see the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html"><code><uses-sdk></code></a>
+manifest element documentation and the <a
+href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#ApiLevels">API Levels</a> document.</p>
