Platform | Package | Size | MD5 Checksum |
---|---|---|---|
Windows | android-ndk-r8d-windows.zip | 327014028 bytes | d78ec3d4ec15ad3b18b9f488a5763c23 |
Mac OS X (intel) | android-ndk-r8d-darwin-x86.tar.bz2 | 308328942 bytes | 5cd9ef9fb7e03943ee8c9e147e42e571 |
Linux 32/64-bit (x86) | android-ndk-r8d-linux-x86.tar.bz2 | 254644383 bytes | e1fa0379a3feb59f2f0865f1a90bd382 |
The NDK is a toolset that allows you to implement parts of your app using native-code languages such as C and C++. For certain types of apps, this can be helpful so you can reuse existing code libraries written in these languages, but most apps do not need the Android NDK.
Before downloading the NDK, you should understand that the NDK will not benefit most apps. As a developer, you need to balance its benefits against its drawbacks. Notably, using native code on Android generally does not result in a noticable performance improvement, but it always increases your app complexity. In general, you should only use the NDK if it is essential to your app—never because you simply prefer to program in C/C++.
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. 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 sections below provide information and notes about successive releases of the NDK, as denoted by revision number.
Android NDK, Revision 8d (December 2012)
ndk-build
, export the NDK_TOOLCHAIN_VERSION=4.7
variable
or add it to Application.mk
.--toolchain=
option to
make-standalone-toolchain.sh
, for example:
--toolchain=arm-linux-androideabi-4.7
Note: This feature is experimental. Please try it and report any issues.
stlport
exception support via gabi++. Note that the new gabi++
depends on dlopen
and related code, meaning that:
-static
option or include libstlport_static.a
using
APP_STL := stlport_static
. (You can still use the -static
option
with a standalone toolchain.) Compiling a dynamic executable using
include $(BUILD_EXECUTABLE)
continues to work because the compiler
automatically adds the -ldl
option.-nostdlib
and {-Wl,--no-undefined}, you
must manually include the -ldl
option.CPLUSPLUS-SUPPORT.html
.
Note: This feature is experimental and works better with the GCC 4.6/4.7 compilers than with GCC 4.4.3 or Clang 3.1. Please try it and report any issues.
-mstack-protector-guard=
option for x86 to choose between a
global default path which is compatible with older Android C library (bionic)
and a new tls path (%gs:20) for -fstack-protector
,
-fstack-protector-all
and -fstack-protector-strong
using the GCC 4.6
and higher compilers.
Note: The -mstack-protector-guard
setting itself does not
enable any -fstack-protector*
options.
android_setCpu()
function to
sources/android/cpufeatures/cpu-features.c
for use when auto-detection via
/proc
is not possible in Android 4.1 and higher.
(Chromium Issue
164154)ndk-build
script.
(Issue 39810)dyld: lazy symbol binding failed: Symbol not found: _memmem Referenced from: ...../arm-linux-androideabi/bin/ld Expected in: /usr/lib/libSystem.B.dylibThis problem was caused by building on Mac OS X 10.7, which produced binaries that were not compatible with Mac OS 10.6.x and the NDK.
-x c++
options from the Clang++ standalone build script.
(Issue 39089)NDK_TOOLCHAIN_VERSION=clang3.1
option in Cygwin.
(Issue 39585)make-standalone-toolchain.sh
script to allow generation of a
standalone toolchain using the Cygwin or MinGW environments. The resulting toolchain
can be used in Cygwin, MingGW or CMD.exe environments.
(Issue 39915,
Issue 39585)SL_IID_ANDROIDBUFFERQUEUESOURCE
option in android-14 builds for
ARM and X86.
(Issue 40625)ANDROID_CPU_X86_FEATURE_MOVBE
feature.
(Issue 39317).cpp
file extension.__WINT_TYPE__
and wint_t
to be the same type.android/bitmap.h
.
(Issue 15134)
errno.h
.__STDC_VERSION__
in sys/cdefs.h
.
(Issue 14627)
byteswap.h
and dirent.h
.limits.h
to include page.h
which provides PAGE_SIZE
settings.
(Issue 39983)
glGetAttribLocation()
and
glGetUniformLocation()
from int
to GLint
.__BYTE_ORDER
constant for x86 builds.
(Issue 39824)
ndk-build
script to not overwrite -Os
with -O2
for ARM
builds.HOST_AWK
, HOST_SED
, and
HOST_MAKE
settings.ld.gold
on fsck_msdos
builds linking objects built by
the Intel C/C++ compiler (ICC).solib
events.
(Issue 38402)libgcc.a
file when linking shared libraries.SIGILL
signal for paths without a return statement.make-standalone-toolchain.sh
to accept the suffix -clang3.1
which is equivalent to adding --llvm-version=3.1
to the GCC 4.6 toolchain.llvm-objdump
.libiberty.a
is built and
placed in lib32/
.Android NDK, Revision 8c (November 2012)
ndk-build
, export NDK_TOOLCHAIN_VERSION=clang3.1
or
add this environment variable setting to Application.mk
.--llvm-version=3.1
to
make-standalone-toolchain.sh
and replace CC
and CXX
in your
makefile with <tool-path>/bin/clang
and
<tool-path>/bin/clang++
. See STANDALONE-TOOLCHAIN.html
for
details.Note: This feature is experimental. Please try it and report any issues.
ld.gold
for the Windows toolchain. Gold linker is also the
default for ARM and X86 on all hosts. You may override it to use the ld.bfd
linker by adding LOCAL_LDFLAGS += -fuse-ld=bfd
to Android.mk
, or by passing
-fuse-ld=bfd
to the g++/clang++ command line that does the linking.ndk-build[.cmd]
and
ndk-gdb
scripts, to prevent build errors that are difficult to diagnose.android-10
through
android-13
in APP_PLATFORM
, project.properties
or
default.properties
link against android-9
instead of
android-14
.
-fPIE
option for position-independent executables (PIE).
A new APP_PIE
option allows you to control this behavior. See APPLICATION-MK.html
for details.
Note: All API levels above 14 still link against platforms/android-14
and no new platforms/android-N
have been added.
ndk-build
to provide warnings if the adjusted API level is larger
than android:minSdkVersion
in the project's AndroidManifest.xml
.cpu-features
helper library to include more ARM-specific features.
See sources/android/cpufeatures/cpu-features.h
for details.APP_ABI=armeabi-v7a
:
-march=armv7-a
parameter
to the linker. This change ensures that v7-specific libraries and crt*.o
are
linked correctly.-mfpu=vfpv3-d16
to ndk-build
instead of the
-mfpu=vfp
option used in previous releases.make-standalone-toolchain.sh
with root privileges
resulted in the stand alone tool chain being inaccessible to some users.
(Issue 35279)
libstdc++.a
is now preserved when copied.\r
from Windows prebuilt echo.exe
. The redundant
\r
caused gdb.setup
to fail in the GNU Debugger (GDB) because it
incorrectly became part of the path.
(Issue 36054)host-mkdir
implementation.
(Issue 25875)libstdc++
to not merge typeinfo
names by
default. For more details, see
toolchain repo gcc/gcc-4.4.3/libstdc++-v3/libsupc++/typeinfo
.
(Issue 22165)null
context in GCC 4.6
cp/mangle.c::write_unscoped_name
, where GCC may crash when the context is
null
and dereferenced in TREE_CODE
.STLport
internal _IteWrapper::operator*()
implementation
where a stale stack location holding the dereferenced value was returned and caused
runtime crashes.
(Issue 38630)g++
to not warn that the mangling of
<va_list> was changed in GCC 4.4. The workaround using the
-Wno-psabi
switch to avoid this warning is no longer required..arm
or .neon
suffixes in
LOCAL_SRC_FILES
also used APP_STL
. With APP_STL
, the
ndk-build
script searches for C++ files in LOCAL_SRC_FILES
before
adding STL header/lib
paths to compilation. Modified ndk-build
to
filter out .arm
and .neon
suffixes before the search, otherwise items
in LOCAL_SRC_FILES
like myfile.cpp.arm.neon
won't be compiled as C++
code.binutils-2.21/ld.bfd
to be capable of linking object from older
binutils without tag_FP_arch
, which was producing assertion fail
error messages in GNU Binutils.
(Issue 35209)
binutils-2.19/ld
links prebuilt object by newer binutils-2.21
stdc++
compilation with both -mthumb
and
-march=armv7-a
, by modifying make-standalone-toolchain.sh
to populate
headers/libs
in sub-directory armv7-a/thumb
.
(Issue 35616)
reload1.c:3633
, caused by the ARM
back-end expecting the wrong operand type when sign-extend from char
.
(GCC Issue 50099)-fstack-protector
for X86, which is also the default for the
ndk-build
x86 ABI target.STLport
endian-ness by setting _STLP_LITTLE_ENDIAN
to 1 when
compiling MIPS libstlport_*
.__builtin_unreachable
issue when compiling LLVM.
(GCC Issue 54369)cc1
compile process consuming 100% CPU.
(GCC Issue 50380)gdb
with a hard-wired dependency on a specific version of Python.
(Issue 36120)
ndk-gdb
when APP_ABI
contains all
and matchs none
of the known architectures.
(Issue 35392)
:
character if it looks
like it could be part of a Windows path starting with a drive letter.
(GDB Issue 12843)
gdbserver
.
(GDB Issue)
solibs
when the linker is consistent.
This change speeds up solib
event handling.
(Issue 37677)
solib
breakpoints. GDB now
retries enable_break()
during every call to svr4_current_sos()
until
it succeeds.
(Change 43563)gdb
would not stop on breakpoints placed in
dlopen-ed
libraries.
(Issue 34856)
SIGILL
in dynamic linker when calling dlopen()
, on system
where /system/bin/linker
is stripped of symbols and
rtld_db_dlactivity()
is implemented as Thumb
, due to not preserving
LSB
of sym_addr
.
(Issue 37147)
arch-mips/include/asm/*
code that was incorrectly removed from
original kernel. (Change
43335)__unused
with __linux_unused
in
linux/sysctl.h
and linux/icmp.h
to avoid conflict with
#define __unused
in sys/cdefs.h
.fenv.h
for enclosed C functions with __BEGIN_DECLS
and
__END_DECLS
.malloc.h
.stdint.h
defintion of uint64_t
for ANSI compilers.
(Issue 1952)<arch>/include/machine/*
.link.h
for MIPS with new version supporting all platforms.linux-unistd.h
LONG_LONG_MIN
, LONG_LONG_MAX
and
ULONG_LONG_MAX
from <pthread.h>
to <limits.h>
.ndk-stack-parser
._STLP_USE_EXCEPTIONS
, when not defined, to omit all declarations
and uses of __Named_exception
. Compiling and use of __Named_exception
settings only occurs when STLport
is allowed to use exceptions../build/tools/make-release.sh --force --systems=linux-x86
libc.so
so it does not export atexit()
and __do_handler
.
These symbols are exported for ARM builds by the system version of the C library to
support legacy native libraries. NDK-generated should never reference them directly.
Instead, each shared library or executable should embed its own version of these symbols,
provided by crtbegin_*.o
.
If your project is linked with the -nostdlib -Wl,--no-undefined
options, you
must provide your own __dso_handle
because crtbegin_so.o
is not linked in
this case. The content of __dso_handle
does not matter, as shown in the following
example code:
extern "C" { extern void *__dso_handle __attribute__((__visibility__ ("hidden"))); void *__dso_handle; }
objdump
for plt
entries to
generate a more readable form function@plt
.libgcc.a
, from
the X86 platform libc.so
library: __aeabi_idiv0
, __aeabi_ldiv0
,
__aeabi_unwind_cpp_pr1
, and __aeabi_unwind_cpp_pr2
..ctors
, .dtors
, and .eh_frame
in MIPS
crt*_so.S
.ndk-gdb
so that it only takes the last line of output for
ndk-build
DUMP_XXXX
. This change ensures that if Application.mk
or
Android.mk
print something with $(info ...)
syntax, it does not get
injected into the result of DUMP_XXXX
.
(More info)arch-x86
and arch-mips
headers from
platforms/android-[3,4,5,8]
. Those headers were incomplete, since both X86 and
MIPS ABIs are only supported at API 9 or higher.<path>/arm-linux-androideabi/include/c++/4.6.x-google to: <path>/include/c++/4.6/
ndk-build
to recognize more C++ file extensions by default:
.cc .cp .cxx .cpp .CPP .c++ .C
. You may still use LOCAL_CPP_EXTENSION
to
overwrite these extension settings.samples/san-angeles
that caused a black screen or freeze
frame on re-launch.hello-gl2
from android-5 to android-7native-activity
from android-9 to android-10native-audio
from android-9 to android-10native-plasma
from android-9 to android-10.note.android.ident
(defined in crtbegin_static/dynamic.o
) so that
debugging tools can act accordingly. The structure member and values are defined as
follows:
static const struct { int32_t namesz; /* = 8, sizeof ("Android") */ int32_t descsz; /* = 1 * sizeof(int32_t) */ int32_t type; /* = 1, ABI_NOTETYPE */ char name[sizeof "Android"]; /* = "Android" */ int32_t android_api; /* = 3, 4, 5, 8, 9, 14 */ }
The previous branding options in section .note.ABI-tag
are deprecated.
run-tests-all.sh
which calls run-tests.sh
and
standalone/run.sh
with various conditions. The script run-tests.sh
runs
without the --abi
option, and is enhanced to compile most of the tests for all
supported ABIs and run on all attached devicesAndroid NDK, Revision 8b (July 2012)
The main features of this release are a new GNU Compiler Collection (GCC) 4.6 toolchain and GNU Debugger (GDB) 7.3.x which adds debugging support for the Android 4.1 (API Level 16) system image.
LOCAL_SHORT_COMMANDS
issues on Mac OS, Windows Cygwin environments for
static libraries. List file generation is faster, and it is not regenerated to avoid repeated
project rebuilds.ndk-gdb
:
-e
, -d
and -s
to adb more
consistently./system/bin/link
information, so gdb
on
the host can set a breakpoint in __dl_rtld_db_dlactivity
and be aware of linker activity
(e.g., rescan solib
symbols when dlopen()
is called).ndk-build clean
on Windows, which was failing to remove
./libs/*/lib*.so
.ndk-build.cmd
to return a non-zero ERRORLEVEL
when make
fails.libc.so
to stop incorrectly exporting the __exidx_start
and
__exidx_end
symbols.SEGV
when unwinding the stack past __libc_init
for ARM and
MIPS.binutils
2.21 with gold
and GDB 7.3.x) to
co-exist with the original GCC 4.4.3 toolchain (binutils
2.19 and GDB 6.6).
NDK_TOOLCHAIN_VERSION=4.4.3
in Application.mk
to select the original one.gold
linker is only available for ARM and x86
architectures on Linux and Mac OS hosts. This support is disabled by default. Add LOCAL_LDLIBS += -fuse-ld=gold
in Android.mk
to enable it.-fPIE
require the new GDB
for debugging,
including binaries in Android 4.1 (API Level 16) system images.binutils
2.21 ld
tool contains back-ported fixes from
version 2.22:
sincos()
optimization for compatibility with older
platforms.relro
/bind_now
protections by default:
--noexecstack
to assembler and -z noexecstack
to linker
that provides NX protection against buffer overflow attacks by enabling NX bit on stack and
heap.-z relro
and -z now
to linker for hardening of internal
data sections after linking to guard against security vulnerabilities caused by memory corruption.
(more info: 1,
2)--execstack
option for the
assembler and -z execstack
for the linker.-z norelro
and
-z lazy
options for the linker.jni/Android.mk
by setting the
following options:
LOCAL_DISABLE_NO_EXECUTE=true # disable "--noexecstack" and "-z noexecstack" DISABLE_RELRO=true # disable "-z relro" and "-z now"
See docs/ANDROID-MK.html
for more details.
.note.ABI-tag
section (in
crtbegin_static/dynamic.o
) so that debugging tools can act accordingly. The structure
member and values are defined as follows:
static const struct { int32_t namesz; /* = 4, sizeof ("GNU") */ int32_t descsz; /* = 6 * sizeof(int32_t) */ int32_t type; /* = 1 */ char name[sizeof "GNU"]; /* = "GNU" */ int32_t os; /* = 0 */ int32_t major; /* = 2 */ int32_t minor; /* = 6 */ int32_t teeny; /* = 15 */ int32_t os_variant; /* = 1 */ int32_t android_api; /* = 3, 4, 5, 8, 9, 14 */ }
mips-linux-gnu
relocation truncated to fit R_MIPS_TLS_LDM
issue.
(more info)ld
tool segfaults when using --gc-sections
.
(more info)
GOT_PAGE
counting issue.
(more info)mips_elf_count_got_symbols
.mips_elf_allocate_lazy_stub
..dynamic
to the data segment, so that it is writable.-mno-shared
option from the defaults in the MIPS toolchain.
The default for Android toolchain is -fPIC
(or -fpic
if supported). If you do not
explicitly specify -mshared
, -fpic
, -fPIC
, -fpie
, or -fPIE
,
the MIPS compiler adds -mno-shared
that turns off PIC. Fixed compiler not to add
-mno-shared
in this case.hello-jni
and two-libs
so that
the tests
project underneath it can compile.gdbserver
from
toolchain/<arch-os-ver>/prebuilt/gdbserver
to
prebuilt/android-<arch>/gdbserver/gdbserver
.i686-android-linux-
to
i686-linux-android-
.sources/cxx-stl/gnu-libstdc++/include
and lib
to
sources/cxx-stl/gnu-libstdc++/4.6
when compiled with GCC 4.6, or
sources/cxx-stl/gnu-libstdc++/4.4.3
when compiled with GCC 4.4.3.libbfd.a
and libintl.a
from lib/
to lib32/
.build-mingw64-toolchain.sh
to generate a new Linux-hosted toolchain
that generates Win32 and Win64 executables.download-toolchain-sources.sh
by using the clone
command and only using checkout
for the directories that are needed to build the NDK
toolchain binaries.build-host-gcc.sh
and build-host-gdb.sh
scripts.tests/check-release.sh
to check the content of a given NDK
installation directory, or an existing NDK package.tests/standalone/run.sh
standalone tests .if_dl.h
header from all platforms and architectures. The AF_LINK
and sockaddr_dl
elements it describes are specific to BSD (i.e., they don't exist
in Linux).Android NDK, Revision 8 (May 2012)
This release of the NDK includes support for MIPS ABI and a few additional fixes.
docs/CPU-MIPS.html
in the NDK package.
By default, code is generated for ARM-based devices. You can add mips
to
your APP_ABI
definition in your Application.mk
file to build
for MIPS platforms. For example, the following line instructs ndk-build
to build your code for three distinct ABIs:
APP_ABI := armeabi armeabi-v7a mips
Unless you rely on architecture-specific assembly sources, such as ARM assembly
code, you should not need to touch your Android.mk
files to build MIPS
machine code.
--arch=mips
option when calling make-standalone-toolchain.sh
. See
docs/STANDALONE-TOOLCHAIN.html
for more details.
Note: To ensure that your applications are available to users only if their devices are capable of running them, Google Play filters applications based on the instruction set information included in your application ? no action is needed on your part to enable the filtering. Additionally, the Android system itself also checks your application at install time and allows the installation to continue only if the application provides a library that is compiled for the device's CPU architecture.
dynamic_cast<D>(b)
of base class object b
to derived class D
is
incorrectly adjusted in the opposite direction from the base class.
(Issue 28721)
make-standalone-toolchain.sh
fails to copy
libsupc++.*
.ndk-build.cmd
to ensure that ndk-build.cmd
works correctly even
if the user has redefined the SHELL
environment variable, which may be changed
when installing a variety of development tools in Windows environments.
Android NDK, Revision 7c (April 2012)
This release of the NDK includes an important fix for Tegra2-based devices, and a few additional fixes and improvements:
cosf
, sinf
, expf
).NDK_OUT
environment variable. When defined, this variable is used to store all
intermediate generated files, instead of $PROJECT_PATH/obj
. The variable is
also recognized by ndk-gdb
. LOCAL_SHORT_COMMANDS
to true
in your Android.mk
.
This change forces the NDK build system to put most linker or archiver options
into list files, as a work-around for command-line length limitations.
See docs/ANDROID-MK.html
for details.
android_getCpuCount()
implementation in the cpufeatures
helper library. On certain devices, where cores are enabled dynamically by the system, the previous
implementation would report the total number of active cores the first time the function
was called, rather than the total number of physically available cores.Android NDK, Revision 7b (February 2012)
This release of the NDK includes fixes for native Windows builds, Cygwin and many other improvements:
sys/atomics.h
to avoid correctness issues
on some multi-core ARM-based devices. Rebuild your unmodified sources with this
version of the NDK and this problem should be completely eliminated.
For more details, read docs/ANDROID-ATOMICS.html
.binutils
2.19 to fix debugging issues that
appeared in NDK r7 (which switched to binutils
2.20.1).ndk-build
on 32-bit Linux. A packaging error put a 64-bit version
of the awk
executable under prebuilt/linux-x86/bin
in NDK r7.ndk-build.cmd
). Other build modes were not
affected. The fixes include:
ndk-build.cmd
from a directory that was not the top of
your project path (e.g., in any sub-directory of it).-lstdc++
(i.e., linking against the GNU libstdc++
C++ runtime). You
should use -lgnustl_shared
if you want to link against the shared library
version or -lstdc++
for the static version.
See docs/STANDALONE-TOOLCHAIN.html
for more details about this fix.
gnustl_shared
on Cygwin. The linker complained that it couldn't find
libsupc++.a
even though the file was at the right location.APP_STL
.libstdc++
runtime, the compiler will
no longer forcibly enable exceptions and RTTI. This change results in smaller code.
If you need these features, you must do one of the following:
Application.mk
. (recommended)APP_GNUSTL_FORCE_CPP_FEATURES
to 'exceptions'
,
'rtti'
or both in your Application.mk
. See
docs/APPLICATION-MK.html
for more details.ndk-gdb
now works properly when your application has private services
running in independent processes. It debugs the main application process, instead of the
first process listed by ps
, which is usually a service process.LOCAL_ARM_MODE
value
and always compile certain source files (but not all) to 32-bit instructions.STLport
: Refresh the sources to match the Android platform version. This
update fixes a few minor bugs:
memmove
instead of memcpy
in string::assign
IsNANorINF
, IsINF
, IsNegNAN
,
etc.For complete details, see the commit log.
STLport
: Removed 5 unnecessary static initializers from the library.cpu-features
helper library was updated to report three optional
x86 CPU features (SSSE3
, MOVBE
and POPCNT
). See
docs/CPU-FEATURES.html
for more details.docs/NDK-BUILD.html
was updated to mention NDK_APPLICATION_MK
instead
of NDK_APP_APPLICATION_MK
to select a custom Application.mk
file.ndk-build
no longer creates an empty "NUL" file in the current
directory when invoked./cygdrive
./home
to \\server\subdir
instead of C:\Some\Dir
.ndk-build
does not try to use the native Windows tools under
$NDK/prebuilt/windows/bin
with certain versions of Cygwin and/or GNU Make.Android NDK, Revision 7 (November 2011)
This release of the NDK includes new features to support the Android 4.0 platform as well as many other additions and improvements:
<OMXAL/OpenMAXAL.h>
and
<OMXAL/OpenMAXAL_Android.h>
headers allow applications targeting
API level 14 to perform multimedia output directly from native code by using a new
Android-specific buffer queue interface. For more details, see
docs/openmaxal/index.html
and http://www.khronos.org/openmax/.docs/opensles/index.html
and
http://www.khronos.org/opensles/.NDK_CCACHE
environment variable to ccache
(or the path to
your ccache
binary). When declared, the NDK build system automatically
uses CCache when compiling any source file. For example:
export NDK_CCACHE=ccache
Note: CCache is not included in the NDK release so you must have it installed prior to using it. For more information about CCache, see http://ccache.samba.org.
APP_ABI
to all
to indicate that
you want to build your NDK modules for all the ABIs supported by your given NDK
release. This means that either one of the following two lines in your
Application.mk
are equivalent with this release:
APP_ABI := all APP_ABI := armeabi armeabi-v7a x86
This also works if you define APP_ABI
when calling
ndk-build
from the command-line, which is a quick way to check that your
project builds for all supported ABIs without changing the project's
Application.mk file
. For example:
ndk-build APP_ABI=all
LOCAL_CPP_FEATURES
variable in Android.mk
that
allows you to declare which C++ features (RTTI or Exceptions) your module uses. This
ensures that the final linking works correctly if you have prebuilt modules that depend
on these features. See docs/ANDROID-MK.html
and
docs/CPLUSPLUS-SUPPORT.html
for more details.$NDK/ndk-build
from your project path, the paths to the source,
object, and binary files that are passed to the build commands are significantly
shorter now, because they are passed relative to the current directory. This is useful
when building projects with a lot of source files, to avoid limits on the maximum
command line length supported by your host operating system. The behavior is unchanged
if you invoke ndk-build
from a sub-directory of your project tree, or if
you define NDK_PROJECT_PATH
to point to a specific directory.ndk-build.cmd
script from the command line from your project path. The
script takes exactly the same arguments as the original ndk-build
script.
The Windows NDK package comes with its own prebuilt binaries for GNU Make, Awk and other
tools required by the build. You should not need to install anything else to get a
working build system.
Important: ndk-gdb
does not work on
Windows, so you still need Cygwin to debug.
This feature is still experimental, so feel free to try it and report issues on the public bug database or public forum. All samples and unit tests shipped with the NDK succesfully compile with this feature.
libs/<abi>
) if APP_MODULES
is not defined in
your Application.mk
. For example, if a top-level module foo
imports a module bar
, then both libfoo.so
and
libbar.so
are copied to the install location. Previously, only
libfoo.so
was copied, unless you listed bar
in your
APP_MODULES
too. If you define APP_MODULES
explicitly, the
behavior is unchanged.ndk-gdb
now works correctly for activities with multiple categories in
their MAIN intent filters.foo
imports static library bar
that imports static
library zoo
, the libfoo.so
will now be linked against both
libbar.a
and libzoo.a
.docs/NATIVE-ACTIVITY.HTML
: Fixed typo. The minimum API level should be
9, not 8 for native activities.docs/STABLE-APIS.html
: Added missing documentation listing EGL as a
supported stable API, starting from API level 9.download-toolchain-sources.sh
: Updated to download the toolchain
sources from android.googlesource.com,
which is the new location for the AOSP servers.gabi++
. More details about it
are available in the updated docs/CPLUSPLUS-SUPPORT.html
.gnustl_shared
that corresponds
to the shared library version of GNU libstdc++ v3 (GPLv3 license). See more info at
docs/CPLUSPLUS-SUPPORT.html
LOCAL_CPP_EXTENSION
. For
example, to compile both foo.cpp
and bar.cxx
as C++ sources,
declare the following:
LOCAL_CPP_EXTENSION := .cpp .cxx
The extensions that are available depend on your actual device and GPU drivers,
not the platform version the device runs on. The header changes simply add new
constants and types to make it easier to use the extensions when they have been
probed with eglGetProcAddress()
or glGetProcAddress()
. The
following list describes the newly supported extensions:
GL_OES_vertex_array_object
GL_OES_EGL_image_external
GL_APPLE_texture_2D_limited_npot
GL_EXT_blend_minmax
GL_EXT_discard_framebuffer
GL_EXT_multi_draw_arrays
GL_EXT_read_format_bgra
GL_EXT_texture_filter_anisotropic
GL_EXT_texture_format_BGRA8888
GL_EXT_texture_lod_bias
GL_IMG_read_format
GL_IMG_texture_compression_pvrtc
GL_IMG_texture_env_enhanced_fixed_function
GL_IMG_user_clip_plane
GL_IMG_multisampled_render_to_texture
GL_NV_fence
GL_QCOM_driver_control
GL_QCOM_extended_get
GL_QCOM_extended_get2
GL_QCOM_perfmon_global_mode
GL_QCOM_writeonly_rendering
GL_QCOM_tiled_rendering
GL_OES_element_index_uint
GL_OES_get_program_binary
GL_OES_mapbuffer
GL_OES_packed_depth_stencil
GL_OES_texture_3D
GL_OES_texture_float
GL_OES_texture_float_linear
GL_OES_texture_half_float_linear
GL_OES_texture_npot
GL_OES_vertex_array_object
GL_OES_EGL_image_external
GL_AMD_program_binary_Z400
GL_EXT_blend_minmax
GL_EXT_discard_framebuffer
GL_EXT_multi_draw_arrays
GL_EXT_read_format_bgra
GL_EXT_texture_format_BGRA8888
GL_EXT_texture_compression_dxt1
GL_IMG_program_binary
GL_IMG_read_format
GL_IMG_shader_binary
GL_IMG_texture_compression_pvrtc
GL_IMG_multisampled_render_to_texture
GL_NV_coverage_sample
GL_NV_depth_nonlinear
GL_QCOM_extended_get
GL_QCOM_extended_get2
GL_QCOM_writeonly_rendering
GL_QCOM_tiled_rendering
EGL_ANDROID_recordable
EGL_NV_system_time
Android NDK, Revision 6b (August 2011)
This release of the NDK does not include any new features compared to r6. The r6b release addresses the following issues in the r6 release:
APP_ABI="armeabi x86"
is used for
multi-architecture builds.atexit()
usage in shared libraries with the x86standalone
toolchain.make-standalone-toolchain.sh --arch=x86
. It used to fail
to copy the proper GNU libstdc++ binaries to the right location.__dso_handle
symbol (ARM only).$(SYSROOT)/usr/include
for x86 builds.
See the bug for
more information.ptrdiff_t
and size_t
in
x86-specific systems when they are used with the x86 standalone toolchain.Android NDK, Revision 6 (July 2011)
This release of the NDK includes support for the x86 ABI and other minor changes.
For detailed information describing the changes in this release, read the
CHANGES.HTML
document included in the NDK package.
docs/CPU-X86.html
in the NDK package.
By default, code is generated for ARM-based devices, but you can add x86 to your
APP_ABI
definition in your Application.mk
file to build
for x86 platforms. For example, the following line instructs ndk-build
to build your code for three distinct ABIs:
APP_ABI := armeabi armeabi-v7a x86
Unless you rely on ARM-based assembly sources, you shouldn't need to touch
your Android.mk
files to build x86 machine code.
--toolchain=x86-4.4.3
option when calling make-standalone-toolchain.sh
. See
docs/STANDALONE-TOOLCHAIN.html
for more details.
ndk-stack
tool lets you translate stack traces in
logcat
that are generated by native code. The tool translates
instruction addresses into a readable format that contains things such
as the function, source file, and line number corresponding to each stack frame.
For more information and a usage example, see docs/NDK-STACK.html
.
arm-eabi-4.4.0
, which had been deprecated since NDK r5, has been
removed from the NDK distribution.Android NDK, Revision 5c (June 2011)
This release of the NDK does not include any new features compared to r5b. The r5c release addresses the following problems in the r5b release:
ndk-build
: Fixed a rare bug that appeared when trying to perform parallel
builds of debuggable projects.LOCAL_WHOLE_STATIC_LIBRARIES
to work
correctly with the new toolchain and added documentation for this in
docs/ANDROID-MK.html
.gnustl_static
crashed when run on
platform releases older than API level 8 (Android 2.2).ndk-gdb
: Fixed a bug that caused a segmentation fault when debugging Android 3.0
or newer devices.<android/input.h>
: Two functions that were introduced in API level
9 (Android 2.3) were incorrect and are fixed. While this breaks the source API, the
binary interface to the system is unchanged. The incorrect functions were missing a
history_index
parameter, and the correct definitions are shown below:
float AMotionEvent_getHistoricalRawX(const AInputEvent* motion_event, size_t pointer_index, size_t history_index); float AMotionEvent_getHistoricalRawY(const AInputEvent* motion_event, size_t pointer_index, size_t history_index);
pthread_rwlock_init
).LOCAL_SRC_FILES
. This was not the case previously because the files were
grouped by source extensions instead.import-module
fails, it now prints the list of directories that
were searched. This is useful to check that the NDK_MODULE_PATH
definition
used by the build system is correct.import-module
succeeds, it now prints the directory where the
module was found to the log (visible with NDK_LOG=1
).ndk-gdb
: Better detection of adb shell
failures and improved
error messages.<pthread.h>
: Fixed the definition of
PTHREAD_RWLOCK_INITIALIZER
for API level 9 (Android 2.3) and higher.LOCAL_ARM_NEON
was set to
true (typo in build/core/build-binary.mk
)..S
files were okay).Android NDK, Revision 5b (January 2011)
This release of the NDK does not include any new features compared to r5. The r5b release addresses the following problems in the r5 release:
ndk-build
issues are fixed:
cygpath -m
from GNU Make for every source or object file, which caused problems
with very large source trees. In case this doesn't work properly, define NDK_USE_CYGPATH=1
in your
environment to use cygpath -m
again.NDK_MODULE_PATH
environment variable from working properly when
it contained multiple directories separated with a colon. prebuilt-common.sh
script contains fixes to check the compiler for 64-bit
generated machine code, instead of relying on the host tag, which
allows the 32-bit toolchain to rebuild properly on Snow Leopard. The toolchain rebuild scripts now also support
using a 32-bit host toolchain.INET_ADDRSTRLEN
was added to <netinet/in.h>
.IN6_IS_ADDR_MC_NODELOCAL
and IN6_IS_ADDR_MC_GLOBAL
were added to <netinet/in6.h>
.<asm/byteorder.h>
to allow compilation with -std=c99
.Android NDK, Revision 5 (December 2010)
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
NativeActivity
class. For detailed information describing the changes in this
release, read the CHANGES.HTML
document included in the downloaded NDK package.
.apk
file../configure && make
. 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.cpufeatures
helper library that improves reporting
of the CPU type (some devices previously reported ARMv7 CPU when the device really was an ARMv6). We
recommend developers that use this library to rebuild their applications then
upload to Google Play to benefit from the improvements.native-plasma
and native-activity
,
to demonstrate how to write a native activity.Android NDK, Revision 4b (June 2010)
Includes fixes for several issues in the NDK build and debugging scripts — if you are using NDK r4, we recommend downloading the NDK r4b build. For detailed information describing the changes in this release, read the CHANGES.TXT document included in the downloaded NDK package.
ndk-build
build
command.ndk-gdb
command.armeabi-v7a
. The new ABI extends the existing armeabi
ABI to
include these CPU instruction set extensions:
cpufeatures
static library (with sources) that lets your
app detect the host device's CPU features at runtime. Specifically, applications can
check for ARMv7-A support, as well as VFPv3-D32 and NEON support, then provide separate
code paths as needed.hello-neon
, that illustrates how to use the
cpufeatures
library to check CPU features and then provide an optimized
code path using NEON instrinsics, if supported by the CPU..apk
.Bitmap
objects from native code.Android NDK, Revision 3 (March 2010)
hello-gl2
, that illustrates the use of
OpenGL ES 2.0 vertex and fragment shaders.Android NDK, Revision 2 (September 2009)
Originally released as "Android 1.6 NDK, Release 1".
san-angeles
, that renders 3D graphics
through the native OpenGL ES APIs, while managing activity lifecycle with a GLSurfaceView
object.Android NDK, Revision 1 (June 2009)
Originally released as "Android 1.5 NDK, Release 1".
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.
Native Code CPU Architecture Used | Compatible Android Platform(s) |
---|---|
ARM, ARM-NEON | Android 1.5 (API Level 3) and higher |
x86 | Android 2.3 (API Level 9) and higher |
MIPS | Android 2.3 (API Level 9) and higher |
These requirements mean you can use native libraries produced with the NDK in applications that are deployable to ARM-based devices running Android 1.5 or later. If you are deploying native libraries to x86 and MIPS-based devices, your application must target Android 2.3 or later.
<uses-sdk>
element in its manifest file, with an
android:minSdkVersion
attribute value of "3" or higher. For example:
<manifest> <uses-sdk android:minSdkVersion="3" /> ... </manifest>
android:minSdkVersion
attribute value, as shown in the
following table.OpenGL ES Version Used | Compatible Android Platform(s) | Required uses-sdk Attribute |
---|---|---|
OpenGL ES 1.1 | Android 1.6 (API Level 4) and higher | android:minSdkVersion="4" |
OpenGL ES 2.0 | Android 2.0 (API Level 5) and higher | android:minSdkVersion="5" |
For more information about API Level and its relationship to Android platform versions, see Android API Levels.
<uses-feature>
element in its manifest, with an
android:glEsVersion
attribute that specifies the minimum OpenGl ES version
required by the application. This ensures that Google Play will show your application only
to users whose devices are capable of supporting your application. For example:
<manifest> <uses-feature android:glEsVersion="0x00020000" /> ... </manifest>
For more information, see the <uses-feature>
documentation.
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 <uses-sdk
android:minSdkVersion="8" />
attribute value in its manifest.Installing the NDK on your development computer is straightforward and involves extracting the NDK from its download package.
Before you get started make sure that you have downloaded the latest Android SDK and upgraded your applications and environment as needed. The NDK is compatible with older platform versions but not older versions of the SDK tools. Also, take a moment to review the System and Software Requirements for the NDK, if you haven't already.
To install the NDK, follow these steps:
android-ndk-<version>
. 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
<ndk>
.You are now ready to start working with the NDK.
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 <ndk>/docs/
directory. In particular, please read the OVERVIEW.HTML document completely, so that you
understand the intent of the NDK and how to use it.
If you used a previous version of the NDK, take a moment to review the list of NDK changes in the CHANGES.HTML document.
Here's the general outline of how you work with the NDK tools:
<project>/jni/...
<project>/jni/Android.mk
to describe your native sources to the
NDK build system<project>/jni/Application.mk
.cd <project> <ndk>/ndk-build
The build tools copy the stripped, shared libraries needed by your application to the proper location in the application's project directory.
.apk
file.For complete information on all of the steps listed above, please see the documentation included with the NDK package.
The Android framework provides two ways to use native code:
Write a native activity, which allows you to implement the lifecycle callbacks in native
code. The Android SDK provides the NativeActivity
class, which is a
convenience class that notifies your
native code of any activity lifecycle callbacks (onCreate()
, onPause()
,
onResume()
, 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.
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.
The NDK contains the APIs, documentation, and sample applications that help you write your native code. Specifically:
.apk
) that can be deployed on Android devicesThe latest release of the NDK supports the following instruction sets:
docs/CPU-ARCH-ABIS.html
for more
information)docs/CPU-ARM-NEON.html
for more information)docs/CPU-X86.html
for more information)docs/CPU-MIPS.html
for more information)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
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.HTML in the NDK package.
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 Development tools section.
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.
It provides a set of system headers for stable native APIs that are guaranteed to be supported in all later releases of the platform:
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.
Important: With the exception of the libraries listed above, native system libraries in the Android platform are not stable and may change in future platform versions. Your applications should only make use of the stable native system libraries provided in this NDK.
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 <ndk>/docs/
directory. Included are these files (partial listing):
cpufeatures
static library that
lets your application code detect the target device's CPU family and the optional features at
runtime.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 <ndk>/docs/system/libc/
directory:
The NDK includes sample applications that illustrate how to use native code in your Android applications:
hello-jni
— a simple application that loads a string from a native
method implemented in a shared library and then displays it in the application UI.two-libs
— 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.san-angeles
— a simple application that renders 3D graphics through the
native OpenGL ES APIs, while managing activity lifecycle with a GLSurfaceView
object.hello-gl2
— a simple application that renders a triangle using OpenGL ES
2.0 vertex and fragment shaders.hello-neon
— a simple application that shows how to use the
cpufeatures
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.bitmap-plasma
— a simple application that demonstrates how to access the
pixel buffers of Android Bitmap
objects from native code, and uses
this to generate an old-school "plasma" effect.native-activity
— a simple application that demonstrates how to use the
native-app-glue static library to create a native activitynative-plasma
— a version of bitmap-plasma implemented with a native
activity.For each sample, the NDK includes the corresponding C source code and the necessary Android.mk
and Application.mk files. There are located under <ndk>/samples/<name>/
and their source code can be found under <ndk>/samples/<name>/jni/
.
You can build the shared libraries for the sample apps by going into
<ndk>/samples/<name>/
then calling the ndk-build
command.
The generated shared libraries will be located under
<ndk>/samples/<name>/libs/armeabi/
for (ARMv5TE machine code) and/or
<ndk>/samples/<name>/libs/armeabi-v7a/
for (ARMv7 machine code).
Next, build the sample Android applications that use the shared libraries:
<ndk>/samples/<name>/
. Then, set up an AVD,
if necessary, and build/run the application in the emulator.android
tool to create the build file
for each of the sample projects at <ndk>/samples/<name>/
.
Then set up an AVD, if necessary, build your project in the usual way, and run it in the
emulator.For more information about developing with the Android SDK tools and what you need to do to create, build, and run your applications, see the Overview section for developing on Android.
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.
The main components of the sample include:
AndroidManifest.xml
file, a src/
and res
directories, and a main activity)jni/
directory that includes the implemented source file for the native code
as well as the Android.mk filetests/
directory that contains unit test code.android
tool to update the project so it generates a build.xml file that you can
use to build the sample.
<ndk-root>/samples/hello-jni
directory.<ndk-root>/samples/hello-jni
directory.android update project -p . -s
ndk-build
command.
cd <ndk-root>/samples/hello-jni <ndk_root>/ndk-build
ant debug adb install bin/HelloJni-debug.apk
When you run the application on the device, the string Hello JNI
should appear on
your device. You can explore the rest of the samples that are located in the
<ndk-root>/samples
directory for more examples on how to use the JNI.
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:
AndroidManifest.xml
file, a src/
and res
directories). The AndroidManifest.xml declares
that the application is native and specifies the .so file of the native activity. See NativeActivity
for the source or see the
<ndk_root>/platforms/samples/native-activity/AndroidManifest.xml
file.jni/
directory contains the native activity, main.c, which uses the
android_native_app_glue.h
interface to implement the activity. The Android.mk that
describes the native module to the build system also exists here.To build this sample application:
android
tool to update the project so it generates a build.xml file that you can
use to build the sample.
<ndk-root>/samples/native-activity
directory.<ndk-root>/samples/native-activity
directory.android update project -p . -s
ndk-build
command.
cd <ndk-root>/platforms/samples/android-9/samples/native-activity <ndk_root>/ndk-build
ant debug adb install bin/NativeActivity-debug.apk