560 lines
24 KiB
Plaintext
560 lines
24 KiB
Plaintext
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 these ARM instruction sets:</p>
|
|
|
|
<ul>
|
|
<li>ARMv5TE (including Thumb-1 instructions)</li>
|
|
|
|
<li>ARMv7-A (including Thumb-2 and VFPv3-D16 instructions, with optional support for
|
|
NEON/VFPv3-D32 instructions)</li>
|
|
</ul>
|
|
|
|
<p>Future releases of the NDK will also support:</p>
|
|
|
|
<ul>
|
|
<li>x86 instructions (see CPU-ARCH-ABIS.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. You can install
|
|
applications that use native code through the JNI on devices that run Android 1.5 or
|
|
later.</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:</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>CPU-ARM-NEON.HTML — a description of how to build with optional ARM NEON / VFPv3-D32
|
|
instructions.</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>/apps/<app_name>/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><ndk>/apps/<app_name>/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 > 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, 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>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>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>
|
|
|
|
<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 given in the
|
|
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 and higher</td>
|
|
|
|
<td><code>android:minSdkVersion="4"</code></td>
|
|
</tr>
|
|
|
|
<tr>
|
|
<td>OpenGL ES 2.0</td>
|
|
|
|
<td>Android 2.0 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/appendix/api-levels.html">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 Android Market 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>
|