This document provides an introduction to the Android NDK (Native Development Kit). It discusses that the NDK allows developing parts of Android apps using native code written in C/C++ for performance reasons or hardware access. Using native code adds complexity since it must be compiled for each hardware platform and interfaced with Java code. The document outlines NDK development, including compiling native libraries for different ABIs (CPU architectures), debugging native code, and considerations for standard C/C++ compatibility on Android.
5. Two kinds of Apps
Apps in the DalvikVM
(that’s the kind of apps you probably know)
Native Apps
(created using the NDK)
6. One VM to rule them all
•
Dalvik is a Virtual Machine (VM)
•
A VM is a common abstraction across different
hardware platforms
•
„Translates“ VM Bytecode to platform specific
instructions
7. It just works™
•
The DalvikVM is already optimized for the x86
Platform
•
Apps relying on the Android SDK / Dalvik Bytecode
will automatically benefit from Platform-specific
Optimizations (like SSE & Co.)
8. From Source to Bytecode
Java
Sourcecode
Java
Bytecode (.class)
Dalvik
Bytecode (.dex)
JAR Archive
Dalvik
VM
Java
VM
13. What’s the NDK?
•
NDK stands for Native Development Kit
•
Allows to compile C/C++ code to native (read:
platform specific) executables/libraries.
•
Build scripts/toolkit to incorporate native code in
Android apps via the Java Native Interface (JNI)
•
Has to be compiled for every platform you want to
support
14. But why?
•
Performance
e.g., complex algorithms, multimedia applications, games
•
Differentiation
app that takes advantage of direct CPU/HW access
e.g., using SSSE3 for optimization
•
Fluid and lag-free animations
•
Software code reuse
17. What could possibly go wrong?
•
Performance improvements are not guaranteed
•
In fact, you could make it worse (read: slower).
•
Added complexity (Java/C++ Interop, Multiple
platforms)
•
Somewhat harder to debug
18.
19. What’s an NDK app?
It’s an Android application that uses
native libraries.
!
Libraries are .so files, usually found
inside libs/CPU_ABI/.
!
These libs can be generated from
native sources inside jni folder,
game engines, or required by other
3rd party libraries.
!
There is no 100% native application.
Even an application purely written
in C/C++, using native_app_glue.h,
will be executed in the context of
the Dalvik Virtual Machine.
20. NDK Development in a Nutshell
C/C++Code
Makefile
ndk-build
APP_ABI := all
or APP_ABI := x86
SDK APIs
Java* calls
GDB debug
through jni
Android* Applications
Java Framework
Java Application
JNI
Native Libs
Bionic C Library
NDK APIs
22. Compatibility with Standard C/C++
•
Bionic C Library:
Lighter than standard GNU C Library
Not POSIX compliant
pthread support included, but limited
No System-V IPCs
Access to Android* system properties
•
Bionic is not binary-compatible with the standard C library
•
It means you generally need to (re)compile everything
using the Android NDK toolchain
23. Pick One
•
By default, libstdc++ is used. It lacks:
Standard C++ Library support (except some headers)
C++ exceptions support
RTTI support
•
Fortunately, you have other libs available with the NDK:
Runtime
Exceptions
RTTI
STL
system
No
No
No
gabi++
Yes
Yes
No
stlport
Yes
Yes
Yes
gnustl
Yes
Yes
Yes
24.
25. Compile for all the platforms.
If you have the source code of your native libraries, you can compile it for several CPU
architectures by setting APP_ABI to all in the Makefile “jni/Application.mk”:!
APP_ABI=all
Put APP_ABI=all inside
Application.mk
Run ndk-build…
ARM v7a libs are built
ARM v5 libs are built
x86 libs are built
mips libs are built
The NDK will generate optimized code for all target ABIs
You can also pass APP_ABI variable directly to ndk-build, and specify each ABI:
ndk-build APP_ABI=x86