Doc change: updating ndk download and overview page

Change-Id: Icbd578958d7a20c19f60827988a8893785b40851

2 files changed, 308 insertions, 295 deletions

diff --git a/docs/html/sdk/ndk/index.jd b/docs/html/sdk/ndk/index.jd
index 0f36345..2c8e4c2 100644
--- a/docs/html/sdk/ndk/index.jd
+++ b/docs/html/sdk/ndk/index.jd
@@ -67,73 +67,71 @@ padding: .25em 1em;
          width="9px" /> Android NDK, Revision 5</a> <em>(November 2010)</em>
 
     <div class="toggleme">
-      <dl>
-        <dt>NDK r5 notes:</dt>
-
-        <dd>
-          <p>The r5 release of the NDK includes many new APIs, many of which are introduced to
-          support native game development and applications that require similar requirements. Most
-          notably, native activities are now supported, which allow you to write an application
-          entirely with native code. For detailed information describing the changes in this
-          release, read the CHANGES.HTML document included in the downloaded NDK package.</p>
-        </dd>
-      </dl>
-
+      <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 CHANGES.HTML document included in the downloaded NDK package.
+      </p>
       <dl>
         <dt>General notes:</dt>
-
         <dd>
           <ul>
-          
-            <li>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 &amp;&amp; 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>Support for prebuilt static and shared libraries (docs/PREBUILTS.html), module
-exports and imports to make sharing and reuse of third-party modules much easier
-(docs/IMPORT-MODULE.html explains why).</li>
-
-            <li>A C++ STL implementation (based on STLport) is now provided as a helper module. It
-can be used either as a static or shared library (details and usage exemple under
-sources/android/stlport/README). <strong>Note:</strong> For now, C++ Exceptions and RTTI are still
-not supported.</li>
-
-            <li>Improvements to the <code>cpufeatures</code> helper library to deal with buggy
-kernel that incorrectly report they run on an ARMv7 CPU (while the device really is an ARMv6). We
-recommend developers that use it to simply rebuild their applications to benefit from it, then
-upload to Market.</li>
-
-            <li>Adds support for native activities, which allows you to write completely native
-            applications.</li>
-
-            <li>Adds an EGL library that lets you create and manage OpenGL ES textures and
-            services.</li>
+            <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>Event loop APIs to wait for things such as input and sensor events</li>
-
-                <li>Access to assets packaged in the <code>.apk</code></li>
-
-                <li>Access to sensor data (accelerometer, compass, gyroscope, etc.)</li>
+                <li>Access to assets packaged in an <code>.apk</code> file.</li>
+                
               </ul>
             </li>
 
-            <li>New sample applications, <code>native-plasma</code> and
-              <code>native-activity</code>, to demonstrate how to write a native activity.</li>
-            
-            <li>Plus many bugfixes and other small improvements; see docs/CHANGES.html for a more
-detailed list of changes.</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 &amp;&amp; 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 Market 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>
@@ -296,14 +294,13 @@ detailed list of changes.</li>
   
   <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. Unlike previous releases, there is no need to run a host-setup
-  script.</p>
+  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 will not work with older versions of the Android SDK. Also, take a moment to
-  review the <a href="{@docRoot}sdk/ndk/reqs.html">System and Software Requirements</a> for the
-  NDK, if you haven't already.</p>
+  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}sdk/ndk/reqs.html">System and Software Requirements</a>
+  for the NDK, if you haven't already.</p>
 
   <p>To install the NDK, follow these steps:</p>
 
@@ -318,7 +315,7 @@ detailed list of changes.</li>
     <code>&lt;ndk&gt;</code>.</li>
   </ol>
 
-  <p>You are now ready start working with the NDK.</p>
+  <p>You are now ready to start working with the NDK.</p>
 
   <h2 id="gettingstarted">Getting Started with the NDK</h2>
 
@@ -342,8 +339,7 @@ detailed list of changes.</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 &lt;project&gt;
+      <pre class="no-pretty-print">cd &lt;project&gt;
 &lt;ndk&gt;/ndk-build
 </pre>
 
@@ -360,220 +356,10 @@ cd &lt;project&gt;
 
   <h2 id="samples">Sample Applications</h2>
 
