IssueTracker

This is part a documentation bug and part a feature request.

THE PROBLEM

Gradle offers two options for building C code for use with Android NDK: ndkBuild and cmake. They cannot be mixed.

If your .gradle contains both a externalNativeBuild { ndkBuild { path '...' } } } and a externalNativeBuild { ndkBuild { cmake '...' } } }, it prints the error "A problem occurred configuring project ':appname'. > More than one externalNativeBuild path specified". (I found this error wording unhelpful; when I first encountered it I could not decipher it because (1) the line numbers of neither "path" directive are provided, and (2) due to includes, the two conflicting "path" directives were in different files.)

On paper, Gradle allows for multi-project builds wherein some subprojects are ndkBuild and some are cmake. However, ndkBuild and CMake are isolated in a way which makes such builds in practice broken. Targets/modules from the CMake world cannot be referenced from the ndkBuild world or vice versa, environment variables (say, include paths) can't be passed between the two. The targetsmodules are the most critical problem because they mean you cannot have a CMake subproject as a dependencies {} from an ndkBuild subproject or vice versa. See "A Repro Case" below: ndkBuild subproject A can list CMake subproject B in dependencies {}, *but B will run after A, not before*, which means that A will fail because the outputs of B have not been created yet. It is my theory that this happens because Gradle is not aware of any files which are an output of B and a input of A (because I have not been given a way to describe these files to Gradle), so it will ignore the dependencies {}.

These limitations are not documented. They are not listed in https://developer.android.com/ndk/guides/cmake , or in https://developer.android.com/studio/projects/add-native-code . In https://developer.android.com/studio/projects/gradle-external-native-builds it *is* mentioned "Each module in your Android project can link to only one CMake or ndk-build script file", but if you read that full paragraph it goes on to describe how to fit multiple CMake files or multiple ndk-build scripts while misleadingly eliding what happens if you need both a CMake and an ndk-build file in one project.

WHY THIS IS A PROBLEM

There are various libraries which are distributed as source and whose build scripts use either ndkBuild, or CMake. Including both of these in a single project or multi-project build is extremely painful and apparently impossible without compromises. Google is encouraging NDK projects to migrate to CMake, but currently using CMake means cutting oneself off from the body of existing ndkBuild libraries.

The example I personally hit: The Oculus Mobile SDK https://developer.oculus.com/downloads/package/oculus-mobile-sdk/ for Oculus Go Android headsets comes with only ndkBuild libraries and sample code; on the other hand LOVR https://lovr.org/ an open-source VR framework I contribute to, has only CMake build scripts. It would be very difficult to port LOVR to ndkBuild because of its size and I do not think I can port the Oculus library to CMake because only the people at Oculus properly understand its internals. I have only been able to build a project with both Lovr and the Oculus libraries by invoking gradle twice (see "unsuccessful workarounds" below), which is very slow, and even this required freakish glue code.

EXPECTED BEHAVIOR

First off, the behavior should be documented. If mixing CMake and ndkBuild is not supported, that fact should be findable in the documentation. If there's some recommended workaround, such as a certain way of configuring multi-project builds, this technique should be documented.

It should be possible to make a multi-project build where some subprojects are ndkBuild and some are CMake. dependencies {} should work properly in these cases, and I should not have to resort to directly listing the paths of intermediate build directories such as build/intermediates/cmake. Perhaps you can come up with a better way of achieving this than me, but here is how I would make this work: Both ndkBuild and CMake have the notion of a target (CMake calls these "targets", ndkBuild calls them "Modules"). It should be possible to reference an ndkBuild module as a CMake Target and vice versa. I should be able to say "LOCAL_SHARED_LIBRARIES := buildtest" in a Android.mk if my CMakeLists has a "add_library(buildtest ...)", for example. If I have to do some kind of "LOCAL_MODULE := buildtest" "include ${CMAKE_LIBRARY}" to make this work, that's fine.

It would be wonderful if there were some way to pass a variable (a CMake "SET", an ndkBuild "var :=") between the CMake and ndkBuild worlds. I guess this is less critical since variables *can* be bassed down from gradle to both.

It would be nice if the "more than one path specified" error message was clearer.

A REPRO CASE

