Android NDK

by Abdun Nur Tomal

Step 1: Installing C/C++ Support on Eclipse

• Choose Eclipse Galileo to update..• Let the item preference tree load, and check

Eclipse C/C++ Development Tools in the Programming Languages branch.

• From - http://www.eclipse.org/cdt/downloads.php

Step 2: Installing Cygwin

• Android is Linux based, and thus it is no surprise that when build native code for it, need some Unix tools.

• On Windows, NDK supports Cygwin 1.7.x and above.

• It’s just a set of software that emulates Unix environment on Windows

• get Cygwin, go to cygwin.com

“Install or update Cygwin now!”• Cygwin’s setup.exe will download and run..

• Choose Install from Internet, then click Next, then choose the installation directory

(be sure to choose a directory path that contains no spaces in it) like – C:/cygwin

Base packages installed, Need the development packages

• After choose the mirror and click Next, Cygwin will download and present to you the list of available packages:

• By default, only the base packages are installed. We, however, need the development packages. Rather than picking the packages we think we need.

• We install the entire Devel branch.

• Click (once) on the word “Default” next to the root Devel node and wait few seconds while the setup hangs.

• When it is back, you will see that “Default” changes to “Install” for the Devel node, just like on the screenshot above.

• Click it once, let the Cygwin console start up and initialize:• should see the same response that tells us that GNU Make is

present in our Unix environment that is emulated by Cygwin.

Android NDKWhile the Android SDK provides a very rich programming environment,

The Android NDK broadens the horizons and can speed up the delivery of desired functionality by bringing in existing source code, some of which may be proprietary and some of which may be open source code.

The NDK includes all the components necessary to incorporate functionality written in C into an Android application.

As of r5 of the NDK application,• authors can write a significant portion of an application directly in C,

including user interface and event-handling capability. As of r4b of the NDK application,• The features enabling the image handling functionality demonstrated

here were introduced with the r4b version of the NDK.

NDK BuildTwo common uses of the NDK are

- to increase application performance and Application performance improvements are available when carefully

crafted functions written in C are leveraged to perform memory-based or computationally intensive operations.- to leverage existing C code by porting it to Android.

The NDK is to port an existing body of C code written for another platform, such as Linux.

The NDK contains a compiler and build scripts, allowing - to focus on the C source files and - leave the build magic to the NDK installation.

The NDK build process is easily incorporated into the Eclipse development environment,

Step 3: Installing the Android NDK

• Android NDK itself and place it on our filesystem.

• Can get NDK from the official Android site• Be sure that there are no spaces in the path.• Extract it to C:\, • so the path is C:\android-ndk-r6.

Step 4: Making a Basic NDK App

• The general idea of using NDK in apps is to put your native pieces of code into libraries that you can then consume from the Java code.

• Use the New Android Project wizard..• However, an important thing to check , it is

spaces in the path again.

• In the project named ... Make a folder called jni in the root of the project (right-click the project node, New – Folder).

• Create a file called Android.mk (New – File) within that folder with the following contents:LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS)

# Here we give our module name and source file(s) :LOCAL_MODULE := ndk_test LOCAL_SRC_FILES := ndk_test.c include $(BUILD_SHARED_LIBRARY)

The Android.mk file is important for the NDK build process to recognize your NDK modules. In our case we named our module ndk_test and told the build tool that it consists of one source file named ndk_test.c. Let’s create it in the same jni folder:

#include <string.h> #include <jni.h>jstring Java_com_mindtherobot_samples_ndkfoo_NdkFooActivity_invokeNativeFunction(JNIEnv* env, jobject javaThis)

{ return (*env)->NewStringUTF(env, "Hello from native code!"); }

• the C function – it matches the Java class name.• create a binary library from the C source that we

wrote, • use a combination of Cygwin and Android NDK

tools. • Launch the Cygwin console and use the cd command

to go directly to the folder where your project is. • the command line is:

/cygdrive/c/android-ndk-r4/ndk-build

• a successful run of the ndk-build tool will create an .so file in a new folder called libs.

• The .so file is the binary library that will be included into the application .apk package and will be available for the Java code of the app to link to.

Ndk_testActivity class to use the NDK code:

package com.mindtherobot.samples.ndkfoo;

import android.app.Activity; import android.app.AlertDialog;import android.os.Bundle;

public class Ndk_testActivity extends Activity { // load the library - name matches jni/Android.mk static {

System.loadLibrary("ndkfoo"); }

// declare the native code function - must match ndk_test.c private nativeString invokeNativeFunction(); @Overridepublic void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);setContentView(R.layout.main); // this is where we call the native code String hello = invokeNativeFunction(); new AlertDialog.Builder(this).setMessage(hello).show(); }

}

How to Build FFmpeg for Android• Download Android NDK r5bTo download android ndk revision 5b and rev.6 use the following command:

http://dl.google.com/android/ndk/android-ndk-r5b-linux-x86.tar.bz2

http://dl.google.com/android/ndk/android-ndk-r6-linux-x86.tar.bz2

• Download Source Code for Ffmpeg - http://ffmpeg.org/download.html https://github.com/FFmpeg/FFmpeg - The FFmpeg 0.8 “Love” need to downloaded. http://ffmpeg.zeranoe.com/builds/