-  <p>The NDK includes sample applications that illustrate how to use native code in your Android
-  applications:</p>
-
-  <ul>
-    <li><code>hello-jni</code> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; a simple application that renders a triangle using OpenGL ES
-    2.0 vertex and fragment shaders.</li>
-
-    <li><code>hello-neon</code> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; 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>&lt;ndk&gt;/samples/&lt;name&gt;/</code>
-  and their source code can be found under <code>&lt;ndk&gt;/samples/&lt;name&gt;/jni/</code>.</p>
-
-  <p>You can build the shared libraries for the sample apps by going into
-  <code>&lt;ndk&gt;/samples/&lt;name&gt;/</code> then calling the <code>ndk-build</code> command.
-  The generated shared libraries will be located under
-  <code>&lt;ndk&gt;/samples/&lt;name&gt;/libs/armeabi/</code> for (ARMv5TE machine code) and/or
-  <code>&lt;ndk&gt;/samples/&lt;name&gt;/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>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/</code>. Then, set up an AVD,
-    if necessary, and build/run the application in the emulator. For more information about
-    creating a new Android project in Eclipse, see <a href=
-    "{@docRoot}guide/developing/eclipse-adt.html">Developing in Eclipse</a>.</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>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/</code>.
-    Then set up an AVD, if necessary, build your project in the usual way, and run it in the
-    emulator. For more information, see <a href=
-    "{@docRoot}guide/developing/other-ide.html">Developing in Other IDEs</a>.</li>
-  </ul>
-
-  <h3 id="hello-jni">Exploring the hello-jni Sample</h3>
-
-  <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 &gt; New Android Project...</strong></li>
+  <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}sdk/ndk/overview.html#samples">Sample Applications</a>.</p>
 
-            <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>&lt;ndk-root&gt;/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>&lt;ndk-root&gt;/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 &lt;ndk-root&gt;/samples/hello-jni
-&lt;ndk_root&gt;/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>&lt;ndk-root&gt;/samples</code> directory for more examples on how to use the JNI.</p>
-
-  <h3 id="native-activity">Exploring the native-activity Sample Application</h3>
-
-  <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>&lt;ndk_root&gt;/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 &gt; 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>&lt;ndk-root&gt;/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>&lt;ndk-root&gt;/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 &lt;ndk-root&gt;/platforms/samples/android-9/samples/native-activity
-&lt;ndk_root&gt;/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="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
diff --git a/docs/html/sdk/ndk/overview.jd b/docs/html/sdk/ndk/overview.jd
index a7ec5d4..f6d148a 100644
--- a/docs/html/sdk/ndk/overview.jd
+++ b/docs/html/sdk/ndk/overview.jd
@@ -7,10 +7,8 @@ page.title=What is the NDK?
 
       <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>
 
@@ -19,9 +17,7 @@ page.title=What is the NDK?
             <li><a href="#samples">Sample applications</a></li>
           </ol>
         </li>
-
         <li><a href="#reqs">System and Software Requirements</a></li>
-        
       </ol>
     </div>
   </div>
@@ -102,9 +98,8 @@ page.title=What is the NDK?
     later.</li>
 
     <li>
-      <p>Write a native activity, which allows you to potentially create an application completely in native
-      code, because you can implement the lifecycle callbacks natively. The Android SDK provides
-      the {@link android.app.NativeActivity} class, which is a convenience class that notifies your
+      <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
@@ -142,6 +137,10 @@ page.title=What is the NDK?
     <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
@@ -163,25 +162,18 @@ page.title=What is the NDK?
   the <code>&lt;ndk&gt;/docs/</code> directory. Included are these files:</p>
 
   <ul>
-    <li>INSTALL.HTML &mdash; describes how to install the NDK and configure it for your host
+    <li>
+    INSTALL.HTML &mdash; describes how to install the NDK and configure it for your host
     system</li>
 
     <li>OVERVIEW.HTML &mdash; provides an overview of the NDK capabilities and usage</li>
-
+    
     <li>ANDROID-MK.HTML &mdash; describes the use of the Android.mk file, which defines the native
     sources you want to compile</li>
-
+    
     <li>APPLICATION-MK.HTML &mdash; describes the use of the Application.mk file, which describes
-    the native sources required by your Android application</li>
-
-    <li>HOWTO.HTML &mdash; information about common tasks associated with NDK development.</li>
-
-    <li>SYSTEM-ISSUES.HTML &mdash; 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 &mdash; a complete list of the stable APIs exposed by headers in the
-    NDK.</li>
-
+    the native sources required by your Android application</li>    
+    <li>CPLUSPLUS-SUPPORT.HTML &mdash; describes the C++ support provided in the Android NDK</li>    
     <li>CPU-ARCH-ABIS.HTML &mdash; a description of supported CPU architectures and how to target
     them.</li>
 
