Downloaded 52 times
Uploaded bySentinel Solutions Ltd
Android ndk
This document discusses using the Android NDK (Native Development Kit) to build native code components for Android applications. It covers installing the necessary tools like Eclipse, Cygwin, and the NDK itself, and creating a basic "hello world" style app with a Java wrapper and native C library. It also discusses building the FFmpeg library for Android and provides an overview of the Java Native Interface (JNI) which allows Java and native code to interact.
More Related Content
![Vibe Coding vs. Spec-Driven Development [Free Meetup]](https://cdn.slidesharecdn.com/ss_thumbnails/vibecodingvsspecdrivendevelopment-251209105622-43f455e7-thumbnail.jpg?width=640&height=640&fit=bounds)
Android ndk
- 1. Android NDK by Abdun Nur Tomal
- 2. Step 1: InstallingC/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
- 3. Step : InstallingCygwin • 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
- 4. “Install or updateCygwin 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
- 5. 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.
- 7. • Click itonce, 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.
- 8. Android rich programmingenvironment, While the Android SDK provides a very NDK 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.
- 9. NDK Build Two commonuses 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,
- 10. Step 3: Installingthe 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.
- 11. Step 4: Makinga 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.
- 12. • 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!"); }
- 13. • the Cfunction – 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
- 15. • a successfulrun 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.
- 16. Ndk_testActivity class touse 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 native String invokeNativeFunction(); @Override public 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(); } }
- 17. How to BuildFFmpeg for Android • Download Android NDK r5b To 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
- 18. 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.”
- 19. Activity Seems clarify 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.
- 20. 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.
- 21. Role of theJNI • 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 -
- 22. JNI - Two-wayinterface • 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.
- 23. 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.
- 24. When the JNIbecomes 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.
- 25. Develop JNI librariesfor Android phones The 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.
- 26. How to codewith JNI
- 27. Android.mk files We'll leavemost 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.
- 28. How to configurea 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/JNITutor ial#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