Cracking the Code: A Beginner’s Adventure into Native Development with Android NDK — Part A

Photo by Guido Coppa on Unsplash

Unveiling the Mystery :

Picture this: you’re a budding Android developer, armed with Java and a quirky sense of humor. Suddenly, you hear whispers of a secret weapon — the NDK. Intrigued, you decide to investigate.

In the world of Android development, there exists a mystical realm known as the Native Development Kit, or NDK for short. Some developers speak of it in hushed tones, while others shy away, fearing its complexity. But fear not, intrepid reader, for we are about to embark on a journey to begin our journey in understanding NDK!

As you start your journey, you discover that the NDK allows you to write code in languages like C and C++, unleashing unparalleled performance and power. It’s like discovering a hidden treasure chest buried beneath layers of Java syntaX!(Pun Intended)

What is NDK??????

Photo by Towfiqu barbhuiya on Unsplash

The Native Development Kit (NDK) is a set of tools provided by Google for Android developers. It allows developers to incorporate native code written in languages like C and C++ into their Android applications. Unlike Java, which runs on the Android Runtime (ART) virtual machine, native code compiled with the NDK runs directly on the device’s CPU, offering performance benefits for computationally intensive tasks.

By leveraging the NDK, developers can optimize performance, access platform-specific features, and reuse existing C/C++ libraries in their Android apps. The NDK provides toolchains, libraries, and build system integration to streamline the development process and enable seamless communication between native code and Java components using the Java Native Interface (JNI).

Imagine you’re on a treasure hunt with friends in an old mansion. You stumble upon a locked chest with mysterious symbols. Your usual methods fail to open it. Enter the Native Development Kit (NDK) — your friend who’s a code-cracking expert. With their help, you quickly decode the symbols and unlock the chest, revealing the treasure inside. Now, armed with their expertise, you and your team can continue the adventure with renewed excitement.

Components of NDK:

1. Header Files (A.K.A. Brain Teasers): Think of header files as the key to unlocking Android’s arcane secrets. They serve as your map, guiding native code straight to the treasures hidden within the Android APIs.
2. Toolchains (The Multitool for Coding Adventurers): Meet the versatile toolchains, your indispensable allies in navigating the Android wilderness. With their arsenal of compilers, linkers, and other tools, they empower you to build native code for different device architectures with ease.
3. C/C++ Libraries (The Avengers of Code): Enter the mighty C/C++ libraries, ready to swoop in and save the day with their pre-built functionalities. From string manipulation to complex computations, they stand as guardians, ensuring your code is armed to conquer any challenge it faces.
4. Build System Integration (CMake, the Master Builder): CMake stands as the architect of your code fortress, laying the groundwork for your app’s construction. With its guidance, you can craft project configurations and manage dependencies with the precision of a master craftsman.
5. Java Native Interface (JNI) (The Babelfish of Code): JNI serves as the bridge between Java and native code, facilitating seamless communication between the two worlds. It allows you to call native functions from Java and vice versa, enabling interoperability in your Android applications.
6. Debugger Support (Sherlock Holmes for Bugs): Debugging native code can feel like solving a mystery, but fear not! With GDB and LLDB at your disposal, you’ll unravel the complexities of your code and banish bugs with the precision of a seasoned detective.
7. Platform APIs (The Playground of Possibilities): Welcome to the playground of Android, where platform APIs offer a myriad of possibilities to explore. From interacting with device hardware to accessing system resources, these APIs empower you to unleash the full potential of your Android applications.

So there you have it — the Native Development Kit demystified in all its quirky glory! With the NDK at your disposal, you can unleash the full potential of your Android apps and embark on epic coding adventures like never before. So strap in, hold onto your hats, and get ready for a wild ride through the native wilderness!

Official documentation of google. https://developer.android.com/ndk

Now, let us begin by taking the first step towards understanding the NDK in Android development

Beginning with JNI (Java Native Interface)

JNI serves as the bridge that connects Java and native code in Android development, enabling seamless communication and interoperability between these two environments. By leveraging JNI, developers can harness the power of native code while retaining the flexibility and platform compatibility of Java applications.

Usage of JNI —

1. Calling Native Code from Java: Java invokes functions implemented in native code for performance-critical tasks.
2. Accessing Java from Native Code: Native code interacts with Java objects and classes, leveraging Java APIs and functionalities.
3. Handling Data Types: JNI facilitates conversion of data types between Java and native code for smooth communication.

More on JNI and its components will be explained in the code in Part B.

CMake

CMake, the master architect of your code castle in Android development. In this expedition, we’ll unravel the mysteries of CMake, its usage, and its indispensable components. CMake is not a build system but rather it generates another system’s build files. Consider it as Gradle of C. The build project contains a CMakeLists.txt file in every directory that controls the build process.

More on CMake can be read from here — https://cmake.org/

Usage of CMake —

1. Project Configuration: Define project settings and configurations in CMakeLists.txt files.
2. Build Automation: Automate compilation, linking, and packaging across platforms.
3. Dependency Management: Easily include external libraries and packages in your project.
4. Cross-Compilation: Support for building software for different target platforms.

LLDB

LLDB is a modern debugger provided by the LLVM project, designed for debugging native code written in languages like C, C++, and Objective-C. It offers a wide range of features and capabilities for analyzing and diagnosing issues in native code during development and testing.

Too much confusion, eh??

Lemme explain it in more simpler manner….

Embark on a daring adventure through the realms of Android development with LLDB, JNI, and CMake as your trusty companions. LLDB acts as your navigator’s compass, guiding you through the debugging depths of native code. JNI serves as a mystical translator’s amulet, bridging the language barriers between Java and native realms. Meanwhile, CMake stands as the builder’s blueprint, crafting the foundations for your code castle with precision. Together, these invaluable treasures unlock hidden treasures, ensuring your quest for Android greatness is a resounding success.

Now we will setup our system to start coding —

To set up your system for NDK development in Android Studio, follow these steps:

1. Install Android Studio: Download and install the latest version of Android Studio from the official website.
2. Install NDK and CMake:

• Open Android Studio and navigate to File > Settings (or Android Studio > Preferences on macOS).
• In the Settings/Preferences dialog, go to Appearance & Behavior > System Settings > Android SDK.
• Click on the SDK Tools tab and check the box next to “Android NDK or Android NDK(Side-by-Side)” to install it.
• Also install “CMake”
• Follow the on-screen instructions to complete the installation process.

3. Configure NDK Location:

• Open Android Studio and navigate to File > Settings (or Android Studio > Preferences on macOS).
• In the Settings/Preferences dialog, go to Appearance & Behavior > System Settings > Android SDK.
• Click on the SDK Tools tab and check the box next to "Android NDK" to install it.
• Follow the on-screen instructions to complete the installation process.

4. Configure NDK Location:

• After installing the NDK, you need to configure its location in Android Studio.
• Go to File > Project Structure.
• In the Project Structure dialog, select SDK Location from the left menu.
• Set the “Android NDK location” to the directory where you installed the NDK.
• Click Ok to save the changes.

5. Create or Import NDK Project:

• You can create a new NDK project or import an existing one into Android Studio.
• To create a new project, go to File > New > New Project > Empty Compose Activity or Native C++ library we will use Empty Compose Activity to begin with and integrate our code with Android, and select as the language.

Now we will one step closer to the treasure chest to understand the NDK development in Android now in Part B of this article, we will experience some hands on for this.

Cracking the Code: A Beginner’s Adventure into Native Development with Android NDK — Part B