@@ -193,6 +185,32 @@ page.title=What is the NDK?
     instructions.</li>
 
     <li>CHANGES.HTML &mdash; a complete list of changes to the NDK across all releases.</li>
+
+    <li>DEVELOPMENT.HTML &mdash; describes how to modify the NDK and generate release packages for it</li>
+    
+    <li>HOWTO.HTML &mdash; information about common tasks associated with NDK development</li>
+    
+    <li>IMPORT-MODULE.HTML &mdash; describes how to share and reuse modules</li>
+    
+    <li>LICENSES.HTML  &mdash; information about the various open source licenses that govern the Android NDK</li>
+ 
+    <li>NATIVE-ACTIVITY.HTML &mdash; describes how to implement native activities</li>
+    
+    <li>NDK-BUILD.HTML &mdash; describes the usage of the ndk-build script</li>
+
+    <li>NDK-GDB.HTML &mdash; describes how to use the native code debugger</li>
+
+    <li>PREBUILTS.HTML &mdash; information about how shared and static prebuilt libraries work </li>
+
+    <li>STANDALONE-TOOLCHAIN.HTML &mdash; describes how to use Android NDK toolchain as a standalone
+    compiler (still in beta).</li>
+    
+    <li>SYSTEM-ISSUES.HTML &mdash; 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 &mdash; 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
@@ -206,9 +224,218 @@ page.title=What is the NDK?
 
   <h3 id="samples">Sample applications</h3>
 
-  <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}sdk/ndk/installing.html#samples">Sample Applications</a>.</p>
+<p>The NDK includes sample applications that illustrate how to use native code in your Android
+  applications:</p>
+
+  <ul>
+    <li><code>hello-jni</code> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; a simple application that renders a triangle using OpenGL ES
+    2.0 vertex and fragment shaders.</li>
+
+    <li><code>hello-neon</code> &mdash; 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> &mdash; 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> &mdash; 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> &mdash; 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>&lt;ndk&gt;/samples/&lt;name&gt;/</code>
+  and their source code can be found under <code>&lt;ndk&gt;/samples/&lt;name&gt;/jni/</code>.</p>
+
+  <p>You can build the shared libraries for the sample apps by going into
+  <code>&lt;ndk&gt;/samples/&lt;name&gt;/</code> then calling the <code>ndk-build</code> command.
+  The generated shared libraries will be located under
+  <code>&lt;ndk&gt;/samples/&lt;name&gt;/libs/armeabi/</code> for (ARMv5TE machine code) and/or
+  <code>&lt;ndk&gt;/samples/&lt;name&gt;/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>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/</code>. Then, set up an AVD,
+    if necessary, and build/run the application in the emulator. For more information about
+    creating a new Android project in Eclipse, see <a href=
+    "{@docRoot}guide/developing/eclipse-adt.html">Developing in Eclipse</a>.</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>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/</code>.
+    Then set up an AVD, if necessary, build your project in the usual way, and run it in the
+    emulator. For more information, see <a href=
+    "{@docRoot}guide/developing/other-ide.html">Developing in Other IDEs</a>.</li>
+  </ul>
+
+  <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 &gt; 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>&lt;ndk-root&gt;/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>&lt;ndk-root&gt;/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 &lt;ndk-root&gt;/samples/hello-jni
+&lt;ndk_root&gt;/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>&lt;ndk-root&gt;/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>&lt;ndk_root&gt;/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 &gt; 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>&lt;ndk-root&gt;/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>&lt;ndk-root&gt;/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 &lt;ndk-root&gt;/platforms/samples/android-9/samples/native-activity
+&lt;ndk_root&gt;/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>
 
@@ -313,7 +540,7 @@ page.title=What is the NDK?
     to users whose devices are capable of supporting your application. For example:
       <pre style="margin:1em;">
 &lt;manifest&gt;
-  ...
+  ... 
 <!-- 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. -->
   &lt;uses-feature android:glEsVersion="0x00020000" /&gt;
@@ -331,4 +558,4 @@ page.title=What is the NDK?
     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>&lt;uses-sdk
     android:minSdkVersion="8" /&gt;</code> attribute value in its manifest.</li>
-  </ul>
\ No newline at end of file
+  </ul>