am 48edf7c0: am d1da5fa2: Revert "SDK doc change: Add doc update for NDKr3."

Merge commit '48edf7c00201f2bc6186e07dbc614976642682e4'

* commit '48edf7c00201f2bc6186e07dbc614976642682e4':
  Revert "SDK doc change: Add doc update for NDKr3."

2 files changed, 1 insertions, 396 deletions

diff --git a/docs/html/sdk/ndk/r3/index.jd b/docs/html/sdk/ndk/r3/index.jd
deleted file mode 100644
index 13dae7f..0000000
--- a/docs/html/sdk/ndk/r3/index.jd
+++ /dev/null
@@ -1,394 +0,0 @@
-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 8ef1176..556f781 100644
--- a/docs/html/sdk/sdk_toc.cs
+++ b/docs/html/sdk/sdk_toc.cs
@@ -126,8 +126,7 @@ 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/r3/index.html">Android NDK, r3</a> 
-       <span class="new">new!</span></li>
+      <li><a href="<?cs var:toroot ?>sdk/ndk/1.6_r1/index.html">Android 1.6 NDK, r1</a></li>
     </ul>
   </li>
   <li>