diff --git a/cmake/android/OpenCVDetectAndroidSDK.cmake b/cmake/android/OpenCVDetectAndroidSDK.cmake index f2f21f5f70..3a4ffefa43 100644 --- a/cmake/android/OpenCVDetectAndroidSDK.cmake +++ b/cmake/android/OpenCVDetectAndroidSDK.cmake @@ -8,6 +8,24 @@ if(DEFINED ANDROID_NDK_REVISION AND ANDROID_NDK_REVISION MATCHES "(1[56])([0-9]+ set(ANDROID_NDK_REVISION "${ANDROID_NDK_REVISION}" CACHE INTERNAL "Android NDK revision") endif() +# fixup -g option: https://github.com/opencv/opencv/issues/8460#issuecomment-434249750 +if((INSTALL_CREATE_DISTRIB OR CMAKE_BUILD_TYPE STREQUAL "Release") + AND NOT OPENCV_SKIP_ANDROID_G_OPTION_FIX +) + if(" ${CMAKE_CXX_FLAGS} " MATCHES " -g ") + message(STATUS "Android: fixup -g compiler option from Android toolchain") + endif() + string(REPLACE " -g " " " CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} ") + string(REPLACE " -g " " " CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} ") + string(REPLACE " -g " " " CMAKE_ASM_FLAGS " ${CMAKE_ASM_FLAGS} ") + if(NOT " ${CMAKE_CXX_FLAGS_DEBUG}" MATCHES " -g") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g") + endif() + if(NOT " ${CMAKE_C_FLAGS_DEBUG}" MATCHES " -g") + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g") + endif() +endif() + # https://developer.android.com/studio/command-line/variables.html ocv_check_environment_variables(ANDROID_SDK_ROOT ANDROID_HOME ANDROID_SDK) diff --git a/cmake/android/android_gradle_projects.cmake b/cmake/android/android_gradle_projects.cmake index 1ca752f8b2..ebad46a403 100644 --- a/cmake/android/android_gradle_projects.cmake +++ b/cmake/android/android_gradle_projects.cmake @@ -1,5 +1,151 @@ -message(FATAL_ERROR " -Android gradle-based build/projects are not supported in this version of OpenCV. -You need to downgrade Android SDK Tools to version 25.2.5. -Details: https://github.com/opencv/opencv/issues/8460 +# https://developer.android.com/studio/releases/gradle-plugin +set(ANDROID_GRADLE_PLUGIN_VERSION "3.2.1" CACHE STRING "Android Gradle Plugin version (3.0+)") +message(STATUS "Android Gradle Plugin version: ${ANDROID_GRADLE_PLUGIN_VERSION}") + +set(ANDROID_COMPILE_SDK_VERSION "26" CACHE STRING "Android compileSdkVersion") +set(ANDROID_MIN_SDK_VERSION "21" CACHE STRING "Android minSdkVersion") +set(ANDROID_TARGET_SDK_VERSION "26" CACHE STRING "Android minSdkVersion") + +set(ANDROID_BUILD_BASE_DIR "${OpenCV_BINARY_DIR}/opencv_android" CACHE INTERNAL "") +set(ANDROID_TMP_INSTALL_BASE_DIR "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/install/opencv_android") + +set(ANDROID_INSTALL_SAMPLES_DIR "samples") + +set(ANDROID_BUILD_ABI_FILTER " +reset() +include '${ANDROID_ABI}' ") + +set(ANDROID_INSTALL_ABI_FILTER " +//reset() +//include 'armeabi-v7a' +//include 'arm64-v8a' +//include 'x86' +//include 'x86_64' +") +if(NOT INSTALL_CREATE_DISTRIB) + set(ANDROID_INSTALL_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}") +endif() + +# BUG: Ninja generator generates broken targets with ANDROID_ABI_FILTER name (CMake 3.11.2) +#set(__spaces " ") +#string(REPLACE "\n" "\n${__spaces}" ANDROID_ABI_FILTER "${__spaces}${ANDROID_BUILD_ABI_FILTER}") +#string(REPLACE REGEX "[ ]+$" "" ANDROID_ABI_FILTER "${ANDROID_ABI_FILTER}") +set(ANDROID_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}") +configure_file("${OpenCV_SOURCE_DIR}/samples/android/build.gradle.in" "${ANDROID_BUILD_BASE_DIR}/build.gradle" @ONLY) + +set(ANDROID_ABI_FILTER "${ANDROID_INSTALL_ABI_FILTER}") +configure_file("${OpenCV_SOURCE_DIR}/samples/android/build.gradle.in" "${ANDROID_TMP_INSTALL_BASE_DIR}/${ANDROID_INSTALL_SAMPLES_DIR}/build.gradle" @ONLY) +install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/${ANDROID_INSTALL_SAMPLES_DIR}/build.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}" COMPONENT samples) + +set(GRADLE_WRAPPER_FILES + "gradle/wrapper/gradle-wrapper.jar" + "gradle/wrapper/gradle-wrapper.properties" + "gradlew.bat" + "gradlew" + "gradle.properties" +) +foreach(fname ${GRADLE_WRAPPER_FILES}) + get_filename_component(__dir "${fname}" DIRECTORY) + set(__permissions "") + set(__permissions_prefix "") + if(fname STREQUAL "gradlew") + set(__permissions FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) + endif() + file(COPY "${OpenCV_SOURCE_DIR}/platforms/android/gradle-wrapper/${fname}" DESTINATION "${ANDROID_BUILD_BASE_DIR}/${__dir}" ${__permissions}) + string(REPLACE "FILE_PERMISSIONS" "PERMISSIONS" __permissions "${__permissions}") + if("${__dir}" STREQUAL "") + set(__dir ".") + endif() + install(FILES "${OpenCV_SOURCE_DIR}/platforms/android/gradle-wrapper/${fname}" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples ${__permissions}) +endforeach() + +file(WRITE "${ANDROID_BUILD_BASE_DIR}/settings.gradle" " +include ':opencv' +") + +file(WRITE "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" " +rootProject.name = 'opencv_samples' + +def opencvsdk='../' +//def opencvsdk='/' +//println opencvsdk +include ':opencv' +project(':opencv').projectDir = new File(opencvsdk + '/sdk') +") + + +macro(add_android_project target path) + get_filename_component(__dir "${path}" NAME) + + set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "") + if(DEFINED ANDROID_TOOLCHAIN) + set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "${OPENCV_ANDROID_CMAKE_EXTRA_ARGS},\n\"-DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}\"") + endif() + if(DEFINED ANDROID_STL) + set(OPENCV_ANDROID_CMAKE_EXTRA_ARGS "${OPENCV_ANDROID_CMAKE_EXTRA_ARGS},\n\"-DANDROID_STL=${ANDROID_STL}\"") + endif() + + # + # Build + # + set(ANDROID_SAMPLE_JNI_PATH "${path}/jni") + set(ANDROID_SAMPLE_JAVA_PATH "${path}/src") + set(ANDROID_SAMPLE_RES_PATH "${path}/res") + set(ANDROID_SAMPLE_MANIFEST_PATH "${path}/gradle/AndroidManifest.xml") + + set(ANDROID_ABI_FILTER "${ANDROID_BUILD_ABI_FILTER}") + set(ANDROID_PROJECT_JNI_PATH "../../") + + string(REPLACE ";" "', '" ANDROID_SAMPLE_JAVA_PATH "['${ANDROID_SAMPLE_JAVA_PATH}']") + string(REPLACE ";" "', '" ANDROID_SAMPLE_RES_PATH "['${ANDROID_SAMPLE_RES_PATH}']") + configure_file("${path}/build.gradle.in" "${ANDROID_BUILD_BASE_DIR}/${__dir}/build.gradle" @ONLY) + + file(APPEND "${ANDROID_BUILD_BASE_DIR}/settings.gradle" " +include ':${__dir}' +") + + # build apk + set(APK_FILE "${ANDROID_BUILD_BASE_DIR}/${__dir}/build/outputs/apk/release/${__dir}-${ANDROID_ABI}-release-unsigned.apk") + ocv_update(OPENCV_GRADLE_VERBOSE_OPTIONS "-i") + add_custom_command( + OUTPUT "${APK_FILE}" "${OPENCV_DEPHELPER}/android_sample_${__dir}" + COMMAND ./gradlew ${OPENCV_GRADLE_VERBOSE_OPTIONS} "${__dir}:assemble" + COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/android_sample_${__dir}" + WORKING_DIRECTORY "${ANDROID_BUILD_BASE_DIR}" + DEPENDS ${depends} opencv_java_android + COMMENT "Building OpenCV Android sample project: ${__dir}" + ) + file(REMOVE "${OPENCV_DEPHELPER}/android_sample_${__dir}") # force rebuild after CMake run + + add_custom_target(android_sample_${__dir} ALL DEPENDS "${OPENCV_DEPHELPER}/android_sample_${__dir}" SOURCES "${ANDROID_SAMPLE_MANIFEST_PATH}") + + # + # Install + # + set(ANDROID_SAMPLE_JNI_PATH "jni") + set(ANDROID_SAMPLE_JAVA_PATH "src") + set(ANDROID_SAMPLE_RES_PATH "res") + set(ANDROID_SAMPLE_MANIFEST_PATH "AndroidManifest.xml") + + install(DIRECTORY "${path}/res" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples OPTIONAL) + install(DIRECTORY "${path}/src" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples) + install(DIRECTORY "${path}/jni" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples OPTIONAL) + + install(FILES "${path}/gradle/AndroidManifest.xml" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples) + + set(ANDROID_ABI_FILTER "${ANDROID_INSTALL_ABI_FILTER}") + set(ANDROID_PROJECT_JNI_PATH "native/jni") + + string(REPLACE ";" "', '" ANDROID_SAMPLE_JAVA_PATH "['${ANDROID_SAMPLE_JAVA_PATH}']") + string(REPLACE ";" "', '" ANDROID_SAMPLE_RES_PATH "['${ANDROID_SAMPLE_RES_PATH}']") + configure_file("${path}/build.gradle.in" "${ANDROID_TMP_INSTALL_BASE_DIR}/${__dir}/build.gradle" @ONLY) + install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/${__dir}/build.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}/${__dir}" COMPONENT samples) + + file(APPEND "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" " +include ':${__dir}' +") + +endmacro() + +install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/settings.gradle" DESTINATION "${ANDROID_INSTALL_SAMPLES_DIR}" COMPONENT samples) diff --git a/modules/java/CMakeLists.txt b/modules/java/CMakeLists.txt index 8cc4bd07a6..a477490d14 100644 --- a/modules/java/CMakeLists.txt +++ b/modules/java/CMakeLists.txt @@ -3,8 +3,8 @@ if(OPENCV_INITIAL_PASS) add_subdirectory(generator) endif() -if(APPLE_FRAMEWORK OR WINRT OR NOT PYTHON_DEFAULT_AVAILABLE OR NOT ANT_EXECUTABLE - OR NOT (JNI_FOUND OR (ANDROID AND ANDROID_NATIVE_API_LEVEL GREATER 7)) +if(APPLE_FRAMEWORK OR WINRT OR NOT PYTHON_DEFAULT_AVAILABLE OR NOT (ANT_EXECUTABLE OR ANDROID_PROJECTS_BUILD_TYPE STREQUAL "GRADLE") + OR NOT (JNI_FOUND OR (ANDROID AND (NOT DEFINED ANDROID_NATIVE_API_LEVEL OR ANDROID_NATIVE_API_LEVEL GREATER 7))) OR BUILD_opencv_world ) ocv_module_disable(java) @@ -55,7 +55,7 @@ macro(copy_common_tests _src_location _dst_location _deps) endmacro() -add_subdirectory(jni) # generates ${the_module} target (${the_module}_jni doesn't work properly with Android samples) +add_subdirectory(jni) # generates ${the_module} target (${the_module}_jni doesn't work properly with Android non-gradle samples) if(ANDROID) add_subdirectory(android_sdk) # generates ${the_module}_android target else() diff --git a/modules/java/android_sdk/CMakeLists.txt b/modules/java/android_sdk/CMakeLists.txt index e57b0394a3..945dcf2b54 100644 --- a/modules/java/android_sdk/CMakeLists.txt +++ b/modules/java/android_sdk/CMakeLists.txt @@ -1,12 +1,11 @@ -if(NOT ANDROID_EXECUTABLE) - message(WARNING "'android' tool required to build Android SDK") - return() -endif() -ocv_assert(ANDROID_TOOLS_Pkg_Revision GREATER 13) project(${the_module}_android) -set(OPENCV_JAVA_DIR "${OpenCV_BINARY_DIR}/android_sdk" CACHE INTERNAL "") +if(ANDROID_EXECUTABLE) + set(OPENCV_JAVA_DIR "${OpenCV_BINARY_DIR}/android_sdk" CACHE INTERNAL "") +else() # gradle + set(OPENCV_JAVA_DIR "${ANDROID_BUILD_BASE_DIR}/opencv" CACHE INTERNAL "") +endif() set(OPENCV_ANDROID_LIB_DIR "${OPENCV_JAVA_DIR}" CACHE INTERNAL "") # for OpenCV samples file(REMOVE_RECURSE "${OPENCV_JAVA_DIR}") @@ -15,6 +14,11 @@ set(java_src_dir "${OPENCV_JAVA_DIR}/src") file(MAKE_DIRECTORY "${java_src_dir}") ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/java" "${java_src_dir}") + +if(ANDROID_EXECUTABLE) + +ocv_assert(ANDROID_TOOLS_Pkg_Revision GREATER 13) + ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android/java" "${java_src_dir}") # calc default SDK Target @@ -90,5 +94,57 @@ FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT}/res\") " COMPONENT java) +ocv_update(ANDROID_COMPILE_SDK_VERSION "27") +ocv_update(ANDROID_MIN_SDK_VERSION "14") +ocv_update(ANDROID_TARGET_SDK_VERSION "21") configure_file("${CMAKE_CURRENT_SOURCE_DIR}/build.gradle.in" "${CMAKE_CURRENT_BINARY_DIR}/build.gradle" @ONLY) install(FILES "${CMAKE_CURRENT_BINARY_DIR}/build.gradle" DESTINATION ${JAVA_INSTALL_ROOT}/.. COMPONENT java) + + +else() # gradle build +# +# Android Gradle-based project +# + +#TODO: INSTALL ONLY +ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android/java" "${java_src_dir}") +ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android-21/java" "${java_src_dir}") + +# copy boilerplate +set(__base_dir "${CMAKE_CURRENT_SOURCE_DIR}/android_gradle_lib/") +file(GLOB_RECURSE seed_project_files_rel RELATIVE "${__base_dir}/" "${__base_dir}/*") +list(REMOVE_ITEM seed_project_files_rel "${ANDROID_MANIFEST_FILE}") +foreach(file ${seed_project_files_rel}) + configure_file("${__base_dir}/${file}" "${OPENCV_JAVA_DIR}/${file}" @ONLY) + list(APPEND depends "${__base_dir}/${file}") + get_filename_component(install_subdir "${file}" PATH) + install(FILES "${OPENCV_JAVA_DIR}/${file}" DESTINATION "${JAVA_INSTALL_ROOT}/${install_subdir}" COMPONENT java) +endforeach() + +list(APPEND depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source") +ocv_copyfiles_add_target(${the_module}_android_source_copy JAVA_SRC_COPY "Copy Java(Andoid SDK) source files" ${depends}) +file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_android_source_copy") # force rebuild after CMake run + +set(depends ${the_module}_android_source_copy "${OPENCV_DEPHELPER}/${the_module}_android_source_copy") + +# build jar +set(AAR_FILE "${OPENCV_JAVA_DIR}/build/outputs/aar/opencv-release.aar") +ocv_update(OPENCV_GRADLE_VERBOSE_OPTIONS "-i") +add_custom_command( + OUTPUT "${AAR_FILE}" "${OPENCV_DEPHELPER}/${the_module}_android" + COMMAND ./gradlew ${OPENCV_GRADLE_VERBOSE_OPTIONS} "opencv:assemble" + COMMAND ${CMAKE_COMMAND} -E touch "${OPENCV_DEPHELPER}/${the_module}_android" + WORKING_DIRECTORY "${ANDROID_BUILD_BASE_DIR}" + DEPENDS ${depends} ${the_module} + COMMENT "Building OpenCV Android library project" +) +file(REMOVE "${OPENCV_DEPHELPER}/${the_module}_android") # force rebuild after CMake run + +add_custom_target(${the_module}_android ALL DEPENDS "${OPENCV_DEPHELPER}/${the_module}_android" SOURCES "${__base_dir}/${ANDROID_MANIFEST_FILE}") + +configure_file("${CMAKE_CURRENT_SOURCE_DIR}/build.gradle.in" "${ANDROID_TMP_INSTALL_BASE_DIR}/opencv/build.gradle" @ONLY) +install(FILES "${ANDROID_TMP_INSTALL_BASE_DIR}/opencv/build.gradle" DESTINATION ${JAVA_INSTALL_ROOT}/.. COMPONENT java) + +install(DIRECTORY "${java_src_dir}" DESTINATION "${JAVA_INSTALL_ROOT}" COMPONENT java) + +endif() # gradle build diff --git a/modules/java/android_sdk/android_gradle_lib/AndroidManifest.xml b/modules/java/android_sdk/android_gradle_lib/AndroidManifest.xml new file mode 100644 index 0000000000..b62ded736d --- /dev/null +++ b/modules/java/android_sdk/android_gradle_lib/AndroidManifest.xml @@ -0,0 +1,6 @@ + + + diff --git a/modules/java/android_sdk/android_gradle_lib/build.gradle b/modules/java/android_sdk/android_gradle_lib/build.gradle new file mode 100644 index 0000000000..8091293401 --- /dev/null +++ b/modules/java/android_sdk/android_gradle_lib/build.gradle @@ -0,0 +1,35 @@ +apply plugin: 'com.android.library' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + //buildToolsVersion "x.y.z" // not needed since com.android.tools.build:gradle:3.0.0 + + defaultConfig { + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_6 + targetCompatibility JavaVersion.VERSION_1_6 + } + + sourceSets { + main { + jniLibs.srcDirs = ['../../jni'] + java.srcDirs = ['src'] // TODO Use original files instead of copied into build directory + aidl.srcDirs = ['src'] + res.srcDirs = ['@OpenCV_SOURCE_DIR@/modules/java/android_sdk/android_gradle_lib/res'] + manifest.srcFile 'AndroidManifest.xml' + } + } +} + +dependencies { +} diff --git a/modules/java/android_sdk/android_gradle_lib/res/values/attrs.xml b/modules/java/android_sdk/android_gradle_lib/res/values/attrs.xml new file mode 100644 index 0000000000..6902621f66 --- /dev/null +++ b/modules/java/android_sdk/android_gradle_lib/res/values/attrs.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/modules/java/android_sdk/build.gradle.in b/modules/java/android_sdk/build.gradle.in index f4c260e40d..fbb65bdfdf 100644 --- a/modules/java/android_sdk/build.gradle.in +++ b/modules/java/android_sdk/build.gradle.in @@ -81,9 +81,9 @@ // splits { // abi { // enable true +// universalApk false // reset() // include 'armeabi-v7a' // , 'x86', 'x86_64', 'arm64-v8a' -// universalApk false // } // } // @@ -93,12 +93,12 @@ apply plugin: 'com.android.library' println "OpenCV: " + project.buildscript.sourceFile android { - compileSdkVersion 27 - //buildToolsVersion "27.0.3" // not needed since com.android.tools.build:gradle:3.0.0 + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + //buildToolsVersion "x.y.z" // not needed since com.android.tools.build:gradle:3.0.0 defaultConfig { - minSdkVersion 14 - targetSdkVersion 21 + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ } buildTypes { diff --git a/modules/java/jni/CMakeLists.txt b/modules/java/jni/CMakeLists.txt index bfb948bfb7..2a50ee238e 100644 --- a/modules/java/jni/CMakeLists.txt +++ b/modules/java/jni/CMakeLists.txt @@ -13,6 +13,12 @@ foreach(m ${OPENCV_MODULES_BUILD}) endif() endforeach() +if(ANDROID) + ocv_update(JNI_OUTPUT_PATH "${OpenCV_BINARY_DIR}/jni/${ANDROID_NDK_ABI_NAME}") +else() + ocv_update(JNI_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH}") +endif() + set(__type MODULE) if(BUILD_FAT_JAVA_LIB) set(__type SHARED) # samples link to libopencv_java @@ -60,7 +66,7 @@ endif() set_target_properties(${the_module} PROPERTIES OUTPUT_NAME "${the_module}${OPENCV_JAVA_LIB_NAME_SUFFIX}" ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} - LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} + LIBRARY_OUTPUT_DIRECTORY ${JNI_OUTPUT_PATH} RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEFINE_SYMBOL CVAPI_EXPORTS ) diff --git a/platforms/android/build-tests/test_ant_build.py b/platforms/android/build-tests/test_ant_build.py deleted file mode 100644 index 73ac4d018e..0000000000 --- a/platforms/android/build-tests/test_ant_build.py +++ /dev/null @@ -1,77 +0,0 @@ -#!/usr/bin/env python - -import unittest -import os, sys, subprocess, argparse, shutil, re -from os.path import abspath - -class TestAntBuild(unittest.TestCase): - pass - - def __init__(self, target, workdir, lib_dir, sample_dir, *args, **kwargs): - unittest.TestCase.__init__(self, *args, **kwargs) - self.target = target - self.workdir = workdir - self.src_lib_dir = lib_dir - self.src_sample_dir = sample_dir - self.lib_dir = os.path.join(self.workdir, "opencv") - self.sample_dir = os.path.join(self.workdir, "project") - - def shortDescription(self): - return "TARGET: %r, SAMPLE: %s" % (self.target, os.path.basename(self.src_sample_dir)) - - def setUp(self): - if os.path.exists(self.workdir): - shutil.rmtree(self.workdir) - os.mkdir(self.workdir) - shutil.copytree(self.src_lib_dir, self.lib_dir) - shutil.copytree(self.src_sample_dir, self.sample_dir) - os.remove(os.path.join(self.sample_dir, "project.properties")) - - def tearDown(self): - if os.path.exists(self.workdir): - shutil.rmtree(self.workdir) - - def runTest(self): - cmd = [os.path.join(os.environ["ANDROID_SDK"], "tools", "android"), "update", "project", "-p", self.lib_dir, "-t", self.target[0]] - retcode = subprocess.call(cmd) - self.assertEqual(retcode, 0, "android update opencv project failed") - - cmd = ["ant", "-f", os.path.join(self.lib_dir, "build.xml"), "debug"] - retcode = subprocess.call(cmd) - self.assertEqual(retcode, 0, "opencv ant build failed") - - cmd = [os.path.join(os.environ["ANDROID_SDK"], "tools", "android"), "update", "project", "-p", self.sample_dir, "-t", self.target[1], "-l", os.path.relpath(self.lib_dir, self.sample_dir)] - retcode = subprocess.call(cmd) - self.assertEqual(retcode, 0, "android update sample project failed") - - cmd = ["ant", "-f", os.path.join(self.sample_dir, "build.xml"), "debug"] - retcode = subprocess.call(cmd) - self.assertEqual(retcode, 0, "sample ant build failed") - -def suite(workdir, opencv_lib_path, opencv_samples_path): - suite = unittest.TestSuite() - for target in [("android-21", "android-14"), ("android-21", "android-17")]: - for item in os.listdir(opencv_samples_path): - item = os.path.join(opencv_samples_path, item) - if (os.path.exists(os.path.join(item, "AndroidManifest.xml"))): - suite.addTest(TestAntBuild(target, workdir, opencv_lib_path, item)) - return suite - -if __name__ == '__main__': - parser = argparse.ArgumentParser(description='Test OpenCV for Android SDK with ant') - parser.add_argument('--sdk_path', help="Path to Android SDK to use for build") - parser.add_argument("--workdir", default="testspace", help="Working directory (and output)") - parser.add_argument("opencv_lib_path", help="Path to folder with SDK java library (usually /sdk/java/)") - parser.add_argument("opencv_samples_path", help="Path to folder with SDK samples (usually /samples/)") - - args = parser.parse_args() - - if args.sdk_path is not None: - os.environ["ANDROID_SDK"] = os.path.abspath(args.sdk_path) - - print("Using SDK: %s" % os.environ["ANDROID_SDK"]) - - s = suite(abspath(args.workdir), abspath(args.opencv_lib_path), abspath(args.opencv_samples_path)) - res = unittest.TextTestRunner(verbosity=3).run(s) - if not res.wasSuccessful(): - sys.exit(res) diff --git a/platforms/android/build-tests/test_cmake_build.py b/platforms/android/build-tests/test_cmake_build.py index eb4d43512a..b90bf5a133 100644 --- a/platforms/android/build-tests/test_cmake_build.py +++ b/platforms/android/build-tests/test_cmake_build.py @@ -44,18 +44,29 @@ int main(int argc, char* argv[]) #=================================================================================================== class TestCmakeBuild(unittest.TestCase): - def __init__(self, libset, abi, toolchain, opencv_cmake_path, workdir, *args, **kwargs): + def __init__(self, libset, abi, cmake_vars, opencv_cmake_path, workdir, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.libset = libset self.abi = abi - self.toolchain = toolchain + self.cmake_vars = cmake_vars self.opencv_cmake_path = opencv_cmake_path self.workdir = workdir self.srcdir = os.path.join(self.workdir, "src") self.bindir = os.path.join(self.workdir, "build") def shortDescription(self): - return "ABI: %s, TOOLCHAIN: %s, LIBSET: %s" % (self.abi, self.toolchain, self.libset) + return "ABI: %s, LIBSET: %s" % (self.abi, self.libset) + + def getCMakeToolchain(self): + if True: + toolchain = os.path.join(os.environ['ANDROID_NDK'], 'build', 'cmake', 'android.toolchain.cmake') + if os.path.exists(toolchain): + return toolchain + toolchain = os.path.join(self.opencv_cmake_path, "android.toolchain.cmake") + if os.path.exists(toolchain): + return toolchain + else: + raise Exception("Can't find toolchain") def gen_cmakelists(self): return CMAKE_TEMPLATE % {"libset": self.libset} @@ -78,43 +89,40 @@ class TestCmakeBuild(unittest.TestCase): os.chdir(self.bindir) def tearDown(self): - if os.path.exists(self.workdir): - shutil.rmtree(self.workdir) + pass + #if os.path.exists(self.workdir): + # shutil.rmtree(self.workdir) def runTest(self): cmd = [ "cmake", "-GNinja", "-DOpenCV_DIR=%s" % self.opencv_cmake_path, - "-DANDROID_ABI=%s" % self.abi, - "-DCMAKE_TOOLCHAIN_FILE=%s" % os.path.join(self.opencv_cmake_path, "android.toolchain.cmake"), - "-DANDROID_TOOLCHAIN_NAME=%s" % self.toolchain, + "-DCMAKE_TOOLCHAIN_FILE=%s" % self.getCMakeToolchain(), self.srcdir - ] + ] + [ "-D{}={}".format(key, value) for key, value in self.cmake_vars.items() ] log.info("Executing: %s" % cmd) retcode = subprocess.call(cmd) self.assertEqual(retcode, 0, "cmake failed") - cmd = ["ninja"] + cmd = ["ninja", "-v"] log.info("Executing: %s" % cmd) retcode = subprocess.call(cmd) self.assertEqual(retcode, 0, "make failed") def suite(workdir, opencv_cmake_path): abis = { - "armeabi":"arm-linux-androideabi-4.8", - "armeabi-v7a":"arm-linux-androideabi-4.8", - "arm64-v8a":"aarch64-linux-android-4.9", - "x86":"x86-4.8", - "x86_64":"x86_64-4.9", - "mips":"mipsel-linux-android-4.8", - "mips64":"mips64el-linux-android-4.9" + "armeabi-v7a": { "ANDROID_ABI": "armeabi-v7a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" }, + "arm64-v8a": { "ANDROID_ABI": "arm64-v8a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" }, + "x86": { "ANDROID_ABI": "x86", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" }, + "x86_64": { "ANDROID_ABI": "x86_64", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" }, } suite = unittest.TestSuite() for libset in ["", "opencv_java"]: - for abi, toolchain in abis.items(): - suite.addTest(TestCmakeBuild(libset, abi, toolchain, opencv_cmake_path, workdir)) + for abi, cmake_vars in abis.items(): + suite.addTest(TestCmakeBuild(libset, abi, cmake_vars, opencv_cmake_path, + os.path.join(workdir, "{}-{}".format(abi, "static" if libset == "" else "shared")))) return suite @@ -132,9 +140,15 @@ if __name__ == '__main__': if args.ndk_path is not None: os.environ["ANDROID_NDK"] = os.path.abspath(args.ndk_path) + if not 'ANDROID_HOME' in os.environ and 'ANDROID_SDK' in os.environ: + os.environ['ANDROID_HOME'] = os.environ["ANDROID_SDK"] + print("Using SDK: %s" % os.environ["ANDROID_SDK"]) print("Using NDK: %s" % os.environ["ANDROID_NDK"]) - res = unittest.TextTestRunner(verbosity=3).run(suite(os.path.abspath(args.workdir), os.path.abspath(args.opencv_cmake_path))) + workdir = os.path.abspath(args.workdir) + if not os.path.exists(workdir): + os.mkdir(workdir) + res = unittest.TextTestRunner(verbosity=3).run(suite(workdir, os.path.abspath(args.opencv_cmake_path))) if not res.wasSuccessful(): sys.exit(res) diff --git a/platforms/android/build-tests/test_gradle.sh b/platforms/android/build-tests/test_gradle.sh new file mode 100755 index 0000000000..9f1b233ff2 --- /dev/null +++ b/platforms/android/build-tests/test_gradle.sh @@ -0,0 +1,37 @@ +#!/bin/bash -e +SDK_DIR=$1 +echo "OpenCV Android SDK path: ${SDK_DIR}" + +ANDROID_HOME=${ANDROID_HOME:-${ANDROID_SDK_ROOT:-${ANDROID_SDK?Required ANDROID_HOME/ANDROID_SDK/ANDROID_SDK_ROOT}}} +ANDROID_NDK=${ANDROID_NDK_HOME-${ANDROID_NDK:-${NDKROOT?Required ANDROID_NDK_HOME/ANDROID_NDK/NDKROOT}}} + +echo "Android SDK: ${ANDROID_HOME}" +echo "Android NDK: ${ANDROID_NDK}" + +if [ ! -d "${ANDROID_HOME}" ]; then + echo "FATAL: Missing Android SDK directory" + exit 1 +fi +if [ ! -d "${ANDROID_NDK}" ]; then + echo "FATAL: Missing Android NDK directory" + exit 1 +fi + +export ANDROID_HOME=${ANDROID_HOME} +export ANDROID_SDK=${ANDROID_HOME} +export ANDROID_SDK_ROOT=${ANDROID_HOME} + +export ANDROID_NDK=${ANDROID_NDK} +export ANDROID_NDK_HOME=${ANDROID_NDK} + +echo "Cloning OpenCV Android SDK ..." +rm -rf "test-gradle" +cp -rp "${SDK_DIR}" "test-gradle" +echo "Cloning OpenCV Android SDK ... Done!" + +echo "Run gradle ..." +(cd "test-gradle/samples"; ./gradlew -i assemble) + +echo "#" +echo "# Done!" +echo "#" diff --git a/platforms/android/build-tests/test_ndk_build.py b/platforms/android/build-tests/test_ndk_build.py deleted file mode 100644 index cc1dbc0102..0000000000 --- a/platforms/android/build-tests/test_ndk_build.py +++ /dev/null @@ -1,148 +0,0 @@ -#!/usr/bin/env python - -import unittest -import os, sys, subprocess, argparse, shutil, re - -TEMPLATE_ANDROID_MK = '''\ -LOCAL_PATH := $(call my-dir) -include $(CLEAR_VARS) -{cut} -LOCAL_MODULE := mixed_sample -LOCAL_SRC_FILES := {cpp1} -LOCAL_LDLIBS += -llog -ldl -include $(BUILD_SHARED_LIBRARY) -include $(CLEAR_VARS) -{cut} -LOCAL_MODULE := mixed_sample2 -LOCAL_SRC_FILES := {cpp2} -LOCAL_LDLIBS += -llog -ldl -LOCAL_SHARED_LIBS := mixed_sample -include $(BUILD_SHARED_LIBRARY) -''' - -TEMPLATE_APPLICATION_MK = '''\ -APP_STL := gnustl_static -APP_CPPFLAGS := -frtti -fexceptions -std=c++11 -APP_ABI := {abi} -APP_PLATFORM := android-9 -''' - -TEMPLATE_JNI = '''\ -#include -#include -#include -#include -#include -using namespace std; -using namespace cv; -extern "C" { -JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_Sample4Mixed_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba); -JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_Sample4Mixed_FindFeatures(JNIEnv*, jobject, jlong addrGray, jlong addrRgba) -{ - Mat& mGr = *(Mat*)addrGray; - Mat& mRgb = *(Mat*)addrRgba; - vector v; - Ptr detector = FastFeatureDetector::create(50); - detector->detect(mGr, v); - for( unsigned int i = 0; i < v.size(); i++ ) - { - const KeyPoint& kp = v[i]; - circle(mRgb, Point(kp.pt.x, kp.pt.y), 10, Scalar(255,0,0,255)); - } -} -} -''' - -#=================================================================================================== - -class TestNDKBuild(unittest.TestCase): - def __init__(self, abi, libtype, opencv_mk_path, workdir, *args, **kwargs): - unittest.TestCase.__init__(self, *args, **kwargs) - self.abi = abi # official NDK ABI name or 'all' - self.libtype = libtype # 'static', etc - self.opencv_mk_path = opencv_mk_path - self.workdir = workdir - self.jnidir = os.path.join(self.workdir, "jni") - self.cpp1 = "jni_part1.cpp" - self.cpp2 = "jni_part2.cpp" - - def shortDescription(self): - return "ABI: %s, LIBTYPE: %s" % (self.abi, self.libtype) - - def gen_android_mk(self): - p = [] - if self.libtype == "static": - p.append("OPENCV_LIB_TYPE := STATIC") - elif self.libtype == "shared": - p.append("OPENCV_LIB_TYPE := SHARED") - p.append("OPENCV_INSTALL_MODULES:=on") - elif self.libtype == "shared_opencv_manager": - p.append("OPENCV_LIB_TYPE := SHARED") - p.append("OPENCV_INSTALL_MODULES:=off") - p.append("include %s" % os.path.join(self.opencv_mk_path, "OpenCV.mk")) - return TEMPLATE_ANDROID_MK.format(cut = "\n".join(p), cpp1 = self.cpp1, cpp2 = self.cpp2) - - def gen_jni_code(self): - return TEMPLATE_JNI - - def gen_application_mk(self): - return TEMPLATE_APPLICATION_MK.format(abi = self.abi) - - def write_jni_file(self, fname, contents): - with open(os.path.join(self.jnidir, fname), "w") as f: - f.write(contents) - - def setUp(self): - if os.path.exists(self.workdir): - shutil.rmtree(self.workdir) - os.mkdir(self.workdir) - os.mkdir(self.jnidir) - self.write_jni_file("Android.mk", self.gen_android_mk()) - self.write_jni_file("Application.mk", self.gen_application_mk()) - self.write_jni_file(self.cpp1, self.gen_jni_code()) - self.write_jni_file(self.cpp2, self.gen_jni_code()) - os.chdir(self.workdir) - - def tearDown(self): - if os.path.exists(self.workdir): - shutil.rmtree(self.workdir) - - def runTest(self): - ndk_path = os.environ["ANDROID_NDK"] - retcode = subprocess.call([os.path.join(ndk_path, 'ndk-build'), "V=0"]) - self.assertEqual(retcode, 0) - -def suite(workdir, opencv_mk_path): - abis = ["armeabi", "armeabi-v7a", "x86", "mips"] - ndk_path = os.environ["ANDROID_NDK"] - if os.path.exists(os.path.join(ndk_path, "RELEASE.TXT")): - with open(os.path.join(ndk_path, "RELEASE.TXT"), "r") as f: - s = f.read() - if re.search(r'r10[b-e]', s): - abis.extend(["arm64-v8a", "x86_64"]) - if os.path.exists(os.path.join(ndk_path, "source.properties")): # Android NDK 11+ - abis.extend(["arm64-v8a", "x86_64"]) - abis.append("all") - - suite = unittest.TestSuite() - for libtype in ["static", "shared", "shared_opencv_manager"]: - for abi in abis: - suite.addTest(TestNDKBuild(abi, libtype, opencv_mk_path, workdir)) - return suite - -if __name__ == '__main__': - parser = argparse.ArgumentParser(description='Test OpenCV for Android SDK with NDK') - parser.add_argument('--ndk_path', help="Path to Android NDK to use for build") - parser.add_argument("--workdir", default="testspace", help="Working directory (and output)") - parser.add_argument("opencv_mk_path", help="Path to folder with OpenCV.mk file (usually /sdk/native/jni/") - - args = parser.parse_args() - - if args.ndk_path is not None: - os.environ["ANDROID_NDK"] = os.path.abspath(args.ndk_path) - - print("Using NDK: %s" % os.environ["ANDROID_NDK"]) - - res = unittest.TextTestRunner(verbosity=3).run(suite(os.path.abspath(args.workdir), os.path.abspath(args.opencv_mk_path))) - if not res.wasSuccessful(): - sys.exit(res) diff --git a/platforms/android/build_sdk.py b/platforms/android/build_sdk.py index 4a5b8b19d6..b38fd7dc84 100755 --- a/platforms/android/build_sdk.py +++ b/platforms/android/build_sdk.py @@ -48,10 +48,6 @@ def check_dir(d, create=False, clean=False): os.makedirs(d) return d -def determine_engine_version(manifest_path): - with open(manifest_path, "rt") as f: - return re.search(r'android:versionName="(\d+\.\d+)"', f.read(), re.MULTILINE).group(1) - def determine_opencv_version(version_hpp_path): # version in 2.4 - CV_VERSION_EPOCH.CV_VERSION_MAJOR.CV_VERSION_MINOR.CV_VERSION_REVISION # version in master - CV_VERSION_MAJOR.CV_VERSION_MINOR.CV_VERSION_REVISION-CV_VERSION_STATUS @@ -133,7 +129,6 @@ class Builder: self.docdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk', 'sdk', 'java', 'javadoc'), create=True, clean=True) self.extra_packs = [] self.opencv_version = determine_opencv_version(os.path.join(self.opencvdir, "modules", "core", "include", "opencv2", "core", "version.hpp")) - self.engine_version = determine_engine_version(os.path.join(self.opencvdir, "platforms", "android", "service", "engine", "AndroidManifest.xml")) self.use_ccache = False if config.no_ccache else True def get_toolchain_file(self): @@ -163,6 +158,7 @@ class Builder: cmd = ["cmake", "-GNinja"] cmake_vars = dict( CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(), + INSTALL_CREATE_DISTRIB="ON", WITH_OPENCL="OFF", WITH_IPP=("ON" if abi.haveIPP() else "OFF"), WITH_TBB="ON", @@ -186,51 +182,7 @@ class Builder: cmd += [ "-D%s='%s'" % (k, v) for (k, v) in cmake_vars.items() if v is not None] cmd.append(self.opencvdir) execute(cmd) - if do_install: - execute(["ninja"]) - for c in ["libs", "dev", "java", "samples"]: - execute(["cmake", "-DCOMPONENT=%s" % c, "-P", "cmake_install.cmake"]) - else: - execute(["ninja", "install/strip"]) - - def build_engine(self, abi, engdest): - cmd = ["cmake", "-GNinja"] - cmake_vars = dict( - CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(), - WITH_OPENCL="OFF", - WITH_IPP="OFF", - BUILD_ANDROID_SERVICE = 'ON' - ) - cmake_vars.update(abi.cmake_vars) - cmd += [ "-D%s='%s'" % (k, v) for (k, v) in cmake_vars.items() if v is not None] - cmd.append(self.opencvdir) - execute(cmd) - apkdest = self.get_engine_apk_dest(engdest) - assert os.path.exists(apkdest), apkdest - # Add extra data - apkxmldest = check_dir(os.path.join(apkdest, "res", "xml"), create=True) - apklibdest = check_dir(os.path.join(apkdest, "libs", abi.name), create=True) - for ver, d in self.extra_packs + [("3.4.4", os.path.join(self.libdest, "lib"))]: - r = ET.Element("library", attrib={"version": ver}) - log.info("Adding libraries from %s", d) - - for f in glob.glob(os.path.join(d, abi.name, "*.so")): - log.info("Copy file: %s", f) - shutil.copy2(f, apklibdest) - if "libnative_camera" in f: - continue - log.info("Register file: %s", os.path.basename(f)) - n = ET.SubElement(r, "file", attrib={"name": os.path.basename(f)}) - - if len(list(r)) > 0: - xmlname = os.path.join(apkxmldest, "config%s.xml" % ver.replace(".", "")) - log.info("Generating XML config: %s", xmlname) - ET.ElementTree(r).write(xmlname, encoding="utf-8") - - execute(["ninja", "opencv_engine"]) - execute(["ant", "-f", os.path.join(apkdest, "build.xml"), "debug"], - shell=(sys.platform == 'win32')) - # TODO: Sign apk + execute(["ninja", "install/strip"]) def build_javadoc(self): classpaths = [] @@ -251,7 +203,7 @@ class Builder: ] execute(cmd) - def gather_results(self, engines): + def gather_results(self): # Copy all files root = os.path.join(self.libdest, "install") for item in os.listdir(root): @@ -270,25 +222,6 @@ class Builder: else: shutil.move(src, dst) - # Copy engines for all platforms - for abi, engdest in engines: - log.info("Copy engine: %s (%s)", abi, engdest) - f = os.path.join(self.get_engine_apk_dest(engdest), "bin", "opencv_engine-debug.apk") - resname = "OpenCV_%s_Manager_%s_%s.apk" % (self.opencv_version, self.engine_version, abi) - dst = os.path.join(self.resultdest, "apk", resname) - if self.config.force_copy: - shutil.copy2(f, dst) - else: - shutil.move(f, dst) - - # Clean samples - path = os.path.join(self.resultdest, "samples") - for item in os.listdir(path): - item = os.path.join(path, item) - if os.path.isdir(item): - for name in ["build.xml", "local.properties", "proguard-project.txt"]: - rm_one(os.path.join(item, name)) - #=================================================================================================== @@ -296,14 +229,13 @@ if __name__ == "__main__": parser = argparse.ArgumentParser(description='Build OpenCV for Android SDK') parser.add_argument("work_dir", nargs='?', default='.', help="Working directory (and output)") parser.add_argument("opencv_dir", nargs='?', default=os.path.join(SCRIPT_DIR, '../..'), help="Path to OpenCV source dir") - parser.add_argument('--config', default='ndk-10.config.py', type=str, help="Package build configuration", ) + parser.add_argument('--config', default='ndk-18.config.py', type=str, help="Package build configuration", ) parser.add_argument('--ndk_path', help="Path to Android NDK to use for build") parser.add_argument('--sdk_path', help="Path to Android SDK to use for build") parser.add_argument("--extra_modules_path", help="Path to extra modules to use for build") parser.add_argument('--sign_with', help="Certificate to sign the Manager apk") parser.add_argument('--build_doc', action="store_true", help="Build javadoc") parser.add_argument('--no_ccache', action="store_true", help="Do not use ccache during library build") - parser.add_argument('--extra_pack', action='append', help="provide extra OpenCV libraries for Manager apk in form :, for example '2.4.11:unpacked/sdk/native/libs'") parser.add_argument('--force_copy', action="store_true", help="Do not use file move during library build (useful for debug)") parser.add_argument('--force_opencv_toolchain', action="store_true", help="Do not use toolchain from Android NDK") args = parser.parse_args() @@ -316,6 +248,9 @@ if __name__ == "__main__": if args.sdk_path is not None: os.environ["ANDROID_SDK"] = args.sdk_path + if not 'ANDROID_HOME' in os.environ and 'ANDROID_SDK' in os.environ: + os.environ['ANDROID_HOME'] = os.environ["ANDROID_SDK"] + if os.path.realpath(args.work_dir) == os.path.realpath(SCRIPT_DIR): raise Fail("Specify workdir (building from script directory is not supported)") if os.path.realpath(args.work_dir) == os.path.realpath(args.opencv_dir): @@ -348,20 +283,9 @@ if __name__ == "__main__": builder = Builder(args.work_dir, args.opencv_dir, args) log.info("Detected OpenCV version: %s", builder.opencv_version) - log.info("Detected Engine version: %s", builder.engine_version) - if args.extra_pack: - for one in args.extra_pack: - i = one.find(":") - if i > 0 and i < len(one) - 1: - builder.add_extra_pack(one[:i], one[i+1:]) - else: - raise Fail("Bad extra pack provided: %s, should be in form ':'" % one) - - engines = [] for i, abi in enumerate(ABIs): do_install = (i == 0) - engdest = check_dir(os.path.join(builder.workdir, "build_service_%s" % abi.name), create=True, clean=True) log.info("=====") log.info("===== Building library for %s", abi) @@ -371,15 +295,7 @@ if __name__ == "__main__": builder.clean_library_build_dir() builder.build_library(abi, do_install) - log.info("=====") - log.info("===== Building engine for %s", abi) - log.info("=====") - - os.chdir(engdest) - builder.build_engine(abi, engdest) - engines.append((abi.name, engdest)) - - builder.gather_results(engines) + builder.gather_results() if args.build_doc: builder.build_javadoc() diff --git a/platforms/android/ndk-18.config.py b/platforms/android/ndk-18.config.py new file mode 100644 index 0000000000..9a9b5cc3e8 --- /dev/null +++ b/platforms/android/ndk-18.config.py @@ -0,0 +1,6 @@ +ABIs = [ + ABI("2", "armeabi-v7a", None, cmake_vars=dict(ANDROID_ABI='armeabi-v7a with NEON')), + ABI("3", "arm64-v8a", None), + ABI("5", "x86_64", None), + ABI("4", "x86", None), +] diff --git a/platforms/android/service/CMakeLists.txt b/platforms/android/service/CMakeLists.txt index b031003177..66e0c468a9 100644 --- a/platforms/android/service/CMakeLists.txt +++ b/platforms/android/service/CMakeLists.txt @@ -1,3 +1,8 @@ +if(NOT ANDROID_PROJECTS_BUILD_TYPE STREQUAL "ANT") + message(STATUS "Android OpenCV Manager is ignored") + return() +endif() + if(BUILD_ANDROID_SERVICE) add_subdirectory(engine) endif() diff --git a/samples/android/15-puzzle/build.gradle.in b/samples/android/15-puzzle/build.gradle.in new file mode 100644 index 0000000000..ad5c9f93f9 --- /dev/null +++ b/samples/android/15-puzzle/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.puzzle15" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/15-puzzle/gradle/AndroidManifest.xml b/samples/android/15-puzzle/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..c0c6cbbc8d --- /dev/null +++ b/samples/android/15-puzzle/gradle/AndroidManifest.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/CMakeLists.txt b/samples/android/CMakeLists.txt index 6135eaa0e6..360f1aa2cb 100644 --- a/samples/android/CMakeLists.txt +++ b/samples/android/CMakeLists.txt @@ -15,12 +15,3 @@ add_subdirectory(tutorial-1-camerapreview) add_subdirectory(tutorial-2-mixedprocessing) add_subdirectory(tutorial-3-cameracontrol) add_subdirectory(tutorial-4-opencl) - -# hello-android sample -if(HAVE_opencv_highgui) - add_executable(hello-android hello-android/main.cpp) - ocv_target_include_modules_recurse(hello-android opencv_imgcodecs opencv_videoio opencv_highgui opencv_core opencv_imgproc) - ocv_target_link_libraries(hello-android ${OPENCV_LINKER_LIBS} opencv_imgcodecs opencv_videoio opencv_highgui opencv_core opencv_imgproc) - set_target_properties(hello-android PROPERTIES OUTPUT_NAME hello-android RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}") - add_dependencies(opencv_android_examples hello-android) -endif() diff --git a/samples/android/build.gradle.in b/samples/android/build.gradle.in new file mode 100644 index 0000000000..49a60e290e --- /dev/null +++ b/samples/android/build.gradle.in @@ -0,0 +1,66 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. + +buildscript { + + repositories { + google() + jcenter() + } + dependencies { + classpath 'com.android.tools.build:gradle:@ANDROID_GRADLE_PLUGIN_VERSION@' + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } +} + +allprojects { + repositories { + google() + jcenter() + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} + +//allprojects { +// gradle.projectsEvaluated { +// tasks.withType(JavaCompile) { +// options.compilerArgs << "-Xlint:unchecked" +// options.compilerArgs << "-Xlint:deprecation" +// } +// } +//} + + +gradle.afterProject { project -> + if (project.pluginManager.hasPlugin('com.android.application') + || project.pluginManager.hasPlugin('com.android.library') + || project.pluginManager.hasPlugin('com.android.test') + || project.pluginManager.hasPlugin('com.android.feature') ) { + if (true) { + gradle.println("Override build ABIs for the project ${project.name}") + project.android { + splits { + abi { + enable true + universalApk false + @ANDROID_ABI_FILTER@ + } + } + } + } + + if (true) { + gradle.println("Override lintOptions for the project ${project.name}") + project.android { + lintOptions { + // checkReleaseBuilds false + abortOnError false + } + } + } + } +} diff --git a/samples/android/camera-calibration/build.gradle.in b/samples/android/camera-calibration/build.gradle.in new file mode 100644 index 0000000000..d62b151867 --- /dev/null +++ b/samples/android/camera-calibration/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.cameracalibration" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/camera-calibration/gradle/AndroidManifest.xml b/samples/android/camera-calibration/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..11444ff48c --- /dev/null +++ b/samples/android/camera-calibration/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/color-blob-detection/build.gradle.in b/samples/android/color-blob-detection/build.gradle.in new file mode 100644 index 0000000000..8900e25c16 --- /dev/null +++ b/samples/android/color-blob-detection/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.colorblobdetect" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/color-blob-detection/gradle/AndroidManifest.xml b/samples/android/color-blob-detection/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..1f09a5e3ca --- /dev/null +++ b/samples/android/color-blob-detection/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/face-detection/build.gradle.in b/samples/android/face-detection/build.gradle.in new file mode 100644 index 0000000000..9e3b187a84 --- /dev/null +++ b/samples/android/face-detection/build.gradle.in @@ -0,0 +1,43 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.facedetect" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + + externalNativeBuild { + cmake { + arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@ + targets "detection_based_tracker" + } + } + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } + externalNativeBuild { + cmake { + path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/face-detection/gradle/AndroidManifest.xml b/samples/android/face-detection/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..c9c69fd243 --- /dev/null +++ b/samples/android/face-detection/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/face-detection/jni/CMakeLists.txt b/samples/android/face-detection/jni/CMakeLists.txt new file mode 100644 index 0000000000..d395999ce0 --- /dev/null +++ b/samples/android/face-detection/jni/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.6) + +# Enable C++11 +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED TRUE) + +set(target detection_based_tracker) +project(${target} CXX) + +set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "") +message(STATUS "ANDROID_ABI=${ANDROID_ABI}") +find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS}) + +file(GLOB srcs *.cpp *.c) +file(GLOB hdrs *.hpp *.h) + +include_directories("${CMAKE_CURRENT_LIST_DIR}") +add_library(${target} SHARED ${srcs} ${hdrs}) +target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS}) diff --git a/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp b/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp index ef8c26f85b..6ce36bc527 100644 --- a/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp +++ b/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp @@ -96,8 +96,8 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker je = jenv->FindClass("java/lang/Exception"); jenv->ThrowNew(je, e.what()); } - catch (...) - { + catch (...) + { LOGD("nativeCreateObject caught unknown exception"); jclass je = jenv->FindClass("java/lang/Exception"); jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeCreateObject()"); diff --git a/samples/android/hello-android/CMakeLists.txt b/samples/android/hello-android/CMakeLists.txt deleted file mode 100644 index 032d98369d..0000000000 --- a/samples/android/hello-android/CMakeLists.txt +++ /dev/null @@ -1,66 +0,0 @@ -CMAKE_MINIMUM_REQUIRED( VERSION 2.8 ) - -######################################################### -# Set project name -######################################################### - -IF( NOT PROJECT_NAME ) - IF ( NOT "x$ENV{PROJECT_NAME}" STREQUAL "x" ) - SET( PROJECT_NAME $ENV{PROJECT_NAME} ) - ELSE() - SET( PROJECT_NAME hello-android ) - ENDIF() -ENDIF() -SET( PROJECT_NAME ${PROJECT_NAME} CACHE STRING "The name of your project") - -PROJECT( ${PROJECT_NAME} ) - -######################################################### -# Find OpenCV -######################################################### - -FIND_PACKAGE( OpenCV REQUIRED ) - -######################################################### -# c/c++ flags, includes and lib dependencies -######################################################### - -#notice the "recycling" of CMAKE_C_FLAGS -#this is necessary to pick up android flags -SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic" ) -SET( CMAKE_CPP_FLAGS "${CMAKE_CPP_FLAGS} -Wall -pedantic" ) - -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) - -SET( LIBRARY_DEPS ${OpenCV_LIBS} ) -IF( ANDROID ) - SET( LIBRARY_DEPS ${LIBRARY_DEPS} log dl ) -ENDIF() - -######################################################### -# source files -######################################################### - -FILE( GLOB hdrs "*.h*" ) -FILE( GLOB srcs "*.cpp" ) - -ADD_EXECUTABLE( ${PROJECT_NAME} ${srcs} ) -TARGET_LINK_LIBRARIES( ${PROJECT_NAME} ${LIBRARY_DEPS} ) - -######################################################### -# Summary report -######################################################### -message( STATUS "") -message( STATUS "General configuration for ${PROJECT_NAME} =====================================") -message( STATUS "") -message( STATUS " OpenCV path: ${OpenCV_DIR}") -message( STATUS " Compiler: ${CMAKE_CXX_COMPILER}") -message( STATUS " C++ flags (Release): ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}") -message( STATUS " C++ flags (Debug): ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}") -if(WIN32) -message( STATUS " Linker flags (Release): ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}") -message( STATUS " Linker flags (Debug): ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}") -else() -message( STATUS " Linker flags (Release): ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") -message( STATUS " Linker flags (Debug): ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}") -endif() diff --git a/samples/android/hello-android/cmake_android.cmd b/samples/android/hello-android/cmake_android.cmd deleted file mode 100644 index 65a1461c2f..0000000000 --- a/samples/android/hello-android/cmake_android.cmd +++ /dev/null @@ -1,9 +0,0 @@ -@ECHO OFF -SETLOCAL -PUSHD %~dp0 -SET PROJECT_NAME=hello-android -SET BUILD_DIR=build_armeabi -SET ANDROID_ABI=armeabi -CALL ..\..\..\android\scripts\build.cmd %* -POPD -ENDLOCAL diff --git a/samples/android/hello-android/cmake_android.sh b/samples/android/hello-android/cmake_android.sh deleted file mode 100755 index f233e302ee..0000000000 --- a/samples/android/hello-android/cmake_android.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/sh -cd `dirname $0` - -BUILD_DIR=build_armeabi -opencv_android=`pwd`/../../../android -opencv_build_dir=$opencv_android/$BUILD_DIR - -mkdir -p $BUILD_DIR -cd $BUILD_DIR - -RUN_CMAKE="cmake -DOpenCV_DIR=$opencv_build_dir -DARM_TARGET=armeabi -DCMAKE_TOOLCHAIN_FILE=$opencv_android/android.toolchain.cmake .." -echo $RUN_CMAKE -$RUN_CMAKE diff --git a/samples/android/hello-android/main.cpp b/samples/android/hello-android/main.cpp deleted file mode 100644 index 8684029672..0000000000 --- a/samples/android/hello-android/main.cpp +++ /dev/null @@ -1,28 +0,0 @@ -#include -#include -#include -#include - -using namespace cv; -const char* message = "Hello Android!"; - -int main(int argc, char* argv[]) -{ - (void)argc; (void)argv; - // print message to console - printf("%s\n", message); - - // put message to simple image - Size textsize = getTextSize(message, FONT_HERSHEY_COMPLEX, 3, 5, 0); - Mat img(textsize.height + 20, textsize.width + 20, CV_32FC1, Scalar(230,230,230)); - putText(img, message, Point(10, img.rows - 10), FONT_HERSHEY_COMPLEX, 3, Scalar(0, 0, 0), 5); - - // save\show resulting image -#if ANDROID - imwrite("/mnt/sdcard/HelloAndroid.png", img); -#else - imshow("test", img); - waitKey(); -#endif - return 0; -} diff --git a/samples/android/hello-android/run.cmd b/samples/android/hello-android/run.cmd deleted file mode 100644 index 54a73f0402..0000000000 --- a/samples/android/hello-android/run.cmd +++ /dev/null @@ -1,49 +0,0 @@ -:: this batch file copies compiled executable to the device, -:: runs it and gets resulting image back to the host -:: -:: Here is sample output of successful run: -:: -:: 204 KB/s (2887388 bytes in 13.790s) -:: Hello Android! -:: 304 KB/s (8723 bytes in 0.028s) - -@ECHO OFF - -:: enable command extensions -VERIFY BADVALUE 2>NUL -SETLOCAL ENABLEEXTENSIONS || (ECHO Unable to enable command extensions. & EXIT \B) - -PUSHD %~dp0 -:: project specific settings -SET PROJECT_NAME=hello-android - -:: try to load config file -SET CFG_PATH=..\..\..\android\scripts\wincfg.cmd -IF EXIST %CFG_PATH% CALL %CFG_PATH% - -:: check if sdk path defined -IF NOT DEFINED ANDROID_SDK (ECHO. & ECHO You should set an environment variable ANDROID_SDK to the full path to your copy of Android SDK & GOTO end) -(PUSHD "%ANDROID_SDK%" 2>NUL && POPD) || (ECHO. & ECHO Directory "%ANDROID_SDK%" specified by ANDROID_SDK variable does not exist & GOTO end) -SET adb=%ANDROID_SDK%\platform-tools\adb.exe - -:: copy file to device (usually takes 10 seconds or more) -%adb% push .\bin\%PROJECT_NAME% /data/bin/sample/%PROJECT_NAME% || GOTO end - -:: set execute permission -%adb% shell chmod 777 /data/bin/sample/%PROJECT_NAME% || GOTO end - -:: execute our application -%adb% shell /data/bin/sample/%PROJECT_NAME% || GOTO end - -:: get image result from device -%adb% pull /mnt/sdcard/HelloAndroid.png || GOTO end - -GOTO end - -:: cleanup (comment out GOTO above to enable cleanup) -%adb% shell rm /data/bin/sample/%PROJECT_NAME% -%adb% shell rm /mnt/sdcard/HelloAndroid.png - -:end -POPD -ENDLOCAL diff --git a/samples/android/hello-android/run.sh b/samples/android/hello-android/run.sh deleted file mode 100755 index 1168c51df6..0000000000 --- a/samples/android/hello-android/run.sh +++ /dev/null @@ -1,15 +0,0 @@ -#!/bin/sh -cd `dirname $0` -PROJECT_NAME=hello-android - -# copy file to device (usually takes 10 seconds or more) -adb push ./bin/$PROJECT_NAME /data/bin/sample/$PROJECT_NAME || return - -# set execute permission -adb shell chmod 777 /data/bin/sample/$PROJECT_NAME || return - -# execute our application -adb shell /data/bin/sample/$PROJECT_NAME || return - -# get image result from device -adb pull /mnt/sdcard/HelloAndroid.png || return diff --git a/samples/android/image-manipulations/build.gradle.in b/samples/android/image-manipulations/build.gradle.in new file mode 100644 index 0000000000..0d685ed410 --- /dev/null +++ b/samples/android/image-manipulations/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.imagemanipulations" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/image-manipulations/gradle/AndroidManifest.xml b/samples/android/image-manipulations/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..5c3b71a77b --- /dev/null +++ b/samples/android/image-manipulations/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/mobilenet-objdetect/AndroidManifest.xml b/samples/android/mobilenet-objdetect/AndroidManifest.xml index cfe8d4ed69..e8d17ba6a3 100644 --- a/samples/android/mobilenet-objdetect/AndroidManifest.xml +++ b/samples/android/mobilenet-objdetect/AndroidManifest.xml @@ -2,27 +2,27 @@ - - - - - - - - + + + + + + + + - - - - - - + + + + + + diff --git a/samples/android/mobilenet-objdetect/build.gradle.in b/samples/android/mobilenet-objdetect/build.gradle.in new file mode 100644 index 0000000000..e8238f7324 --- /dev/null +++ b/samples/android/mobilenet-objdetect/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.opencv_mobilenet" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 341 + versionName "3.41" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml b/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..d17e633b41 --- /dev/null +++ b/samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/tutorial-1-camerapreview/build.gradle.in b/samples/android/tutorial-1-camerapreview/build.gradle.in new file mode 100644 index 0000000000..5a649175dc --- /dev/null +++ b/samples/android/tutorial-1-camerapreview/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.tutorial1" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml b/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..490dd6a1e7 --- /dev/null +++ b/samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/tutorial-2-mixedprocessing/build.gradle.in b/samples/android/tutorial-2-mixedprocessing/build.gradle.in new file mode 100644 index 0000000000..7eca49b1b1 --- /dev/null +++ b/samples/android/tutorial-2-mixedprocessing/build.gradle.in @@ -0,0 +1,43 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.tutorial2" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + + externalNativeBuild { + cmake { + arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@ + targets "mixed_sample" + } + } + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } + externalNativeBuild { + cmake { + path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml b/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..34753e4daa --- /dev/null +++ b/samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt b/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt new file mode 100644 index 0000000000..2219121fde --- /dev/null +++ b/samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.6) + +# Enable C++11 +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED TRUE) + +set(target mixed_sample) +project(${target} CXX) + +set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "") +message(STATUS "ANDROID_ABI=${ANDROID_ABI}") +find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS}) + +file(GLOB srcs *.cpp *.c) +file(GLOB hdrs *.hpp *.h) + +include_directories("${CMAKE_CURRENT_LIST_DIR}") +add_library(${target} SHARED ${srcs} ${hdrs}) +target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS}) diff --git a/samples/android/tutorial-3-cameracontrol/build.gradle.in b/samples/android/tutorial-3-cameracontrol/build.gradle.in new file mode 100644 index 0000000000..0ba304f5e5 --- /dev/null +++ b/samples/android/tutorial-3-cameracontrol/build.gradle.in @@ -0,0 +1,31 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.tutorial3" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml b/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..4985185b10 --- /dev/null +++ b/samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/tutorial-4-opencl/build.gradle.in b/samples/android/tutorial-4-opencl/build.gradle.in new file mode 100644 index 0000000000..2cb9a7bcb9 --- /dev/null +++ b/samples/android/tutorial-4-opencl/build.gradle.in @@ -0,0 +1,43 @@ +apply plugin: 'com.android.application' + +android { + compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@ + defaultConfig { + applicationId "org.opencv.samples.tutorial4" + minSdkVersion @ANDROID_MIN_SDK_VERSION@ + targetSdkVersion @ANDROID_TARGET_SDK_VERSION@ + versionCode 301 + versionName "3.01" + + externalNativeBuild { + cmake { + arguments "-DOpenCV_DIR=" + project(':opencv').projectDir + "/@ANDROID_PROJECT_JNI_PATH@"@OPENCV_ANDROID_CMAKE_EXTRA_ARGS@ + targets "JNIpart" + } + } + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + } + } + sourceSets { + main { + java.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + aidl.srcDirs = @ANDROID_SAMPLE_JAVA_PATH@ + res.srcDirs = @ANDROID_SAMPLE_RES_PATH@ + manifest.srcFile '@ANDROID_SAMPLE_MANIFEST_PATH@' + } + } + externalNativeBuild { + cmake { + path '@ANDROID_SAMPLE_JNI_PATH@/CMakeLists.txt' + } + } +} + +dependencies { + //implementation fileTree(dir: 'libs', include: ['*.jar']) + implementation project(':opencv') +} diff --git a/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml b/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml new file mode 100644 index 0000000000..6bce3c7191 --- /dev/null +++ b/samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/samples/android/tutorial-4-opencl/jni/CMakeLists.txt b/samples/android/tutorial-4-opencl/jni/CMakeLists.txt new file mode 100644 index 0000000000..6b3f3a0940 --- /dev/null +++ b/samples/android/tutorial-4-opencl/jni/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.6) + +# Enable C++11 +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED TRUE) + +set(target mixed_sample) +project(${target} CXX) + +set(ANDROID_OPENCV_COMPONENTS "opencv_java" CACHE STRING "") +message(STATUS "ANDROID_ABI=${ANDROID_ABI}") +find_package(OpenCV REQUIRED COMPONENTS ${ANDROID_OPENCV_COMPONENTS}) + +file(GLOB srcs *.cpp *.c) +file(GLOB hdrs *.hpp *.h) + +include_directories("${CMAKE_CURRENT_LIST_DIR}") +add_library(${target} SHARED ${srcs} ${hdrs}) +target_link_libraries(${target} ${ANDROID_OPENCV_COMPONENTS} -lGLESv2 -lEGL -lOpenCL)