Building Shared Libraries with CMake and Android NDK

Building shared libraries using CMake and Android NDK is a crucial skill for developers looking to integrate native code into their Android applications. This process allows you to leverage the performance benefits of C++ while maintaining compatibility with Java or Kotlin through the Java Native Interface (JNI) . In this blog post, we will explore the steps required to build shared libraries using these tools.

Understanding the Tools

Before diving into the technical details, it’s essential to understand what each tool does:

• Android NDK (Native Development Kit): This set of tools enables you to implement parts of your app using native-code languages such as C and C++. It provides headers and libraries that allow you to build activities, handle user input, and run other tasks necessary for running an Android application .

• CMake: An external build tool that works alongside Gradle to build your native code. CMake uses a build script named CMakeLists.txt to manage the compilation process .

Setting Up Your Environment

To get started, ensure that you have installed the following components in your development environment:

1. Android Studio with support for C++ projects.
2. The Android NDK, which can be downloaded via the SDK Manager within Android Studio.
3. CMake, also available through the SDK Manager under "SDK Tools".

Once these are set up, you can create a new project in Android Studio that supports C++ or modify an existing project to include native code.

Creating a Shared Library

The first step in creating a shared library is to write your native code. For example, let’s say you want to create a simple function that returns a string from C++. You would start by writing the corresponding C++ file, say native-lib.cpp.

Next, you need to create a CMakeLists.txt file in your app’s src/main/cpp directory. This file tells CMake how to compile your source files into a shared library. Here’s a basic example of what this might look like:

# Sets the minimum version of CMake required to build the native library.
cmake_minimum_required(VERSION 3.4.1)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
add_library( # Specifies the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.cpp )

# Searches for a previously imported library named log.
find_library( log-lib
              log )

# Specifies libraries CMake should link to your target library.
target_link_libraries( # Specifies the target library.
                       native-lib

                       # Links the target library to the log library.
                       ${log-lib} )

This script defines a shared library called native-lib, compiles native-lib.cpp, and links against the Android logging library so you can output logs from your native code.

Integrating with Gradle

After setting up the CMakeLists.txt, you must inform Gradle about your native code. Open your module-level build.gradle file and add the externalNativeBuild block inside the android section:

android {
    ...
    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
            version "3.10.2" // Optional: specify the CMake version if needed
        }
    }
}

With this configuration, Gradle knows where to find your CMake script and how to invoke CMake during the build process.

Using the Shared Library in Java/Kotlin

Finally, once the shared library is built, you can load it in your Java or Kotlin code and call its functions. Add the following line to your Activity class to load the native library:

static {
    System.loadLibrary("native-lib");
}

Then declare any native methods you wish to expose to Java/Kotlin. These methods should match those defined in your C++ code.

Conclusion

By mastering the art of building shared libraries with CMake and the Android NDK, developers gain access to powerful optimization techniques that can significantly enhance app performance. Whether you’re working on computationally intensive tasks or reusing existing C++ libraries, understanding this workflow opens up new possibilities for Android development. Remember to consult official documentation and community resources when troubleshooting specific issues, as they often contain valuable insights based on real-world experiences .