Android studio

Unless you are using a game engine with an integrated scripting language, game development is usually done with C++. On the other hand, most Android applications are developed with Java.

This post will explain how to integrate C++ code into Android Studio, use gradle to build it and clear out some misconceptions.

If you used Eclipse you probably know there was a relatively easy way to add "native library" support to your project but now that most projects are being moved to the newer Android Studio it seems like there is no more C++ support. That is incorrect.

There are two ways to add C++ code code into your project. The first is by including prebuilt libraries which you have compiled elsehwere or were pre-compiled for you. The other is to compile them directly from your Android Studio project.

Including pre-built C++ libraries

Including pre-built libraries is simple. Android Studio will look for a specific directory tree and copy all libraries it finds.

The folder structure should be in your Android Studio module's folder and look like this

[module_name][src][main][jniLibs][armeabi][armeabi-v7a][x86][mips]

Make sure the folder tree is located inside your module, not inside your project root. For example [project_root]/app/…

The names of the end folders are the same as the ABI the library was compiled for. Make sure to add new ones when you compile for arm64-v8a,x86-64 and mips64.

This is how it looks like from Android Studio:

Now you can load your shared libraries (.so) from Android using

1 2 String libName = "helloNDK"; // the module name of the library, without .so System.loadLibrary( libName );

Note that compiling a shared library with the ndk generatres a lib + yourModuleName + .so. When loading your library you should only call your module's name, without the prefix and suffix.

Changing the jniLibs folder

If for some reason you want your C++ libraries path to be somewhere else, you can change it by settingsourceSets.main.jniLibs.srcDirs in your module's build.gradle:

1 2 3 4 5 6 7 8 android { // .. android settings .. sourceSets.main { jniLibs.srcDir 'src/main/myCppLibraries' // <-- Set your folder here! } }

Compiling C++ in Android Studio

Adding precompiled libraries is easy but tabbing between terminal and Android Studio can be annoying. If you are developing your C++ code with Android Studio and want it to be compiled when you build your .apk this is how you can do it.

There are 3 things you need to do:

Add ndk.dir variable inside thelocal.properties file.Configure ndk module with gradle.Add C++ files to the expected folder.(Optional) Set product flavors.

Adding ndk.dir variable

The first thing to do is to configure the path to your ndk folder. Inside your proejct's root folder there should be a file called local.properties. Add andk.dir variable directing to your ndk folder. For example:

1 2 sdk.dir=/Users/shanee/Development/Android/sdk ndk.dir=/Users/shanee/Development/ndk

That was easy!

Configuring ndk with gradle

Ok, now to tell gradle to compile our C++ code.

Inside your module's build.gradle file locate your android's defaultConfigsection and add the following:

1 2 3 ndk { moduleName "moduleNameHere" }

Make sure to replace the string with your module's name!

Here is mine for reference:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 android { compileSdkVersion 19 buildToolsVersion "20.0.0" defaultConfig { applicationId "com.example.ndksample" minSdkVersion 9 targetSdkVersion 19 versionCode 1 versionName "1.0" ndk { moduleName "myEpicGameCode" // <-- This is the name of my C++ module! } } // ... more gradle stuff here ... } // end of android section

Note that you can also add additional C++ configuration such as cFlags, stland ldLibs.

1 2 3 4 5 6 ndk { moduleName "myEpicGameCode" cFlags "-DANDROID_NDK -D_DEBUG DNULL=0" // Define some macros ldLibs "EGL", "GLESv3", "dl", "log" // Link with these libraries! stl "stlport_shared" // Use shared stlport library }

Adding C++ source files

Now that Android Studio and Gradle are configured to compile C++ source code it is time to feed them some files!

Naturally, Gradle expects the C++ files to be inside [module]/src/main/jni/. Simply adding your files there will do the trick:

The next time you try to run the application, gradle will build the C++ module for you. It will even shout at you for C++ errors in the gradle console, for example I added thisbad_function:

1 2 3 4 void bad_function() { int myInt = 4; myInt = 10

And gradle responded with:

Changing the folder of your source files

Just like with the jniLibs folder, you can tell gradle to look for your C++ files in a different path. I for example prefer my source code inside source. I can set it by editing thesourceSets.main.jni.srcDirs variable:

1 2 3 4 5 6 7 8 android { // .. android settings .. sourceSets.main { jni.srcDirs 'src/main/source' } }

(Optional) Setting product flavors

You can set different compilation variables for different platforms. For example you might want to define a different macro for x86 and arm to use different optimizations or to include different header files.

You can do this by adding theproductFlavors section under androidin the module's build.gradle file.

The most obvious settin