Merge "SDK doc change: Add doc update for NDKr3." into eclair

2 files changed, 396 insertions, 1 deletions

diff --git a/docs/html/sdk/ndk/r3/index.jd b/docs/html/sdk/ndk/r3/index.jd
new file mode 100644
index 0000000..13dae7f
--- /dev/null
+++ b/docs/html/sdk/ndk/r3/index.jd
@@ -0,0 +1,394 @@
+ndk=true
+ndk.rel.id=3
+ndk.date=January 2010
+
+ndk.win_download=android-ndk-r3-windows.zip
+ndk.win_bytes=36470676
+ndk.win_checksum=623311259d601e1fd3daccf8b3e24e04
+
+ndk.mac_download=android-ndk-r3-darwin-x86.zip
+ndk.mac_bytes=38255513
+ndk.mac_checksum=3b2f41ea46549724c938416a98731166
+
+ndk.linux_download=android-ndk-r3-linux-x86.zip
+ndk.linux_bytes=37400526
+ndk.linux_checksum=08f3754f541e2b9563d371482656617a
+
+page.title=Android NDK, Release 3
+@jd:body
+
+<h2 id="overview">What is the Android NDK?</h2>
+
+<p>The Android NDK provides tools that allow Android application developers
+to embed components that make use of native code in their Android applications.
+</p>
+
+<p>Android applications run in the Dalvik virtual machine. The NDK allows 
+developers to implement parts of their 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 application package
+files (.apks) 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 </li>
+<li>Documentation, samples, and tutorials</li>
+</ul>
+
+<p>This release of the NDK supports two ARM instruction sets:</p>
+<ul>
+<li>ARMv5TE and</li>
+<li>ARMv7-A  <span class="new">new!</span></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 and Thumb-2 instructions. You can target either or
+both of the instruction sets &mdash; ARMv5TE is the default, but switching to
+ARMv7-A is as easy as adding a single line to the application's Application.mk
+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
+.apk. Complete information is provided in the CPU-ARCH-ABIS.TXT 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 section below.</p>
+
+<p>The NDK will not benefit most applications. As a developer, you will need 
+to balance its benefits against its drawbacks; notably, using native code does 
+not result in an automatic performance increase, but does always increase 
+application complexity. 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. The NDK can, however, can be 
+an effective way to reuse a large corpus of existing C/C++ code.</p>
+
+<p>Please note that the NDK <em>does not</em> enable you to develop native-only
+applications. Android's primary runtime remains the Dalvik virtual machine.</p>
+
+<h2 id="contents">Contents of the NDK</h2>
+
+<h4>Development tools</h4>
+
+<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 <span class="new">new!</span> (3D graphics libraries) headers</li>
+<li>A Minimal set of headers for C++ support</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 &mdash; 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>
+
+<h4>Documentation</h4>
+
+<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>&lt;ndk&gt;/docs/</code> directory. Included are these files:</p>
+
+<ul>
+<li>INSTALL.TXT &mdash; describes how to install the NDK and configure it for
+your host system</li>
+<li>OVERVIEW.TXT &mdash; provides an overview of the NDK capabilities and
+usage</li>
+<li>ANDROID-MK.TXT &mdash; describes the use of the Android.mk file, which
+defines the native sources you want to compile</li>
+<li>APPLICATION-MK.TXT &mdash; describes the use of the Application.mk file,
+which describes the native sources required by your Android application</li>
+<li>HOWTO.TXT &mdash; information about common tasks associated with NDK 
+development.</li>
+<li>SYSTEM-ISSUES.TXT &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.TXT &mdash; a complete list of the stable APIs exposed
+by headers in the NDK.</li>
+<li>CPU-ARCH-ABIS.TXT &mdash; a description of supported CPU architectures 
+and how to target them. </li>
+<li>CHANGES.TXT &mdash; a complete list of changes to the NDK across all 
+releases.</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>&lt;ndk&gt;/docs/system/libc/</code> directory:</p>
+
+<ul>
+<li>OVERVIEW.TXT &mdash; provides an overview of the "bionic" C library and the 
+features it offers.</li>
+</ul>
+
+<h4>Sample applications</h4>
+
+<p>The NDK includes four sample Android 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 that is 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 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>
+</ul>
+
+<p>For more information, see <a href="#samples">Using the Sample
+Applications</a>.</p>
+
+<h2 id="requirements">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, tested on Linux Ubuntu Dapper Drake)</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>For Windows, a recent release of <a
+href="http://www.cygwin.com">Cygwin</a> is required. </li>
+</ul>
+
+<h4>Android platform compatibility</h4>
+<ul>
+  <li>The native libraries created by the Android NDK can only be used on
+devices running the Android 1.5 platform version or later. This is due to 
+toolchain and ABI related changes that make the native libraries incompatible
+with 1.0 and 1.1 system images.</li>
+  <li>For this reason, you should use native libraries produced with the NDK in
+applications that are deployable to devices running the Android 1.5 platform
+version or later. 
+  <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>&lt;uses-sdk&gt;</code></a>
+element in its manifest file, with an <code>android:minSdkVersion</code> attribute 
+value of "3" or higher. For example:
+
+<pre>&lt;manifest&gt;
+  ...
+  &lt;uses-sdk android:minSdkVersion="3" /&gt;
+  ...
+&lt;/manifest&gt;</pre>
+
+<p>Additionally, 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. </p>
+
+<table>
+<tr>
+<th>Version</th>
+<th>Platform Compatibility</th>
+</tr>
+<tr><td>OpenGL ES 1.1</td><td>Android 1.6 (API Level 4) or higher</td></tr>
+<tr><td>OpenGL ES 2.0</td><td>Android 2.0 (API Level 5) or higher</td></tr>
+</table>
+
+<p>To ensure compatibility, the application <em>must</em> declare the proper
+<code>android:minSdkVersion</code></a> attribute value, as given in the table
+above. </p>
+
+<p>For more information about API Level and its relationship to Android 
+platform versions, see <a href="{@docRoot}guide/appendix/api-levels.html">
+Android API Levels</a>.</p></li>
+</ul>
+
+<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 and running a host-setup
+script. </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="#requirements">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-&lt;version&gt;</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>&lt;ndk&gt;</code>.  </li>
+<li>Open a terminal, change to the NDK directory, and run the host-setup script.
+The script sets up your environment and generates a host configuration file used
+later, when building your shared libraries. The path to the host-setup script
+is:
+
+<p><code>&lt;ndk&gt;/build/host-setup.sh</code></p>
+
+<p>If the script completes successfully, it prints a "Host setup complete."
+message. If it fails, it prints instructions that you can follow to correct any
+problems. </p>
+</li>
+</ol>
+
+<p>Once you have run the host-setup script, you are ready 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>&lt;ndk&gt;/docs/</code> directory. In particular, please read the
+OVERVIEW.TXT 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.TXT 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>&lt;project&gt;/jni/...</code></li>
+<li>Create <code>&lt;project&gt;/jni/Android.mk</code> to
+describe your native sources to the NDK build system</li>
+<li>Create <code>&lt;ndk&gt;/apps/&lt;my_app&gt;/Application.mk</code> to
+describe your Android application and native sources it needs to the NDK build
+system. This file sets up the link between an Android SDK application project
+and any number of shared libraries defined in the
+<code>&lt;project&gt;/jni/</code> folder and it specifies the path to the
+application project that will receive the shared library built from the
+sources.</li>
+<li>Build your native code by running this make command from the top-level NDK
+directory:
+
+<p><code>$ make APP=&lt;my_app&gt;</code></p>
+
+<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 .apk file. </p></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">Using the Sample Applications</h2>
+
+<p>The NDK includes four 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 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>
+</ul>
+
+<p>For each sample, the NDK includes an Android application project, as well as
+the corresponding C source code and the necessary Android.mk and Application.mk
+files. The application projects are provided in
+<code>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/</code> and the C source for
+each application is provided in
+<code>&lt;ndk&gt;/apps/&lt;app_name&gt;/project/jni/</code>.</p>
+
+<p>Once you have installed the NDK, you can build the shared libraries from the
+NDK by using these commands from the root of the NDK directory:</p>
+<ul>
+<li><code>$ make APP=hello-jni</code> &mdash; compiles
+<code>&lt;ndk&gt;/apps/hello-jni/project/jni/hello-jni.c</code> and outputs a
+shared library to
+<code>&lt;ndk&gt;/apps/hello-jni/project/libs/armeabi/libhello-jni.so</code>.
+</li>
+<li><code>$ make APP=two-libs</code> &mdash; compiles
+<code>&lt;ndk&gt;/apps/two-libs/project/jni/second.c</code> and
+<code>first.c</code> and outputs a shared library to
+<code>&lt;ndk&gt;/apps/two-libs/project/libs/armeabi/libtwolib-second.so</code>.
+</li>
+</ul>
+
+<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>
+
+<h2>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/sdk/sdk_toc.cs b/docs/html/sdk/sdk_toc.cs
index 556f781..8ef1176 100644
--- a/docs/html/sdk/sdk_toc.cs
+++ b/docs/html/sdk/sdk_toc.cs
@@ -126,7 +126,8 @@ Windows, r3</a> <span class="new">new!</span>
       <span style="display:none" class="zh-TW"></span>
     </h2>
     <ul>
-      <li><a href="<?cs var:toroot ?>sdk/ndk/1.6_r1/index.html">Android 1.6 NDK, r1</a></li>
+      <li><a href="<?cs var:toroot ?>sdk/ndk/r3/index.html">Android NDK, r3</a> 
+       <span class="new">new!</span></li>
     </ul>
   </li>
   <li>