• Build FFmpeg (The script is based on RockPlayer build script)RockPlayer open source component: http://rockplayer.freecoder.org/tech.html http://roman10.net/src/build_android_r5b.txt http://roman10.net/src/build_android_r6.txt

• The Output of the Build

All about JNI

• Java Native Interface (JNI)• The JNI is a part of the Java platform,

programmers can address interoperability issues once, and expect their solution to work with all implementations of the Java platform.

“Applications written in the Java programming language as well as in native (C, C++, etc.) programming languages.”

Activity Seemsclarify the exact scope of the programming environments for these languages.• Java applications are written in the Java programming language, and

compiled into a machine-independent binary class format.• The Java API consists of a set of predefined classes.• Any implementation of the Java platform is guaranteed to support the Java

programming language, virtual machine, and API.• The term host environment represents the host operating system, a set of

native libraries, and the CPU instruction set. • Native applications are written in native programming languages such as C

and C++, compiled into host-specific binary code, and linked with native libraries.

• We know, Native applications and native libraries are typically dependent on a particular host environment.

• A C application built for one operating system, for example, typically does not work on other operating systems.

Java Platform do

• Java platforms are commonly deployed on top of a host environment.

For example, the Java Runtime Environment (JRE) is a Sun product that supports the Java platform on existing operating systems such as Solaris and Windows.

• The Java platform offers a set of features that applications can rely on independent of the underlying host environment.

Role of the JNI• The JNI is a powerful feature that allows you to take advantage of the Java platform, but

still utilize code written in other languages. As a part of the Java virtual machine implementation, the JNI is a two-way interface that allows Java applications to invoke native code and vice versa. Figure -

JNI - Two-way interface• As a two-way interface, the JNI can support two types of native code:

- Native libraries and - Native applications.

- Applications call native methods in the same way that they call methods implemented in the Java programming language.

- An invocation interface : Native applications can link with a native library that implements the Java virtual machine, and then ..Use the invocation interface to execute software components written in the Java programming language.

For example, a web browser written in C can execute downloaded applets in an embedded Java virtual machine implemention.

JNI - Risks• It risks losing two benefits of the Java platform

- First, Java applications that depend on the JNI can no longer readily run on multiple host environments. It will be necessary to recompile the part of the application written in native programming languages.- Second, The Java programming language is type-safe and secure, native languages such as C or C++ are not.while this point may be for those OS Development which might have independent hardware licensing issues.

When to Use the JNI ?A number of alternative approaches also allow Java applications to interoperate with code written

in other languages. For example: • A Java application may communicate with a native application through a TCP/IP connection or

through other inter-process communication (IPC) mechanisms. • A Java application may connect to a legacy database through the JDBCTM API. • A Java application may take advantage of distributed object technologies such as the Java IDL

API.

When the JNI becomes useful ?The following scenarios:• Targeted Java API might not support certain host-dependent features

needed by an application. • May want to access an existing native library and are not willing to pay for

the overhead of copying and transmitting data across different processes.• Loading a native library into the existing process hosting the application

requires less system resources than starting a new process and loading the library into that process.

• If a 3D-intensive application spends most of its time in graphics rendering, you may find it necessary to write the core portion of a graphics library in assembly code to achieve maximum performance. Like, Games, Ex-H/W ….

• Have role on the JDK- The JNI was first supported in JDK release 1.1. Internally.- Java 'jdk' is the 'Java Development Kit' and it allows you to compile Java programs.

Develop JNI libraries for Android phonesThe steps that you have to take to develop JNI libraries for Android phones are simple in

principle.

They are outlined below. • Install the JNI/NDK package from Google • Create your Android project • Make a JNI folder in your Android project root directory (called 'jni') • Put your JNI sources in the 'jni' folder • Create an 'Android.mk' file, and place it in the 'jni' folder • Optionally create an 'Application.mk' file, and place it in the 'jni' folder • Open a command line terminal and navigate to the root directory of your Android project. • Execute 'ndk-build', (if it's in your PATH variable) or execute '/path/to/command/ndk-build' • The 'ndk-build' command creates the binary for your library and puts it in the proper folder. • Switch to Eclipse, Refresh the 'Project Explorer View' (F5) • Rebuild the project • Run your project testing your JNI library.

How to code with JNI

Android.mk filesWe'll leave most of the file as it is. • LOCAL_PATH - this line should be left as it is since your source file

('example.c') is in the same directory as the 'Android.mk' file. • include $(CLEAR_VARS) - this line should be left as it is. It is required. • LOCAL_MODULE - this line should be changed to match your module

name. For this tutorial we'll change it to 'example'. This name should not have any spaces in it as it will be made into the actual library's name ('libexample.so' for us).

• LOCAL_CFLAGS - This line can be left as it is. It is for compiler flags. • LOCAL_SRC_FILES - this line should be changed to 'example.c' since

that's our source file. • LOCAL_LDLIBS - leave this the same. • include $(BUILD_SHARED_LIBRARY) - leave this the same.

How to configure a script for making a library and an Android.mk file

• Configure script to generate the – config.h and config.mak files.

– http://code.google.com/p/awesomeguy/wiki/JNITutorial#Overview

– CV Ready + Cygwin Devel Branch + NDK set– YA cam recorder + ffmpeg test project for making

ffmpeg library + Color Conversion yuv2rgb– halfninja-android-ffmpeg-x264-04b62f2 need ffmpeg

library– Test the project + ffmpeg tutorial search