Overview of NDK and Set up Eclipse for Android C/C++ Development

This tutorial shows overview of NDK & how to setup Eclipse for using C/C++ together with Java in Android projects.

How NDK comes into Picture?

Portability among hardware and adaptability to the constrained resources of mobile devices: this is the real essence of the mobile challenge from a technical perspective. With Android, ones has to deal with multiple screen resolutions, various CPU and GPU speed or capabilities, memory limitations, and so on, which are not topics specific to this Linux-based system.

To ease portability, Google engineers packaged a virtual machine with a complete framework (the Android SDK) to run programs written in one of the most spread programming language nowadays: Java.

Java, augmented with the Android framework, is really powerful. But first,
Java is specific to Android. Apple's products are written for example in Objective C and can be combined with C and C++. 

And second, a Java virtual machine does not always give you enough capability to exploit the full power of mobile devices, even with just-in-time compilation
enabled. Resources are limited on these devices and have to be carefully exploited to offer the best experience. This is where the Android Native Development Kit comes into place.

When to Use NDK

However, we’d like to take a moment to talk about why the NDK is important, when it should be used.

Generally speaking, you only need to use the NDK if your application is truly processor bound. That is, you have algorithms that are using all of the processor within the DalvikVM and would benefit from running natively. Also, a JIT compiler will improve the performance of such code as well.

Another reason to use the NDK is for ease of porting. If you’ve got loads of C code for your existing application, using the NDK could speed up your project’s development process.

You need to have Google ADT (Android Development Tools) installed. See http://developer.android.com/sdk/eclipse-adt.html how to do it.

You also need Android ndk. Download it from http://developer.android.com/sdk/ndk/index.html and unpack it somewhere.

1) Install CDT (C/C++ Development Tools) into Eclipse.

Choose Help->Install New Software… from the main menu.

Choose http://download.eclipse.org/releases/galileo as the source site. If you have another Eclipse release than Galileo choose the appropriate url.

  Click Next, Accept licences and finish the installation process.



2) In file manager create jni/ directory in your project directory and place your C/C++ sources file here. Also put here Android.mk file which is a makefile that tells Android build-system how to build your files.

Take a look into Android ndk docs/ANDROID-MK.html file how to create one.
Simple example of Android.mk file:

LOCAL_PATH := $(call my-dir)  
include $(CLEAR_VARS) 
LOCAL_LDLIBS := -llog
LOCAL_MODULE := com_anky_ndk 
LOCAL_SRC_FILES := com_anky_ndk_test.c
include $(BUILD_SHARED_LIBRARY)

3)  Refresh (F5) directories in Package Explorer to see jni directory here. Open your .c/.cpp file.

Your .c/.cpp file (native.c in my case) contains a lot of syntax errors which are not truly syntax errors. This is because Eclipse threats the project as a pure Java project. We have to convert the project into mixed Java & C/C++ project.



4) Press Ctrl+n  (or choose File->New->Other… from main menu) and select Convert to a C/C++ Project.

This will convert your project into a mixed Java & C/C++ project rather than into pure C/C++ project (the name of the function is misleading).

Click Next. Then choose your project and below choose Makefile project and – Other Toolchain –. Click Finish.

After doing this Eclipse will ask you if you want to switch to C/C++ perspective. Choose Yes because otherwise you wouldn’t be able to set C/C++ build preferences.


5) Click on your project with right button and select Properties or press Alt+Enter

Properties windows will appear. Here you have to configure use of ndk-build instead of make all command and set proper include paths.

6) Choose C/C++ Build and configure ndk-build as a build command
In Builder settings fill ndk-build into Build command entry. You have to uncheck Use default build command. You also need to have ndk-build script in your PATH.

In Behaviour setting uncheck clean (ndk-build cleans project automatically on build and does not support separate clean command) and clear all text from build (ndk-build does not accept all as a parameter.

Click Apply to save settings.



7) Choose C/C++ General->Paths and Symbols and configure include path

In Includes tab choose GNU C or GNU C++ and click Add… button. Add path to include directory which is located in platforms/android-4/arch/arm/usr/include subdirectory of place where you’ve unpacked Android ndk. Include path depends on target for which you are compiling (android-4 in my case — i.e. Android 1.6).

Finally click Apply and OK and that is all. Now you can use all Eclipse power for editing your C/C++ sources. If you click Run or Debug Eclipse will compile C/C++ code as well as Java code and run it on device/emulator. However you will not be able to debug C/C++ code.