I included a Boost-Header file to my test project using CMakeLists.txt. My some.cpp can include this header without any error, but i'm not able to run since the header file relies obviously on other Boost headers and its not finding the required files. The location of my files is in cpp folder and the boost files are in (C:\boost) a subdirectory:
..\src\main\cpp\boost\RequiredHeader.hpp.
For the include files in the "RequiredHeader" the compiler is looking at:
..\src\main\cpp\boost\boost\AnotherHeader.hpp.
CMakeLists.txt (Boost-part)
# ADD BOOST
message("Import Boost...\n")
set(Boost_USE_STATIC_LIBS OFF)
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME OFF)
set(Boost_INCLUDE_DIRS C:/boost_1_64_0/boost)
find_package(Boost 1.64.0)
if(Boost_FOUND)
message("Boost found! Link libraries...\n")
include_directories(${Boost_INCLUDE_DIRS})
target_link_libraries(myDependantLib ${Boost_LIBRARIES})
endif()
Your help is highly appreciated!
Updated question:
How to tell CMake where my Boost header files are, since it still is not finding the right location, with BOOST_ROOT set?
Updated CMakeLists.txt
# ADD BOOST
message("Add boost...\n")
set(Boost_USE_STATIC_LIBS OFF)
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME OFF)
set(BOOST_ROOT C:/boost_1_64_0)
set(BOOST_INCLUDE_DIR C:/boost_1_64_0/boost)
FIND_PACKAGE(Boost 1.64.0 COMPONENTS foreach REQUIRED)
if(Boost_FOUND)
message("Boost found! Link libraries...\n")
target_link_libraries(calculator LINK_PUBLIC ${Boost_LIBRARIES})
endif()
This post here helped me in resolving this.
Include Boost-Header files and libs:
set(BOOST_ROOT C:/boost)
The path containing the include headers "boost/*.hpp" and libraries "stage/lib" or any other path where your compiled files have been output.
Then you need to specify the include header and libs paths. In the default case the headers are stored in the same directory as the root (since "boost" folder is searched automatically) and the libs as described in "stage/lib". Otherwise it should be "include" and "lib" of your output directory, while the boost version has to be corresponding to the one specified in version.hpp in the "boost" folder:
set( Boost_INCLUDE_DIR ${BOOST_ROOT}/include )
set( Boost_LIBRARY_DIR ${BOOST_ROOT}/lib )
set( Boost_Version 1_64 )
find_package( Boost ${Boost_Version} COMPONENTS system thread )
if( Boost_FOUND )
target_include_directories( <your_lib> PUBLIC/PRIVATE ${Boost_INCLUDE_DIR} )
# its possible to include boost to system path too:
# include_directories( SYSTEM ${Boost_INCLUDE_DIR} )
link_directories( ${Boost_LIBRARY_DIR} )
target_link_libraries( <your_lib> ${Boost_LIBRARIES} )
endif()
Then i was able to simply:
#include <boost/random.hpp>
#include <boost/whatever.hpp>
This worked for me on following environment:
Android Studio 2.3.1 and 3.0
NDK 14.1
Boost 1.56.0 and 1.64.0
Windows 10
If further explanation is needed, please comment your concerns!
Related
I am trying to use Protocol Buffers in C++ under Android (x86, x86_64, armeabi-v7a, arm64-v8a). Using these build scripts, I have been able to generate libprotobuf.a static libraries for the different architectures.
However, I am struggling to make the connection between the static libraries and the test_spec.pb.cc and test_spec.pb.h files that I generated with my system's global protobuf compiler of the same version (3.19.2).
What I have tried
I have tried setting both the Protobuf_LIBRARY and Protobuf_LIBRARIES to the path to libprotobuf.a
I have tried setting Protobuf_INCLUDE_DIRS and Protobuf_INCLUDE_DIR to the include directory I generated running the extract_includes.bat.in script in protobuf's cmake folder
I have tried finding protobuf using find_package( Protobuf REQUIRED ) and find_package( Protobuf REQUIRED HINTS _path_to_dir_containing_lib_and_include_)
I have tried setting Protobuf_SRC_ROOT_FOLDER to a directory containing libprotobuf.a and the include folder
This is my current CMakeLists.txt
cmake_minimum_required(VERSION 3.5)
set (CMAKE_VERBOSE_MAKEFILE ON)
set (CMAKE_CXX_STANDARD 11)
set(CMAKE_PREFIX_PATH
${CMAKE_PREFIX_PATH}
${CMAKE_PREFIX_PATH}/../cpp
)
ADD_LIBRARY(protobuf STATIC IMPORTED)
SET_TARGET_PROPERTIES(protobuf PROPERTIES IMPORTED_LOCATION ../cpp/libs/${ANDROID_ARCH}/google/protobuf/libprotobuf.a)
INCLUDE(FindProtobuf)
SET(Protobuf_USE_STATIC_LIBS ON)
SET(Protobuf_SRC_ROOT_FOLDER ../cpp)
SET(Protobuf_LIBRARIES protobuf)
SET(Protobuf_INCLUDE_DIR ../cpp/include/google/protobuf)
FIND_PACKAGE(Protobuf REQUIRED)
ADD_LIBRARY(cpp
SHARED
../cpp/rn-etsi-parser.cpp
cpp-adapter.cpp
)
# Specifies a path to native header files.
INCLUDE_DIRECTORIES(
../cpp
)
And this is the current error I get when I run it:
CMake Error at CMakeLists.txt:18 (FIND_PACKAGE):
Could not find a package configuration file provided by "Protobuf" with any
of the following names:
ProtobufConfig.cmake
protobuf-config.cmake
Add the installation prefix of "Protobuf" to CMAKE_PREFIX_PATH or set
"Protobuf_DIR" to a directory containing one of the above files. If
"Protobuf" provides a separate development package or SDK, be sure it has
been installed.
Thank you for your help!
Thanks to David's nudge and various CMake/C++ tutorials I was able to figure out a solution that works for my use case.
What I did:
I moved both libprotobuf.a as well as the respective include to a folder within my PROJECT_SOURCE_DIR
I cleaned up my eclectic mix of find_package, add_library, and find_protobuf
I added the linker flag -llog to bypass this issue
cmake_minimum_required(VERSION 3.5)
set (CMAKE_VERBOSE_MAKEFILE ON)
set (CMAKE_CXX_STANDARD 11)
set (CMAKE_SHARED_LINKER_FLAGS "-llog")
list(APPEND CMAKE_PREFIX_PATH [
${CMAKE_PREFIX_PATH}
])
ADD_LIBRARY(protobuf STATIC IMPORTED)
SET_TARGET_PROPERTIES(protobuf PROPERTIES IMPORTED_LOCATION ${PROJECT_SOURCE_DIR}/src/main/jniLibs/google/protobuf/${ANDROID_ABI}/libprotobuf.a)
INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/main/jniLibs/include/)
ADD_LIBRARY(cpp
SHARED
../cpp/rn-etsi-parser.cpp
cpp-adapter.cpp
)
TARGET_LINK_LIBRARIES(cpp PUBLIC protobuf)
# Specifies a path to native header files.
INCLUDE_DIRECTORIES(
../cpp
)
I'd be interested to know, however, if there is a way to 'inject' prebuilt protobuf libraries into CMake's find_protobuf workflow, so that I could make use of features like protobuf_generate_cpp.
I'm working on an Android project which uses a Java class that is a wrapper on a C++ library. The C++ library is a company internal library and we have access to its source code, but in the Android project it is only dynamically linked, so it is used only in the form of headers (.h) and shared objects (.so). Having access to the library source code, is it possible to specify to Android Studio the path to the source code so I can step inside the library using the debugger?
The debugger works, I can step inside the Java_clory_engine_sdk_CloryNative_nativeInit function, but I would also like to further debug the library corresponding to the Clory::Engine class which, as I mentioned, is an internal library we have source code access to.
For example, Clory::Engine::instance is part of the library and I would like to specify to Android Studio the location of the CloryEngine.cpp file so I can step inside Clory::Engine::instance with the debugger, thus debugging this static member function.
I am using Android Studio 3.1.4.
Is this possible?
EDIT:
The clory-sdk.gradle file specifies the CMakeLists.txt file which configures the C++ layer.
externalNativeBuild {
cmake {
path "CMakeLists.txt"
}
}
So I am using an internal application which uses the Clory SDK. Inside the app.gradle file I use:
dependencies {
...
compile project(':clory-sdk-core')
compile project(':clory-sdk')
...
}
so I don't think we're using the aars for the app.gradle project. The aars are shipped to the client, but we are using app.gradle project to test our little SDK functionalities before doing that. The JNI layer is inside clory-sdk-core project.
EDIT 2:
Here is the CMakeLists.txt which handles the JNI layer:
cmake_minimum_required(VERSION 3.4.1)
set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_BUILD_TYPE Debug)
add_library(
clory-lib
SHARED
# JNI layer and other helper classes for transferring data from Java to Qt/C++
src/main/cpp/clory-lib.cpp
src/main/cpp/JObjectHandler.cpp
src/main/cpp/JObjectResolver.cpp
src/main/cpp/JObjectCreator.cpp
src/main/cpp/DataConverter.cpp
src/main/cpp/JObjectHelper.cpp
src/main/cpp/JEnvironmentManager.cpp
)
find_library(
log-lib
log
)
target_compile_options(clory-lib
PUBLIC
-std=c++11
)
# Hardcoded for now...will fix later...
set(_QT_ROOT_PATH /Users/jacob/Qt/5.8)
if(${ANDROID_ABI} MATCHES ^armeabi-v7.*$)
set(_QT_ARCH android_armv7)
elseif(${ANDROID_ABI} MATCHES ^x86$)
set(_QT_ARCH android_x86)
else()
message(FATAL_ERROR "Unsupported Android architecture!!!")
endif()
set(CMAKE_FIND_ROOT_PATH ${_QT_ROOT_PATH}/${_QT_ARCH})
find_package(Qt5 REQUIRED COMPONENTS
Core
CONFIG
)
target_include_directories(clory-lib
PUBLIC
${CMAKE_CURRENT_LIST_DIR}/src/main/cpp
)
set(_CLORYSDK_LIB_PATH ${CMAKE_CURRENT_LIST_DIR}/src/main/jniLibs/${ANDROID_ABI})
target_link_libraries(clory-lib
${log-lib}
-L${_CLORYSDK_LIB_PATH}
clorysdk
Qt5::Core
)
The library clorysdk is actually our internal library I was talking about, which contains e.g. Clory::Engine::instance I would like to step into with the debugger. It was built with qmake and is built in debug mode (CONFIG+=debug was added in the effective qmake call).
EDIT 3:
In the LLDB session which has opened after it hit the Java_clory_engine_sdk_CloryNative_nativeInit breakpoint, I got the following:
(lldb) image lookup -vrn Clory::Engine::instance
2 matches found in /Users/jacob/.lldb/module_cache/remote-android/.cache/6EDE4F0A-0000-0000-0000-000000000000/libclorysdk.so:
Address: libclorysdk.so[0x0001bb32] (libclorysdk.so..text + 8250)
Summary: libclorysdk.so`Clory::Engine::instance(Clory::Engine::Purpose)
Module: file = "/Users/jacob/.lldb/module_cache/remote-android/.cache/6EDE4F0A-0000-0000-0000-000000000000/libclorysdk.so", arch = "arm"
Symbol: id = {0x0000005e}, range = [0xcb41eb32-0xcb41ebc0), name="Clory::Engine::instance(Clory::Engine::Purpose)", mangled="_ZN4Clory2Engine8instanceENS0_7PurposeE"
Address: libclorysdk.so[0x0001b82c] (libclorysdk.so..text + 7476)
Summary: libclorysdk.so`Clory::Engine::instance(Clory::RuntimeConfiguration const&, Clory::Engine::Purpose)
Module: file = "/Users/jacob/.lldb/module_cache/remote-android/.cache/6EDE4F0A-0000-0000-0000-000000000000/libclorysdk.so", arch = "arm"
Symbol: id = {0x000000bd}, range = [0xcb41e82c-0xcb41e970), name="Clory::Engine::instance(Clory::RuntimeConfiguration const&, Clory::Engine::Purpose)", mangled="_ZN4Clory2Engine8instanceERKNS_20RuntimeConfigurationENS0_7PurposeE"
(lldb) settings show target.source-map
target.source-map (path-map) =
First of all, there was no CompileUnit section in the result of the command image lookup -vrn Clory::Engine::instance. How is this possible to have no source-map defined(second lldb command) if the libclorysdk.so was built in Debug mode? Is it possible to explicitly set it so that the debugger would search there for the library's source files?
EDIT 4:
After searching more I found out that the process of creating the APK actually strips the *.so libraries from their debugging symbols. libclorysdk.so built in debug mode has about 10MB while the libclorysdk.so file which I extracted after unarchiving the generated *.apk file is just 350KB.
As stated here, running greadelf --debug-dump=decodedline libclorysdk.so on the debug version outputs references to the source files, but if the command is run on the *.apk extracted library, it outputs nothing.
Is there a way to stop Android Studio from stripping the *.sos? I tried How to avoid stripping for native code symbols for android app but didn't have any effect, *.apk file is the same size as before and debugging the native libraries still doesn't work.
I'm using Gradle 3.1.4.
EDIT 5:
The stripping solution works, but in my case, it needed a Clean & Build before hitting the breakpoints in the library. Deploying *.sos which are not stripped is allowing you to have debugging sessions and step inside the native libraries.
Note:
If the libraries are built using the Qt for Android toolchain, the *.sos deployed to $SHADOW_BUILD/android-build are also stripped(where $SHADOW_BUILD is the build directory usually starting with build-*). So in order to debug those you should copy them from outside the android-build directory where each *.so is generated.
The debug info records the location of the source files when they were built.
(lldb) image lookup -vrn Clory::Engine::instance
The CompileUnit line shows the source file. Suppose it says:
"/BuildDirectory/Sources/Clory/CloryEngine.cpp"
Let's assume you have the source on your machine here:
"Users/me/Sources/Clory"
So you can tell lldb: find the source file rooted at /BuildDirectory/Sources/Clory in Users/me/Sources/Clory instead.
(lldb) settings set target.source-map /BuildDirectory/Sources/Clory Users/me/Sources/Clory
You can use these commands in the lldb console of Android Studio or put into a .lldbinit file for general use.
If there no debug symbols available, you might have to build the referenced library in debug mode.
Either with -DCMAKE_BUILD_TYPE=DEBUG:
defaultConfig {
externalNativeBuild {
cmake {
arguments "-DANDROID_TOOLCHAIN=gcc", "-DCMAKE_BUILD_TYPE=DEBUG"
cppFlags "-std=c++14 -fexceptions -frtti"
}
}
}
externalNativeBuild {
cmake {
path file('src/main/cpp/CMakeLists.txt')
}
}
Or add this to the CMakeLists.txt of the library:
set(CMAKE_BUILD_TYPE Debug)
See the CMake documentation and Symbolicating with LLDB.
Elsewhere it explains (lldb) settings set target.source-map /buildbot/path /my/path:
Remap source file path-names for the debug session. If your source files are no longer located in the same location as when the program was built --- maybe the program was built on a different computer --- you need to tell the debugger how to find the sources at their local file path instead of the build system's file path.
There's also (lldb) settings show target.source-map, to see what is mapped.
(lldb) set append target.source-map /buildbot/path /my/path seems rather suitable, in order not to overwrite existing mappings.
I tried with this example, but nothing happens:
cmake_minimum_required(VERSION 3.8)
project(cmake_simulator)
set(CMAKE_SYSTEM_NAME Android)
set(CMAKE_SYSTEM_VERSION 21)
set(CMAKE_ANDROID_ARCH_ABI x86)
set(CMAKE_ANDROID_NDK /home/icarolima/Android/Sdk/ndk/21.3.6528147)
set(CMAKE_ANDROID_STL_TYPE gnustl_static)
set(CMAKE_TOOLCHAIN_FILE /home/icarolima/Android/Sdk/ndk/21.3.6528147/build/cmake/android.toolchain.cmake)
find_package(verilator HINTS $ENV{VERILATOR_ROOT} ${VERILATOR_ROOT})
if (NOT verilator_FOUND)
message(FATAL_ERROR "Verilator was not found. Either install it, or set the VERILATOR_ROOT environment variable")
endif()
# Create a new executable target that will contain all your sources
add_library(simulator SHARED simulator.cpp)
# Add the Verilated circuit to the target
verilate(simulator
INCLUDE_DIRS "."
SOURCES top.sv
VERILATOR_ARGS -Wno-CASEINCOMPLETE -Wno-WIDTH -Wno-COMBDLY -cc +1800-2012ext+sv)
For example, if I change the CMAKE_ANDROID_ARCH_ABI to anything else, nothing happens. It is like CMake is ignoring the NDK part of the code.
But If I change the project to another location, different things happen:
cmake_minimum_required(VERSION 3.8)
set(CMAKE_SYSTEM_NAME Android)
set(CMAKE_SYSTEM_VERSION 21)
set(CMAKE_ANDROID_ARCH_ABI x86)
set(CMAKE_ANDROID_NDK /home/icarolima/Android/Sdk/ndk/21.3.6528147)
set(CMAKE_ANDROID_STL_TYPE gnustl_static)
project(cmake_simulator)
set(CMAKE_TOOLCHAIN_FILE /home/icarolima/Android/Sdk/ndk/21.3.6528147/build/cmake/android.toolchain.cmake)
find_package(verilator HINTS $ENV{VERILATOR_ROOT} ${VERILATOR_ROOT})
if (NOT verilator_FOUND)
message(FATAL_ERROR "Verilator was not found. Either install it, or set the VERILATOR_ROOT environment variable")
endif()
# Create a new executable target that will contain all your sources
add_library(simulator SHARED simulator.cpp)
# Add the Verilated circuit to the target
verilate(simulator
INCLUDE_DIRS "."
SOURCES top.sv
VERILATOR_ARGS -Wno-CASEINCOMPLETE -Wno-WIDTH -Wno-COMBDLY -cc +1800-2012ext+sv)
The error:
CMake Error at /home/icarolima/Android/Sdk/cmake/3.10.2.4988404/share/cmake-3.10/Modules/Platform/Android/Determine-Compiler-NDK.cmake:97 (message):
Android: No toolchain for ABI 'x86' found in the NDK:
/home/icarolima/Android/Sdk/ndk/21.3.6528147
I have no experience with CMake, I think that the problem is the order of the things. Can anyone help me?
Setting all of these variables (such as CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_VERSION, CMAKE_ANDROID_ARCH_ABI, etc.) should happen in the toolchain file. You may certainly experience some nasty CMake behavior by putting these in the CMakeLists.txt file itself. There is even a sample toolchain file in the CMake documentation you linked here.
Also, the CMAKE_TOOLCHAIN_FILE variable should be set on the command line when you call cmake, not in the CMake file itself. This reduces your CMakeLists.txt file to something like this:
cmake_minimum_required(VERSION 3.8)
project(cmake_simulator)
find_package(verilator HINTS $ENV{VERILATOR_ROOT} ${VERILATOR_ROOT})
if (NOT verilator_FOUND)
message(FATAL_ERROR "Verilator was not found. Either install it, or set the VERILATOR_ROOT environment variable")
endif()
# Create a new executable target that will contain all your sources
add_library(simulator SHARED simulator.cpp)
# Add the Verilated circuit to the target
verilate(simulator
INCLUDE_DIRS "."
SOURCES top.sv
VERILATOR_ARGS -Wno-CASEINCOMPLETE -Wno-WIDTH -Wno-COMBDLY -cc +1800-2012ext+sv)
Then, you should call cmake, specifying the toolchain file to use, like this:
cmake -DCMAKE_TOOLCHAIN_FILE=/home/icarolima/Android/Sdk/ndk/21.3.6528147/build/cmake/android.toolchain.cmake ..
So, just to clarify, the way I solved it can be seen here: Dockerfile, and here: sandbox_template.
Thanks for the answers #squareskittles!
I'm developing a C++ library for Android, and I have as dependency the libpng. I'm using the modified library for Android https://github.com/julienr/libpng-android.git, which has a build.sh file in order to compile for the different architectures. Or it can be compiled using ndk-build.
I'm Fetching the library from CMake using FetchContent, this effectively download the sources files, but it doesn't build properly. I'm setting the BUILD_COMMAND but it doesn't work.
FetchContent_Declare( png
GIT_REPOSITORY https://github.com/julienr/libpng-android.git
GIT_TAG master
UPDATE_DISCONNECTED TRUE
STEP_TARGETS update
BUILD_COMMAND "${NDK_PATH}/ndk-build.cmd NDK_PROJECT_PATH=${png_SOURCE_DIR}"
FetchContent_GetProperties(png)
if (NOT png_POPULATED)
FetchContent_Populate(png)
add_subdirectory("${png_SOURCE_DIR}" "${png_BINARY_DIR}" EXCLUDE_FROM_ALL)
endif()
It seems that the BUILD_COMMAND do nothing.
So, How can I fetch and build the libpng-android from CMake, and then import that result as an imported library?
To complete the Tsyvarev comment with references, according to the doc...
The following options are explicitly prohibited (they are disabled by the
FetchContent_Populate() command):
CONFIGURE_COMMAND
BUILD_COMMAND
INSTALL_COMMAND
TEST_COMMAND
ref: https://cmake.org/cmake/help/latest/module/FetchContent.html#command:fetchcontent_getproperties (just the paragraph above)
Thanks to #Tsyvarev and #Mizux I can follow the correct way to do it.
FetchContent_Declare( libpng
GIT_REPOSITORY https://github.com/julienr/libpng-android.git
GIT_TAG master
UPDATE_DISCONNECTED TRUE
STEP_TARGETS update)
FetchContent_GetProperties(libpng)
if (NOT libpng_POPULATED)
FetchContent_Populate(libpng)
add_subdirectory("${libpng_SOURCE_DIR}" ${libpng_BINARY_DIR} EXCLUDE_FROM_ALL)
endif()
exec_program("${CMAKE_ANDROID_NDK}/ndk-build.cmd"
${libpng_BINARY_DIR}
ARGS NDK_PROJECT_PATH=${libpng_SOURCE_DIR} APP_ABI=${ANDROID_ABI})
and then linking the libraries
target_link_libraries( project
PRIVATE
${libpng_SOURCE_DIR}/obj/local/${ANDROID_ABI}/libpng.a
)
My project is fairly simple. I have an app that includes a library written based on integration platfrom so it looks something like this:
My app
----> Extension
----> Main library
The app is cross-compiled to Android. All of them are based on CMake. I'm using CLion as an IDE. I've added a profile with custom toolchain required to build for Android (that is clang, clang++ for apropiate platform, cmake from Android SDK and make from Android NDK r20b). Problem is I have to call CMake 3 times (reload it in CLion) before it generates all of the files needed. Whole file is listed below.
On the first run it ignores the fact it is build for android (doesn't go into if (ANDROID) ) and copies the prebuilt sub-executable for linux (default)
On the second run it ignores the needed android.toolchain.cmake and when build on this stage it fails to add android headers to search path BUT chooses correct prebuilt sub-executable
On the the third run it uses the android.toolchain.cmake file AND chooses correct sub-executable.
After that I can hit build and everything compiles correctly.
The CMake I have:
add_executable(androidApp main.cpp)
target_include_directories(androidApp
PUBLIC
../submodules/exten/src/libraries/main_lib/lib/include
../submodules/exten/src/libraries/main_lib/sdk/rlogging/include) //Headers from main library
target_link_libraries(androidApp
PRIVATE
exten) //Extension
install(TARGETS androidApp DESTINATION ${CMAKE_SOURCE_DIR}/bin)
install(FILES ../submodules/exten/src/libraries/main_lib/integration_app/resources/someFile.zip DESTINATION ${CMAKE_SOURCE_DIR}/bin)
install(FILES ../resources/someFile2.zip DESTINATION ${CMAKE_SOURCE_DIR}/bin/resources)
file(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/bootsafe)
file(WRITE ${CMAKE_SOURCE_DIR}/bin/bootsafe/dummy "") //Required dir
add_custom_command(TARGET dongleApp POST_BUILD
COMMAND ${CMAKE_SOURCE_DIR}/ndk/android-ndk-r20b/toolchains/llvm/prebuilt/linux-x86_64/arm-linux-androideabi/bin/strip --strip-debug dongleApp
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Stripping debug symbols")
if (ANDROID)
target_link_libraries(androidApp
PRIVATE
log)
endif (ANDROID) //Linking android lib
On different CMake (on the main library level) here's how the choosing on correct prebuilt is written
if(NOT ANDROID)
set(PREBUILD_NAME "linux")
else()
if(ANDROID_ABI STREQUAL "x86_64")
set(PREBUILD_NAME "android-x86")
else()
set(PREBUILD_NAME "android-arm")
endif()
endif()
The command that is used to generate makefiles:
/home/gravlok/companyName/app_v2/sdk/cmake/3.10.2.4988404/bin/cmake
-DCMAKE_BUILD_TYPE=Debug
-DCMAKE_MAKE_PROGRAM=/home/gravlok/companyName/app_v2/ndk/android-ndk-r20b/prebuilt/linux-x86_64/bin/make
-DCMAKE_C_COMPILER=/home/gravlok/companyName/app_v2/ndk/android-ndk-r20b/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi28-clang
-DCMAKE_CXX_COMPILER=/home/gravlok/companyName/app_v2/ndk/android-ndk-r20b/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi28-clang++
-DANDROID=ON
-DCMAKE_TOOLCHAIN_FILE=/home/gravlok/companyName/app_v2/ndk/android-ndk-r20b/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=android-28
-G "CodeBlocks - Unix Makefiles"
/home/gravlok/companyName/app_v2
Why do I need to run it 3 times in order to configure correctly?