I am trying to build a bridge between Java and C++ using Protobuf for serialization and storage purpose, inside an Android Studio project. Things work well on the Java side. Using the JavaLite plugin, I am able to generate the classes for each file.
Where things start to break is trying to do the same on the native side. I've tried many things and I came to the conclusion that using cmake would be the best way to get there. However, I am running into some issues.
Cmake doesn't seem to know about protobuf. When I add these lines to CMakeList.txt:
include(FindProtobuf)
find_package(Protobuf REQUIRED)
include_directories(${PROTOBUF_INCLUDE_DIR})
I am getting:
-- Could NOT find Protobuf (missing: Protobuf_LIBRARIES Protobuf_INCLUDE_DIR)
which is strange since my version passes the smoke test:
cmake_minimum_required(VERSION 3.4.1)
Sanity check, from terminal:
$ protoc --version
libprotoc 3.5.1
What are the other option to generate C++ protobuf in Android Studio? Would NDK-build be another option?
Related
i have downloaded the vtk from source both the latest version 9.1.0 and the previous version
8.2.0,
configured and generate a project file with no error, built the source in visual studio and it was a success also installed it.
but when i run a simple example as SIMPLE as this one https://kitware.github.io/vtk-examples/site/Cxx/GeometricObjects/CylinderExample/
it crashes with
I also tried to set it up with QT but i also am getting a crash in QVTKOpenGLWidget.
It looks like whatever version I am installing whether its a stand alone or in QT i ant seem to make VTK run.
I am using and configuring VTK for visual studo 2019.
maybe because the 'DEBUG/RELEASE' building setting? here
if you use 'DEBUG' to build your code,try change it to 'RELEASE'.
With Android Studio 3.3 I use native (C++) library, which I built with CMake. The Android plugin (v. 3.2.1) will choose the 'builtin' or 'external' cmake, depending on the configuration of externalNativeBuild, as documented at developer.android.com.
I want to add an extra custom task (install) that should use the same cmake version as the Android Plugin. But even with the 'builtin' cmake, it's not clear what the path is. I can find android.sdkDirectory, but even there I have today sdk\cmake\3.6.4111459 and sdk\cmake\3.10.2.4988404, and for some strange reason, some of my projects choose 3.6, while others use 3.10. This contradicts the official the release notes for Android Studio that "Gradle still uses version 3.6.0 by default", but well…
How can I decide which to use, without reimplementing the Android Plugin's obscure logic?
One workaround that may help, parse the first line of the generated file .externalNativeBuild/cmake/debug/armeabi-v7a/cmake_build_command.txt:
Executable : C:\local\Android\sdk\cmake\3.10.2.4988404\bin\cmake.exe
This still needs some adjustments, because the later versions of build tools will use .cxx instead of .externalNativeBuild; the build variant names may be different too.
Android Studio will pick up the latest CMake version under sdk\cmake, but you can configure your particular version from
externalNativeBuild {
cmake {
...
version "cmake-version"
}
}
And specify our custom CMake director as below inside local.properties
cmake.dir="path-to-cmake"
Or, you can choose NOT to upgrade your CMake from SDK Manager (just to delete the sdk\cmake\<version to delete> folder will be fine) so that you can stick to the CMake version your project is comfortable with.
I'm working on a c/c++ cross-platform project, constructed of 2 main libraries (with a few external dependencies: ssl, yajl, fribidi).
The android solution will include Java files and a JNI layer, all bundled in a AAR file (including assets and the native libs).
I managed to build the whole project, but in a very awkward way:
I created a 'hello world' Android app', with native support, from within Android Studio, and added all native dependencies to the CMAkeList.txt. I added my Java code + JNI and managed to create the AAR (only for ARM, for now).
Now I need to separate the build of the different libraries, to their separate projects, respectively: libA, libB and C.aar.
How is it done without the IDE (and via command-line)?
There's the stand-alone NDK, the make_standalone_toolchain.py script, android.toolchain.cmake and other options, but none are documented or up-to-date. Most documentation still talks about the outdated Android.mk methodology.
I'd presume including android.toolchain.cmake in my CMakeList.txt, which will set all needed environment...
I'm using the newest Android Studio 3.0.1 and NDK r16b (installed via SDK Manager)
Alex - thanks, exactly what I was looking for. Just had to add a few flags and a call to make:
> cmake -G "MinGW Makefiles" -DCMAKE_TOOLCHAIN_FILE=%ANDROID_NDK%\build\cmake\android.toolchain.cmake -DANDROID_NATIVE_API_LEVEL=android-19 -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK%\prebuilt\windows-x86_64\bin\make.exe -DCMAKE_BUILD_TYPE=Release -DANDROID_ABI="armeabi-v7a with NEON" ..
> cmake --build .
Android Studio (the standard Android gradle plugin, that is) does not support native-only modules, but you can split your CMake script and work with libA and libB separately. You can run cmake from command line (but better use the version that is shipped with Android SDK).
sdk/cmake/3.6.4111459/bin/cmake -DCMAKE_TOOLCHAIN_FILE=sdk/ndk-bundle/build/cmake/android.toolchain.cmake ...
The easiest way to build the AAR file that includes a compiled Java wrapper and the two native libraries would be with Android Studio, but you can run the gradle task from command line. This is what we typically do on a build server.
I am trying to compile my fork of ReactOS using CMake 3.9.0-MSVC_2 (as included with Visual Studio 2017, 15.4 update). When I have CMake generate NMake makefiles or Ninja inputs, it works just fine. However, when I tell CMake to generate a Visual Studio 2017 solution, it fails with a weird error. Here's how to reproduce this issue:
Clone git#github.com:SunburstApps/ReactOS. (It's a big repo, so please be patient. I have not been able to consistently reproduce this issue on a smaller project, in case anyone asks.)
In the root of the project directory, run configure.cmd VSSolution from a VS2017 x86 C++ tools command prompt. This will tell CMake to generate a Visual Studio solution (the exact version is inferred from the copy of cl.exe in the path).
I get the following CMake output:
-- The C compiler identification is unknown
-- The CXX compiler identification is unknown
CMake Error at CMakeLists.txt:24 (project):
The CMAKE_C_COMPILER:
cl
is not a full path and was not found in the PATH.
CMake Error at CMakeLists.txt:24 (project):
The CMAKE_CXX_COMPILER:
cl
is not a full path and was not found in the PATH.
-- Configuring incomplete, errors occurred!
Investigating the CMakeError.log file reveals the problem is actually something else. The vcxproj file that CMake generated to identify the compiler is refusing to link, complaining that ucrtd.lib can't be found. If I add the following line of code to the top-level CMakeLists.txt file, it will then progress slightly further (successfully identifying the compiler), only to die of the same issue during a try_compile() run to "detect compiler features".
set(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION 10.0.15063.0)
I have come to the conclusion that CMake is generating files without the Windows SDK target platform set, which is causing VS to refuse to locate ucrtd.lib. The set() line above tells CMake to add that specific version to the vcxproj files it generates, but clearly it doesn't add it to all of them.
I have tried other solutions I have found searching SO, including installing the Windows 8.1 SDK and running the CMake command as an administrator. Nothing helps. I need to generate a solution file so I can write code for this project using Visual Studio's excellent C++ editor. (I have also tried using the built-in CMake support in VS2017, but have found that it does not quite work due to ReactOS' specific cross-compiling requirements.) Can anyone give me some pointers? Thanks!
I just installed the latest android SDK and NDK. I want to get familiar with OpenSL so I started with the native-audio example project in ndk/samples and I'm having trouble with native-audio-jni.c file. Eclipse cannot resolve any of the include files and doesn't recognize any of the OpenSL definitions. Doesn't even know what NULL means. I can build the project but once I open the .c file (once the file runs through the parser) the project won't build any more.
Other people have had the same problems and many solutions exist but none of them works for the latest SDK.
How can I fix all these errors?