Adding VTK to Android Studio 3.3 project with NDK r17c

Issue

I am trying to add the VTK to my native Android project in AS 3.3. I have installed the NDK r17c. I would like to use some of the VTK functionalities in my native application. Also, I am using gradle 3.3.2 for building my android project and CMake 3.6.4 for building native side of the project. My problem is that I haven't found a suitable tutorial (I am new to Android native development) for importing the VTK into the Android Studio using all building tools that I have described. Is there a way to do that? Also, I would like to add that I am using Windows 7 OS.

EDIT: I had updated my CMakeLists.txt file with some lines I had found relevant in the official example (https://github.com/Kitware/VTK/tree/master/Examples/Android). I would like to use VTK inside my native-lib library:

# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html

# 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.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.

link_directories(src/main/jni/japi src/main/jni/acquisition)

file(GLOB native_SRC
        "src/main/jni/japi/*.h"
        "src/main/jni/japi/*.cpp"
        )

add_library( # Sets the name of the library.
        native-lib

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        ${native_SRC})


file(GLOB acquisition_SRC
        "src/main/jni/acquisition/*.h"
        "src/main/jni/acquisition/*.cpp"
        )
#file(GLOB acquisition_SRC
#        "src/main/jni/acquisition/*.h"
#        )

add_library( acquisition-lib STATIC ${acquisition_SRC})
#add_library(
#        acquisition-lib
#
#        STATIC
#
#        src/main/jni/acquisition/test-lib.h
#        src/main/jni/acquisition/test-lib.cpp)

# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
          log-lib

          # Specifies the name of the NDK library that
          # you want CMake to locate.
          log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
           native-lib

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

target_link_libraries( native-lib acquisition-lib )

set(OpenCV_DIR "../opencv/src/sdk/native/jni")
find_package(OpenCV REQUIRED)
message(STATUS "OpenCV libraries: ${OpenCV_LIBS}")
target_link_libraries(native-lib ${OpenCV_LIBS})
target_link_libraries(acquisition-lib ${OpenCV_LIBS})
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--exclude-libs,libippicv.a -Wl,--exclude-libs,libippiw.a")



##ADDED for including the VTK

find_package(VTK COMPONENTS
        vtkInteractionStyle
        vtkRenderingOpenGL2
        vtkRenderingFreeType
        vtkTestingCore
        vtkTestingRendering
        )
include(${VTK_USE_FILE})

target_link_libraries( native-lib ${VTK_LIBRARIES} )

Solution

Ok, it took me about a week to get this working, but it paid off. I will list all the things I needed to do to be able to use VTK in my android application.

STEP 1: Building VTK on Linux machine

Because Android is based on the Linux OS, you need to build libraries in .a or .so format. To do this, the easiest thing to do is to build VTK on Linux machine. So you have to install Linux to your machine eather as dual boot or, as in my case, install a virtual machine that runs Linux.

After that, you need to install all the thing needed to download and build VTK for Android. Here is the list of the things you need to download and install to your Linux machine:

1. Download and install the Android NDK- I downloaded the same version that I am using in my Android Studio - r17c
2. Download and install the Android SDK , i.e. Android Studio
3. Download and install ANT
4. Download and install Java
5. Download and install CMake - also after I installed it, I needed to run: sudo apt-get update && sudo apt-get install build-essential
6. Download and install Git
7. Install OpenGL - I used: sudo apt-get install freeglut3-dev
8. Define ANDROID_NDK environment variable - point it to unzipped android NDK folder
9. Define ANT_HOME environment variable - point it to unzipped ANT folder
10. Define JAVA_HOME environment variable - point it to unzipped Java JRE folder
11. Define ANDROID_SDK environment variable - point it to the location of Android/Sdk folder
12. Define CMAKE_HOME environment variable - point it to the location of your installed CMake
13. Add to PATH enviroment variable: ANT_HOME/bin, JAVA_HOME/bin, ANDROID_SDK/platform-tools, ANDROID_SDK/tools, CMAKE_HOME/bin

After the installation of the all the needed tools above, you need to download the VTK source code using git:

1. Create an 'vtk' folder somewhere
2. cd vtk
3. git clone https://github.com/Kitware/VTK.git

Now, you can go and build the VTK:

1. mkdir vtk/vtk-android
2. cd vtk-android
3. ccmake ../VTK
4. press c (configure)
5. press c (configure)
6. press q (quit)
7. cmake -DVTK_ANDROID_BUILD=ON -DANDROID_NATIVE_API_LEVEL=23 -DANDROID_ARCH_ABI=arm64-v8a ../VTK - here I defined the 23 api level because that is what I am using in my applicatin. Also, here is where you define the architecture ABI of your targeted devices. My device is arm64-v8a so I am using that. In order to build VTK for other architectures, you will need to build for every each one of them. Also, you can edit this in the next step!
8. ccmake ../VTK

9. OPTIONAL: at this point, you can define additional modules you need in your application. If you just skip this step, the modules (.a files) you will get are:

   vtkCommonColor, vtkCommonComputationalGeometry, vtkCommonCore,
   vtkCommonDataModel, vtkCommonExecutionModel, vtkCommonMath, vtkCommonMisc,
   vtkCommonSystem, vtkCommonTransforms, vtkDICOMParser, vtkdoubleconversion, vtkexpat, vtkFiltersCore, vtkFiltersExtraction, vtkFiltersGeneral, vtkFiltersGeometry, vtkFiltersHybrid, vtkFiltersModeling, vtkFiltersSources, vtkFiltersStatistics, vtkfreetype, vtkglew, vtkImagingCore, vtkImagingFourier, vtkImagingMath, vtkImagingSources, vtkInfovisCore, vtkInteractionStyle, vtkIOCore vtkIOGeometry, vtkIOImage, vtkIOInfovis, vtkIOLegacy, vtkIOPLY, vtkIOXML, vtkIOXMLParser, vtkjpeg, vtkjsoncpp, vtklibxml2, vtklz4, vtklzma, vtkmetaio, vtkParallelCore, vtkpng, vtkRenderingCore, vtkRenderingFreeType, vtkRenderingOpenGL2, vtkRenderingVolume, vtkRenderingVolumeOpenGL2, vtksys, vtkTestingRendering, vtktiff, vtkWrappingTools, vtkzlib

If these modules are not sufficient for you, you need to add some lines to VTK/CMake/vtkAndroid.cmake file because there the build for android is defined. Lines you add must look like:

-DVTK_MODULE_ENABLE_VTK_[name-of-the-module]:STRING=YES

You can find out all possible name-of-the-module values if you press t (toggle) and scroll to VTK_MODULE_ENABLE_VTK_... part of the configuration.

10. c (configue)
11. g (generate)
12. make

Ok, so the build process starts. On my laptop it took ~30mins (I assigned 3GB of RAM to the virtual machine).

STEP 2 : Importing the VTK to the Android Studio

After the build process is finished, you need to copy the folder vtk/vtk-android/CMakeExternals/Install/vtk-android to the your Windows machine. The folder lib contains the build VTK library as a set of static libraries (.a files), and the folder include contains all the header files of the VTK you neeed to get the VTK working in full.

Now, in your Android Studio project, create a new Android Library module called vtk. Create the src/main/jni folder and inside that folder copy the lib and include folder described above.

In jni folder crate an vtk-lib.cpp file which will serve as an interface from your Java code to the VTK library. An example may be:

#include <jni.h>
#include <vtkConeSource.h>

extern "C"
JNIEXPORT void JNICALL
Java_link_to_your_java_function(
        JNIEnv *env,
        jobject /*this*/) {

    vtkConeSource *cone = vtkConeSource::New();
    cone->SetHeight(3.0);
    cone->Delete();

}

In the build.gradle file of your vtk module, add this lines:

android {
    ...

    defaultConfig {
        ...

        externalNativeBuild {
            cmake {
                cppFlags "-std=c++11"
                arguments "-DANDROID_CPP_FEATURES=rtti exceptions",
                        "-DANDROID_STL=gnustl_shared"
                abiFilters 'arm64-v8a'
            }
        }
    }

    ...

    externalNativeBuild {
        cmake {
            path "src/main/jni/CMakeLists.txt"
        }
    }
}

After that, to the jni folder add a CMakeLists.txt file which will be used for building the module:

cmake_minimum_required(VERSION 3.4.1)

set(LIB_DIR ${PROJECT_SOURCE_DIR}/lib/${ANDROID_ABI})

add_library(vtk-common-color STATIC IMPORTED)
set_target_properties(vtk-common-color
    PROPERTIES IMPORTED_LOCATION
    ${LIB_DIR}/libvtkCommonColor-8.90.a)

#53 more libraries from lib folder

add_library( vtk-lib SHARED ${PROJECT_SOURCE_DIR}/vtk-lib.cpp)

target_include_directories(vtk-lib PRIVATE ${PROJECT_SOURCE_DIR}/include)

target_link_libraries(
    vtk-lib
    -Wl,--start-group -L ${TARGET_OUT}
    vtk-common-color
    #53 more libraries names
    -Wl,--end-group
)

And that's it, voila!

Answered By - vp24