Here https://github.com/mcclure/android-ndk is a minimal example of the problem based on the googlesamples android-ndk repository. The repro case is in other-builds/ndkbuild/hello-libs and is a recreation of the actual problem my "LOVR" project encountered in https://github.com/mcclure/lovr-oculus-mobile . The example:

I git clone https://github.com/googlesamples/android-ndk.git . I go in the directory other-builds/ndkbuild/hello-libs . I create a completely minimal CMake library which has one (empty) C source file and a message("BUILDING CMAKE TEST PROJECT") in the CMakeLists. I list it as a dependency of the app/ project in settings.gradle and app/build.gradle. I build this, with:
(export PATH="/Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin":~/Library/Android/sdk/platform-tools:$PATH ANDROID_HOME=~/Library/Android/sdk GRADLE=`pwd`/gradlew; ($GRADLE build))
When I build, I see "BUILDING CMAKE TEST PROJECT" in the flow, so I know that my CMakeLists is running. You can find this version listed as 45ff8b1ce.

I next make my CMake subproject not just a dependency, but I make the app/ project actually depend on it. I amend app/'s Android.mk to have a PREBUILT_SHARED_LIBRARY module. This is *super* ugly and horrific, it requires me to order things very precisely in the Android.mk and directly reference the build/intermediates folder, but this is the only way I know to do it This version is listed as a2a9607ac65. When I try to build a2a9607ac65, something interesting happens. On my first build, it works fine. I then try "git clean -xffd". This erases all build products. If I build after git cleaning, the build fails. It prints:

  Android NDK: ERROR:/Users/mcc/work/gh/other/android-ndk/other-builds/ndkbuild/hello-libs/app/Android.mk:buildtest: LOCAL_SRC_FILES points to a missing file    
  Android NDK: Check that /Users/mcc/work/gh/other/android-ndk/other-builds/ndkbuild/hello-libs/app/../cmakelib/build/intermediates/cmake/debug/obj/armeabi-v7a/libbuildtest.so exists  or that its path is correct  
  /Users/mcc/Library/Android/sdk/ndk-bundle/build/core/prebuilt-library.mk:45: *** Android NDK: Aborting    .  Stop.

I then try building the cmakelib subproject standalone, with
(export PATH="/Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin":~/Library/Android/sdk/platform-tools:$PATH ANDROID_HOME=~/Library/Android/sdk GRADLE=`pwd`/gradlew; (cd cmakelib && $GRADLE build))
Once I have done this standalone build of the subproject, I am able to build the top level project again.

In other words: The top level build, which depends on the output of cmakelib, is able to build as long as the cmakelib build runs first, either because it ran on a previous run or I built cmakelib separately. Listing :cmakelib as a "dependency" does not cause it to run first, I actually have to invoke gradle twice. I find invoking gradle twice to be an unacceptably scary (and slow!) solution, in addition to which the PREBUILT_SHARED_LIBRARY build code having to reference build/intermediates is unacceptably scary. This overall-unacceptably-scary solution is, as mentioned, the one currently being used in my "lovr-oculus-mobile" project linked above, which is currently shipping, and the README simply asks the user to invoke gradle twice. There appears to be no other way to do it.

CONFIGURATION

Gradle version: If I run gradlew -v I get:
------------------------------------------------------------
Gradle 4.4
------------------------------------------------------------
Build time:   2017-12-06 09:05:06 UTC
Revision:     cf7821a6f79f8e2a598df21780e3ff7ce8db2b82
Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.9 compiled on February 2 2017
JVM:          1.8.0_152-release (JetBrains s.r.o 25.152-b01)
OS:           Mac OS X 10.13.2 x86_64

Android Plugin Version: My gradle file contains:
          compileSdkVersion 21
          buildToolsVersion '27.0.3'
                  minSdkVersion 21
                  targetSdkVersion 21

Android SDK Tools version:  "Select Tools > Android > SDK Manager, click SDK Tools"
"Android SDK Build-Tools" "Version" is blank and "Status" says "Installed"
"Android SDK Platform-Tools" "Version" is "28.0.1" and "Status" is "Installed"
"Android SDK Tools" "Version" is "26.1.1" and "Status" is "Installed"
NDK" "Version" is "18.1.5063045" and "Status" is "Installed"