Android NDK – Writing Performance-Critical Code in C/C++ - Textnotes

Android NDK – Writing Performance-Critical Code in C/C++

Learn how to use Android NDK (Native Development Kit) to write performance-critical portions of your Android app using C/C++. This tutorial covers the basics of the NDK, setting up your development environment, and integrating native code into Android apps.

The Android NDK (Native Development Kit) allows developers to write parts of their Android applications using C and C++, which can result in improved performance for specific use cases like graphics rendering, physics simulations, or handling large datasets. The NDK is designed for developers who need to optimize specific parts of their application for better performance.

In this tutorial, we’ll explore Android NDK and how to set up and use C/C++ code in your Android apps for performance-critical operations.

i) What is Android NDK?

The Android NDK is a toolset that enables developers to write portions of their app using native code (in C and C++). Native code is compiled and executed directly by the device's hardware, offering significant performance improvements over Java code for some computationally heavy tasks.

Key Features of Android NDK:

  1. Native Code Execution: Write performance-critical parts of your app in C/C++.
  2. Low-level System Access: Interact directly with the device’s hardware and operating system, giving more control over memory and CPU usage.
  3. Optimization: Useful for apps that require intensive computation, such as games, video processing, and scientific applications.

ii) When to Use the NDK?

While using native code can result in performance improvements, it should be used selectively. Some scenarios where NDK can be helpful include:

  1. High-performance gaming or graphics rendering.
  2. Signal processing and other real-time audio processing.
  3. Machine learning or computationally intensive algorithms.
  4. Accessing platform-specific features not available in the Java APIs.

However, Java should be used for the general app logic unless performance becomes a bottleneck, as native code can introduce complexity and platform-specific dependencies.

iii) Setting Up the NDK in Android Studio

  1. Install the NDK:
  2. In Android Studio, go to File > Settings > Appearance & Behavior > System Settings > Android SDK.
  3. Under the SDK Tools tab, check NDK (Side by side) and CMake and then click OK to install.
  4. Create a New Project with NDK Support:
  5. Open Android Studio and create a new project using the Native C++ template.
  6. This template provides a starter code with necessary CMake and NDK setup.
  7. Android Studio will automatically generate a CMakeLists.txt file and a native-lib.cpp file where you can write your C/C++ code.
  8. Add Native Support to an Existing Project:
  9. If you already have a project, you can add NDK support by modifying the build.gradle files.
  10. In your build.gradle (app-level), you will need to include the externalNativeBuild block:

android {
compileSdkVersion 30
defaultConfig {
applicationId "com.example.nativeapp"
minSdkVersion 21
targetSdkVersion 30
externalNativeBuild {
cmake {
cppFlags "-std=c++11"
}
}
}

externalNativeBuild {
cmake {
path "CMakeLists.txt"
}
}
}
  1. You also need a CMakeLists.txt file in the root of the project that specifies how to compile your C/C++ code. This file helps Android Studio understand how to build your native library.
  2. Write Your C/C++ Code:
  3. Once the NDK is set up, you can write your C/C++ code in the cpp files.
  4. The generated native-lib.cpp file provides an entry point to implement native functions.

iv) Writing and Calling Native Code

  1. Create a Native Method in your Java/Kotlin code:
  2. In your MainActivity.java or MainActivity.kt file, declare a native method using the native keyword:

public class MainActivity extends AppCompatActivity {

// Load the native library
static {
System.loadLibrary("native-lib");
}

// Declare a native method
public native String stringFromJNI();
}
  1. Implement the Native Function in C/C++:
  2. Implement the native method in C/C++ in the native-lib.cpp file:

#include <jni.h>
#include <string>

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_nativeapp_MainActivity_stringFromJNI(JNIEnv* env, jobject /* this */) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}
  1. The JNIEXPORT and JNICALL keywords are part of the JNI (Java Native Interface) to link the C/C++ code to Java.
  2. Calling the Native Code:
  3. The stringFromJNI method in Java/Kotlin is now ready to be called. For example, in the MainActivity:

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// Call the native method
TextView tv = findViewById(R.id.sample_text);
tv.setText(stringFromJNI());
}
  1. This will display the string returned from the native method on the screen.

v) Using CMake for Native Code Compilation

CMake is the preferred build system for compiling C/C++ code with the NDK. CMakeLists.txt is a file where you specify the source files and how to build the native library.

For example, a basic CMakeLists.txt file could look like this:


cmake_minimum_required(VERSION 3.4.1)

# Specify the native library
add_library(native-lib SHARED
src/main/cpp/native-lib.cpp)

# Link the library to Android's standard libraries
find_library(log-lib log)

target_link_libraries(native-lib
${log-lib})

This CMake configuration tells Android Studio to compile native-lib.cpp and link it with the log library (used for logging in native code).

vi) Debugging Native Code

Android Studio provides tools for debugging C/C++ code, including:

  1. NDK Debugging: Use the LLDB debugger to step through your C/C++ code.
  2. Logcat: Print log messages from native code using __android_log_print or LOGI to debug.
  3. Native Profiler: Android Studio provides profiling tools to analyze CPU and memory usage of native code.

vii) JNI (Java Native Interface)

The JNI allows Java/Kotlin code to call native methods written in C/C++, and it’s the bridge between Java and native code. You need to write JNI code that allows Java to call C/C++ functions and pass data between them.

Example:

  1. Pass data from Java to C/C++ and back.
  2. Handle memory management for native objects.

viii) Best Practices for Using the NDK

  1. Avoid Excessive Use of Native Code: Only use NDK for performance-critical parts of your app, as managing native code is more complex and error-prone than Java/Kotlin.
  2. Use JNI Efficiently: Minimize the number of JNI calls between Java and C/C++ code, as each call can add overhead.
  3. Memory Management: Be careful with memory management in C/C++, as Android’s garbage collector doesn’t manage memory in native code.
  4. Cross-Platform Code: If you need your app to run on both Android and other platforms (e.g., iOS), consider using CMake and NDK to write cross-platform C/C++ code.

ix) Conclusion

The Android NDK is a powerful tool for writing performance-critical code in C/C++. It allows developers to harness the full potential of the device’s hardware for high-performance operations. However, native code adds complexity to app development, so it should only be used when necessary for specific performance bottlenecks.

By following best practices for integrating native code, using CMake for compiling, and leveraging JNI for seamless communication between Java/Kotlin and C/C++, you can effectively build performance-optimized Android applications.