[cmake-developers] CMake integration in Gradle (Android Studio)

[Florent Castelli]

I tried the Gradle + CMake integration and I'm not really impressed.
I would recommend not using it right now until they fix the rough edges.

The prime concern is that it is REALLY hard to get the CMake output and 
compilation output,
even within Android Studio. If you compile from command line, you won't 
see much.
This is a no go for CI environments where you need to see what went 
wrong and also some
output once in a while (or builds are usually considered stuck and 
canceled if they take too long).
See the issue: https://code.google.com/p/android/issues/detail?id=210930

Installing CMake within the SDK is not trivial. There's an open bug with 
a proposed solution,
it's not pretty stuff but does the work: 
https://code.google.com/p/android/issues/detail?id=221907
An alternative would be to repackage your SDK folder after running 
Android Studio and installing
everything you need and distribute that to your CI build machines / 
developer machines.

But essentially, what you want is probably just use their toolchain 
file, which is much better
than the OpenCV one. You can find it bundled in the latest NDK and I 
guess you could be using
that directly with CMake. If it is doing weird things, I guess you could 
have a look at it and debug it.
It's not as complicated as the OpenCV one and I hope you'll find the 
solution to your issues!

As for CMake 3.7, when I asked about it in this mailing list, someone 
said there will be
a compatibility layer to the toolchain to reuse the upstream support 
when it's available
if I remember correctly.

/Florent

On 25/10/2016 15:48, Robert Dailey wrote:
> I'm not sure if the CMake mailing lists are the right place to ask
> this question but I thought I'd ask just in case someone has gone down
> this path or has experience with what Google/Gradle is actually trying
> to accomplish with what seems to be a hand-built version of CMake with
> custom patches that are not in upstream repositories.
>
> Prior to switching to Android Studio / Gradle, I was using Eclipse /
> Ant. The way I did CMake integration was not really integration at
> all: I generated Ninja build scripts using CMake and implemented
> custom targets to run "ant release" after all the C++ projects were
> built. I made sure that CMake copied relevant *.so files to
> appropriate directories in the Ant structure so they are packaged with
> built APKs. That's how I did my Android development.
>
> Now that I'm integrating CMake into Gradle, first annoyance I noticed
> is that I can't use CMake 3.7 (or any external installation of CMake)
> with Android Studio. It requires a version of CMake installed through
> SDK Manager. This means I can't use the new Android toolchain
> functionality built into CMake 3.7 (sad face). But this is something I
> can work around...
>
> Next I found out that stuff I'm setting in my CMake scripts, such as
> CPP flags like `-std=c++14` and `-fexceptions` was not being applied.
> For whatever reason, Gradle is overriding these from the command line
> (I'm guessing?). So this requires me to duplicate the toolchain /
> compiler flag setup I already do in my CMake scripts now in the Gradle
> build scripts. This seems completely unnecessary and a maintenance
> burden.
>
> What I was expecting Gradle to do was essentially provide me some
> toolchain file so that CMake can find the compiler and linker to use
> and then the rest would be determined by CMake itself.
>
> Is there a way I can tell Gradle to not take so much control over
> compiler flags? I want my CMake scripts to do this. I can't imagine
> they had a good reason to do this. What have others done in this
> situation with their own Gradle + CMake integration? Looking for
> advice here, since information is sparse, especially since the Android
> Studio 2.2 CMake integration is relatively new stuff.