We assume that you have opened the Panorama project. We need to import the converted OpenCV Android SDK in the previous section as follows:

File | New | Import Module

In the New Module window, we will select the source directory to the converted project. In our case, we will choose /Volumes/Data/OpenCV/opencv-java. Then, we'll check the import checkbox, change the module name to :opencv-java, as shown in the following screenshot and click Finish:

A new module window

Next, we need to modify build.gradle in the app folder to add one line to the dependencies section:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.1.1'

    compile project(":opencv-java")
}

Finally, we must sync the project with the button Sync Project with Gradle Files.

static {
    //If you use OpenCV 2.*, use "opencv_java"
    System.loadLibrary("opencv_java3");
}

Before we start the compile process, we will create a class file named NativePanorama.java and add a method to the NativePanorama class:

public class NativePanorama {
    public native static void processPanorama(long[] imageAddressArray, long outputAddress);
}

The processPanorama method will receive an array of long addresses of each image and a long address of an output image.

You must rebuild the project in order to follow the ensuing steps. The detailed explanation is in the next paragraph:

You may notice the keyword native before the processPanorama method. This means that we will use this method to interact between Java and C++ in our application. Therefore, we need to create some headers and source files to implement our C++ code. We must follow Java Native Interface (JNI) to use C++ code, so the process may be a bit complex and out of the scope of this book.

In the following parts, we will show you the steps to use OpenCV C++.

First, we will use the javah command in the terminal to create the corresponding C++ header for the processPanorama method. In order to do this, you need to open the terminal on your machine, then change the directory to the folder app/src/main in your Android application and run the following command:

javah -d jni -classpath ../../build/intermediates/classes/debug/ com.example.panorama.NativePanorama

You only need to verify the package name and the name of the class file, NativePanorama. The command will not display anything on the terminal, as shown in the following figure. You may want to rebuild the project if you encounter the following error: Error: Could not find class file for 'com.example.panorama.NativePanorama'.

The terminal after using the javah command

As the result of the javah command, we now have a folder named jni in our app/src/main folder with a file com_example_panorama_NativePanorama.h. This header contains a function to work with Java Interface. When processPanorama is called, this function will run in C++.

Next, we will create a source file named com_example_panorama_NativePanorama.cpp in the jni folder. We recommend that you should copy the function declaration from the header file to the source file and add the parameter names as follows:

#include "com_example_panorama_NativePanorama.h"
JNIEXPORT void JNICALL Java_com_example_panorama_NativePanorama_processPanorama
  (JNIEnv * env, jclass clazz, jlongArray imageAddressArray, jlong outputAddress){
}

The only thing left is that we need to compile OpenCV C++ SDK to use it in the preceding source file.

In order to use OpenCV in C++ code, we need to compile OpenCV C++ and use an Android.mk file as the make file to build and link our C++ file with OpenCV library. However, Android Studio doesn't support Android.mk out of the box. We need to do lots of things to make this happen.

First, we will open the local.properties file and set ndk.dir to be your path to the Android NDK folder. In our case, the local.properties will look like this:

sdk.dir=/Users/quanhua92/Library/Android/sdk
ndk.dir=/Users/quanhua92/Software/android-ndk-r10e

Secondly, we open the build.gradle file in our app folder and add this line at the top:

import org.apache.tools.ant.taskdefs.condition.Os

Then, we need to add the following code between the defaultConfig tag and buildType tag to create a new Gradle task to build C++ code.

// begin NDK OPENCV
sourceSets.main {
    jni.srcDirs = [] //disable automatic ndk-build call
}
task ndkBuild(type: Exec, description: 'Compile JNI source via NDK') {
    def rootDir = project.rootDir
    def localProperties = new File(rootDir, "local.properties")
    Properties properties = new Properties()
    localProperties.withInputStream { instr ->
        properties.load(instr)
    }
    def ndkDir = properties.getProperty('ndk.dir')
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        commandLine "$ndkDir\ndk-build.cmd",
                'NDK_PROJECT_PATH=build/intermediates/ndk',
                'NDK_LIBS_OUT=src/main/jniLibs',
                'APP_BUILD_SCRIPT=src/main/jni/Android.mk',
                'NDK_APPLICATION_MK=src/main/jni/Application.mk'
    } else {
        commandLine "$ndkDir/ndk-build",
                'NDK_PROJECT_PATH=build/intermediates/ndk',
                'NDK_LIBS_OUT=src/main/jniLibs',
                'APP_BUILD_SCRIPT=src/main/jni/Android.mk',
                'NDK_APPLICATION_MK=src/main/jni/Application.mk'
    }
}
tasks.withType(JavaCompile) {
    compileTask -> compileTask.dependsOn ndkBuild
}
//end

You may want to look at the following figure for a screenshot of our build.gradle.

A screenshot of our build.gradle

Next, we create a file named Application.mk in the jni folder and put the following lines in it:

APP_STL := gnustl_static
APP_CPPFLAGS := -frtti -fexceptions
APP_ABI := all
APP_PLATFORM := android-16

Finally, we create a file named Android.mk in the jni folder and set up this file as below to use OpenCV in our C++ code. You may need to change the OPENCVROOT variable to the location of OpenCV-android-sdk in your machine:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
#opencv
OPENCVROOT:= /Volumes/Data/OpenCV/OpenCV-android-sdk
OPENCV_CAMERA_MODULES:=on
OPENCV_INSTALL_MODULES:=on
OPENCV_LIB_TYPE:=SHARED
include ${OPENCVROOT}/sdk/native/jni/OpenCV.mk

LOCAL_SRC_FILES := com_example_panorama_NativePanorama.cpp
LOCAL_LDLIBS += -llog
LOCAL_MODULE := MyLib

include $(BUILD_SHARED_LIBRARY)

With the preceding Android.mk, Android Studio will build OpenCV into libopencv_java3.so and build our C++ code into libMyLib.so in the folder app/src/main/jniLibs. We have to open our MainActivity.java and load this library to use in our application as follows:

public class MainActivity extends ActionBarActivity {
    static{
        System.loadLibrary("opencv_java3");
        System.loadLibrary("MyLib");
    }