In this codelab, you'll learn how to use Android Studio to start Android NDK project development.

What you'll learn

What you'll need

How will you use this tutorial?

Read it through only Read it and complete the exercises

How would rate your experience with building Android apps?

Novice Intermediate Proficient
  1. Find and start Android Studio on your development system:
    a) Linux: Run studio.sh from your installed location
    b) OSX: Find studio installation in Application folder, double click to start
    If this is the first time you run this version of Android Studio on this system, Android Studio will prompt to import from previous settings, just select "I do not have a previous version of Studio or I do not want to import my settings", "Welcome to Android Studio" will be displayed.
  2. Select "Start a new Android Studio project".
  3. On "New Project" page, change "Application Name" to HelloAndroidJni, and leave the default values for other fields.

  4. Click "Next", select "Basic Activity" as our template in "Add an Activity to Mobile" page
  5. Click "Next" all the way to "Finish" to complete application creation.
    This creates an Android "Hello World" Java app; your Android Studio looks like:

  6. (Optional) Connect your Android Device with USB cable if you have device available; otherwise, create an Emulator when Android Studio prompts you in the next step.
  7. Sync , Build and Run , you will see the following on your target device or Emulator:

  8. Configure the project to use gradle wrapper.
    a) On Mac OS, menu "Android Studio" > "Preferences".
    b) On Linux, menu "File" > "Settings".
    c) Then "Build, Execution, Deployment" > "Build Tools" > "Gradle".
    d) Select "Use Default Gradle wrapper (recommended)", click "OK".
  9. Configure Android Studio to download NDK
    a) Menu "Tools" > "Android" > "SDK Manager"
    b) Select tab "SDK Tools"
    c) Check "Android NDK"[ or "NDK"] if it is not checked
  10. Sync , Build and Run , you should see the same as in step 6.

Android Studio supports native development via experimental plugin developed by Google, let's add it into our project.

  1. Find the latest gradle-experimental plugin version[currently is 0.7.2 at the writing]. Open project build.gradle in Android Studio's "Project" window.
  2. Replace gradle plugin
classpath 'com.android.tools.build:gradle:2.1.0'

with your latest version[it does not have to be 0.7.2]:

classpath 'com.android.tools.build:gradle-experimental:0.7.2'
  1. Change to the latest gradle version (2.10 is required for plugin version 0.7.0).
    Select Android Studio "Project" pane, "Gradle Scripts" > "gradle-wrapper.properties (Gradle Version)" and change:
    distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
    to:
    distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip
  2. Convert the auto-generated module build.gradle to Gradle's component model DSL.
    Select Android Studio "Project" pane > "Gradle Scripts" > "build.gradle (Module: app)" and replace:
apply plugin: 'com.android.application'

android {
   compileSdkVersion 23
   buildToolsVersion "23.0.1"

   defaultConfig {
       applicationId "com.google.sample.helloandroidjni"
       minSdkVersion 22
       targetSdkVersion 23
       versionCode 1
       versionName "1.0"
   }
   buildTypes {
       release {
           minifyEnabled false
           proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
       }
   }
}
// others below this line: no change

with:

apply plugin: 'com.android.model.application'

model {
   android {
       compileSdkVersion 23
       buildToolsVersion "23.0.3"

       defaultConfig {
           applicationId "com.google.sample.helloandroidjni"
           minSdkVersion.apiLevel 22
           targetSdkVersion.apiLevel 23
           versionCode 1
           versionName "1.0"
       }
       buildTypes {
           release {
               minifyEnabled false
               proguardFiles.add(file('proguard-android.txt'))
           }
       }
   }
}
// others below this line: no change

NOTE: the version numbers may be different on your system, and you do not need to change the version number -- just use them as is. Only changing the highlighted part would be fine!

  1. Sync , Build and Run . You should still see the same "Hello World" on your target device.
  1. Check the NDK Path.
    Select the menu "File" > "Project Structure" > "SDK Location", "Android NDK Location" if it is not set yet, then click "...", and browse to your NDK location and click "OK" (you may also choose "download").
  2. Configure the module build.gradle to create "hello-android-jni" shared lib.
    Select Android Studio "Project" pane > "Gradle Scripts" > "build.gradle (Module:app)", add the following inside the "model" block, after "buildTypes" block.
buildTypes {
...
}
// New code
ndk {
    moduleName "hello-android-jni"
}
// New code finished
  1. Add JNI function and load jni shared lib into project.
    Select Android Studio "Project" pane > "app" > "java" > "com.google.sample.helloandroidjni" > "MainActivity", and add JNI function getMsgFromJni() and System.loadLibrary() to the end of class MainActivity.
...
   // new code
   static {
       System.loadLibrary("hello-android-jni");
   }
   public native String getMsgFromJni();
   // new code done
} // class MainActivity
  1. Sync , Build , there should be no errors from Android Studio.

Note:

  1. Generate the C/C++ prototype function for jni function getMsgFromJni().
    In MainActivity.java file, "getMsgFromJni()" is highlighed with red because Android Studio could not find its implementation; let's get it implemented:
#include <jni.h>

JNIEXPORT jstring JNICALL
Java_com_google_sample_helloandroidjni_MainActivity_getMsgFromJni(JNIEnv *env, jobject instance) {

   // TODO
  
   return (*env)->NewStringUTF(env, returnValue);
}
// TODO
return (*env)->NewStringUTF(env, "Hello From Jni");
  1. Display our JNI message in the application.
((TextView) findViewById(R.id.jni_msgView)).setText(getMsgFromJni());
  1. Click the Run button, you should see "Hello From Jni" in your target device.
  2. Browse the Native Code
  1. Click the Run/Debug Configuration
    [For Android Studio version earlier than 2.2, select . Android Studio auto-generates this native debug configuration when it detects JNI code. In this config, debug configurations are enabled by default. If is not visible, close this project and reopen it with Android Studio, it will be there; Android Studio version 2.2 integrated the debug functionality into app configure].
  2. Open hello-android-jni.c inside Android Studio.
  3. Click the left edge of the native code to set a breakpoint:
  4. Click the Debug button, your android device should prompt "Waiting For Debugger" message:
  5. Wait until Android Studio connects to the debugger on your device ( it might take 1 - 2 minutes, depending on the device and OS version ), and stops at the breakpoint.
  6. Click "env" inside the "Variables" window at the bottom pane of Android Studio to observe contents of env pointer.
  7. Click "+" at the bottom of the "Watches" window (next to "Variables") and add "env", Android Studio will bring the content of env into watch window. The values should be the same as the values in "Variables" window.
  8. Click the "F8" key to step over, and menu "Run" > "Resume Program" to continue the execution.

[Note: if you are using Android Studio RC 1.5 or better, you can set a breakpoint on getMsgFromJni() in Java code and "trace into" JNI code]

Your app is now ready to use Android Studio for your Native project development!

What we've covered with Android Studio

Next Steps

Learn More

Tell us how we did