Skip to content

O
opencv
Commit 2b35c170 authored by Alexander Alekhin's avatar Alexander Alekhin Committed by Alexander Alekhin
Browse files
Options

android: gradle-based package and samples 

- drop hello-android sample
parent d5f430cc
Hide whitespace changes
Inline Side-by-side
Showing with 1218 additions and 568 deletions
cmake/android/OpenCVDetectAndroidSDK.cmake
View file @ 2b35c170
...@@ -8,6 +8,24 @@ if(DEFINED ANDROID_NDK_REVISION AND ANDROID_NDK_REVISION MATCHES "(1[56])([0-9]+ ...@@ -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") set(ANDROID_NDK_REVISION "${ANDROID_NDK_REVISION}" CACHE INTERNAL "Android NDK revision")
endif() 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 # https://developer.android.com/studio/command-line/variables.html
ocv_check_environment_variables(ANDROID_SDK_ROOT ANDROID_HOME ANDROID_SDK) ocv_check_environment_variables(ANDROID_SDK_ROOT ANDROID_HOME ANDROID_SDK)
......
cmake/android/android_gradle_projects.cmake
View file @ 2b35c170
message(FATAL_ERROR " # https://developer.android.com/studio/releases/gradle-plugin
Android gradle-based build/projects are not supported in this version of OpenCV. set(ANDROID_GRADLE_PLUGIN_VERSION "3.2.1" CACHE STRING "Android Gradle Plugin version (3.0+)")
You need to downgrade Android SDK Tools to version 25.2.5. message(STATUS "Android Gradle Plugin version: ${ANDROID_GRADLE_PLUGIN_VERSION}")
Details: https://github.com/opencv/opencv/issues/8460
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='/<path to OpenCV-android-sdk>'
//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)
modules/java/CMakeLists.txt
View file @ 2b35c170
...@@ -3,8 +3,8 @@ if(OPENCV_INITIAL_PASS) ...@@ -3,8 +3,8 @@ if(OPENCV_INITIAL_PASS)
add_subdirectory(generator) add_subdirectory(generator)
endif() endif()
if(APPLE_FRAMEWORK OR WINRT OR NOT PYTHON_DEFAULT_AVAILABLE OR NOT ANT_EXECUTABLE 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 ANDROID_NATIVE_API_LEVEL GREATER 7)) OR NOT (JNI_FOUND OR (ANDROID AND (NOT DEFINED ANDROID_NATIVE_API_LEVEL OR ANDROID_NATIVE_API_LEVEL GREATER 7)))
OR BUILD_opencv_world OR BUILD_opencv_world
) )
ocv_module_disable(java) ocv_module_disable(java)
...@@ -55,7 +55,7 @@ macro(copy_common_tests _src_location _dst_location _deps) ...@@ -55,7 +55,7 @@ macro(copy_common_tests _src_location _dst_location _deps)
endmacro() 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) if(ANDROID)
add_subdirectory(android_sdk) # generates ${the_module}_android target add_subdirectory(android_sdk) # generates ${the_module}_android target
else() else()
......
modules/java/android_sdk/CMakeLists.txt
View file @ 2b35c170
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) 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 set(OPENCV_ANDROID_LIB_DIR "${OPENCV_JAVA_DIR}" CACHE INTERNAL "") # for OpenCV samples
file(REMOVE_RECURSE "${OPENCV_JAVA_DIR}") file(REMOVE_RECURSE "${OPENCV_JAVA_DIR}")
...@@ -15,6 +14,11 @@ set(java_src_dir "${OPENCV_JAVA_DIR}/src") ...@@ -15,6 +14,11 @@ set(java_src_dir "${OPENCV_JAVA_DIR}/src")
file(MAKE_DIRECTORY "${java_src_dir}") file(MAKE_DIRECTORY "${java_src_dir}")
ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/java" "${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}") ocv_copyfiles_append_dir(JAVA_SRC_COPY "${OPENCV_JAVA_BINDINGS_DIR}/gen/android/java" "${java_src_dir}")
# calc default SDK Target # calc default SDK Target
...@@ -90,5 +94,57 @@ FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT ...@@ -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\") FILE(MAKE_DIRECTORY \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${JAVA_INSTALL_ROOT}/res\")
" COMPONENT java) " 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) 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) 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
modules/java/android_sdk/android_gradle_lib/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv"
android:versionCode="@OPENCV_VERSION_MAJOR@@OPENCV_VERSION_MINOR@@OPENCV_VERSION_PATCH@0"
android:versionName="@OPENCV_VERSION@">
</manifest>
modules/java/android_sdk/android_gradle_lib/build.gradle 0 → 100644
View file @ 2b35c170
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 {
}
modules/java/android_sdk/android_gradle_lib/res/values/attrs.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name = "CameraBridgeViewBase" >
<attr name="show_fps" format="boolean"/>
<attr name="camera_id" format="integer" >
<enum name="any" value="-1" />
<enum name="back" value="99" />
<enum name="front" value="98" />
</attr>
</declare-styleable>
</resources>
modules/java/android_sdk/build.gradle.in
View file @ 2b35c170
...@@ -81,9 +81,9 @@ ...@@ -81,9 +81,9 @@
// splits { // splits {
// abi { // abi {
// enable true // enable true
// universalApk false
// reset() // reset()
// include 'armeabi-v7a' // , 'x86', 'x86_64', 'arm64-v8a' // include 'armeabi-v7a' // , 'x86', 'x86_64', 'arm64-v8a'
// universalApk false
// } // }
// } // }
// //
...@@ -93,12 +93,12 @@ apply plugin: 'com.android.library' ...@@ -93,12 +93,12 @@ apply plugin: 'com.android.library'
println "OpenCV: " + project.buildscript.sourceFile println "OpenCV: " + project.buildscript.sourceFile
android { android {
compileSdkVersion 27 compileSdkVersion @ANDROID_COMPILE_SDK_VERSION@
//buildToolsVersion "27.0.3" // not needed since com.android.tools.build:gradle:3.0.0 //buildToolsVersion "x.y.z" // not needed since com.android.tools.build:gradle:3.0.0
defaultConfig { defaultConfig {
minSdkVersion 14 minSdkVersion @ANDROID_MIN_SDK_VERSION@
targetSdkVersion 21 targetSdkVersion @ANDROID_TARGET_SDK_VERSION@
} }
buildTypes { buildTypes {
......
modules/java/jni/CMakeLists.txt
View file @ 2b35c170
...@@ -13,6 +13,12 @@ foreach(m ${OPENCV_MODULES_BUILD}) ...@@ -13,6 +13,12 @@ foreach(m ${OPENCV_MODULES_BUILD})
endif() endif()
endforeach() 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) set(__type MODULE)
if(BUILD_FAT_JAVA_LIB) if(BUILD_FAT_JAVA_LIB)
set(__type SHARED) # samples link to libopencv_java set(__type SHARED) # samples link to libopencv_java
...@@ -60,7 +66,7 @@ endif() ...@@ -60,7 +66,7 @@ endif()
set_target_properties(${the_module} PROPERTIES set_target_properties(${the_module} PROPERTIES
OUTPUT_NAME "${the_module}${OPENCV_JAVA_LIB_NAME_SUFFIX}" OUTPUT_NAME "${the_module}${OPENCV_JAVA_LIB_NAME_SUFFIX}"
ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH} LIBRARY_OUTPUT_DIRECTORY ${JNI_OUTPUT_PATH}
RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
DEFINE_SYMBOL CVAPI_EXPORTS DEFINE_SYMBOL CVAPI_EXPORTS
) )
......
platforms/android/build-tests/test_ant_build.py deleted 100644 → 0
View file @ d5f430cc
#!/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>/sdk/java/)")
parser.add_argument("opencv_samples_path", help="Path to folder with SDK samples (usually <SDK>/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)
platforms/android/build-tests/test_cmake_build.py
View file @ 2b35c170
...@@ -44,18 +44,29 @@ int main(int argc, char* argv[]) ...@@ -44,18 +44,29 @@ int main(int argc, char* argv[])
#=================================================================================================== #===================================================================================================
class TestCmakeBuild(unittest.TestCase): 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) unittest.TestCase.__init__(self, *args, **kwargs)
self.libset = libset self.libset = libset
self.abi = abi self.abi = abi
self.toolchain = toolchain self.cmake_vars = cmake_vars
self.opencv_cmake_path = opencv_cmake_path self.opencv_cmake_path = opencv_cmake_path
self.workdir = workdir self.workdir = workdir
self.srcdir = os.path.join(self.workdir, "src") self.srcdir = os.path.join(self.workdir, "src")
self.bindir = os.path.join(self.workdir, "build") self.bindir = os.path.join(self.workdir, "build")
def shortDescription(self): 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): def gen_cmakelists(self):
return CMAKE_TEMPLATE % {"libset": self.libset} return CMAKE_TEMPLATE % {"libset": self.libset}
...@@ -78,43 +89,40 @@ class TestCmakeBuild(unittest.TestCase): ...@@ -78,43 +89,40 @@ class TestCmakeBuild(unittest.TestCase):
os.chdir(self.bindir) os.chdir(self.bindir)
def tearDown(self): def tearDown(self):
if os.path.exists(self.workdir): pass
shutil.rmtree(self.workdir) #if os.path.exists(self.workdir):
# shutil.rmtree(self.workdir)
def runTest(self): def runTest(self):
cmd = [ cmd = [
"cmake", "cmake",
"-GNinja", "-GNinja",
"-DOpenCV_DIR=%s" % self.opencv_cmake_path, "-DOpenCV_DIR=%s" % self.opencv_cmake_path,
"-DANDROID_ABI=%s" % self.abi, "-DCMAKE_TOOLCHAIN_FILE=%s" % self.getCMakeToolchain(),
"-DCMAKE_TOOLCHAIN_FILE=%s" % os.path.join(self.opencv_cmake_path, "android.toolchain.cmake"),
"-DANDROID_TOOLCHAIN_NAME=%s" % self.toolchain,
self.srcdir self.srcdir
] ] + [ "-D{}={}".format(key, value) for key, value in self.cmake_vars.items() ]
log.info("Executing: %s" % cmd) log.info("Executing: %s" % cmd)
retcode = subprocess.call(cmd) retcode = subprocess.call(cmd)
self.assertEqual(retcode, 0, "cmake failed") self.assertEqual(retcode, 0, "cmake failed")
cmd = ["ninja"] cmd = ["ninja", "-v"]
log.info("Executing: %s" % cmd) log.info("Executing: %s" % cmd)
retcode = subprocess.call(cmd) retcode = subprocess.call(cmd)
self.assertEqual(retcode, 0, "make failed") self.assertEqual(retcode, 0, "make failed")
def suite(workdir, opencv_cmake_path): def suite(workdir, opencv_cmake_path):
abis = { abis = {
"armeabi":"arm-linux-androideabi-4.8", "armeabi-v7a": { "ANDROID_ABI": "armeabi-v7a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" },
"armeabi-v7a":"arm-linux-androideabi-4.8", "arm64-v8a": { "ANDROID_ABI": "arm64-v8a", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" },
"arm64-v8a":"aarch64-linux-android-4.9", "x86": { "ANDROID_ABI": "x86", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" },
"x86":"x86-4.8", "x86_64": { "ANDROID_ABI": "x86_64", "ANDROID_TOOLCHAIN": "clang", "ANDROID_STL": "c++_static" },
"x86_64":"x86_64-4.9",
"mips":"mipsel-linux-android-4.8",
"mips64":"mips64el-linux-android-4.9"
} }
suite = unittest.TestSuite() suite = unittest.TestSuite()
for libset in ["", "opencv_java"]: for libset in ["", "opencv_java"]:
for abi, toolchain in abis.items(): for abi, cmake_vars in abis.items():
suite.addTest(TestCmakeBuild(libset, abi, toolchain, opencv_cmake_path, workdir)) suite.addTest(TestCmakeBuild(libset, abi, cmake_vars, opencv_cmake_path,
os.path.join(workdir, "{}-{}".format(abi, "static" if libset == "" else "shared"))))
return suite return suite
...@@ -132,9 +140,15 @@ if __name__ == '__main__': ...@@ -132,9 +140,15 @@ if __name__ == '__main__':
if args.ndk_path is not None: if args.ndk_path is not None:
os.environ["ANDROID_NDK"] = os.path.abspath(args.ndk_path) 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 SDK: %s" % os.environ["ANDROID_SDK"])
print("Using NDK: %s" % os.environ["ANDROID_NDK"]) 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(): if not res.wasSuccessful():
sys.exit(res) sys.exit(res)
platforms/android/build-tests/test_gradle.sh 0 → 100755
View file @ 2b35c170
#!/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 "#"
platforms/android/build-tests/test_ndk_build.py deleted 100644 → 0
View file @ d5f430cc
#!/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 <jni.h>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features2d.hpp>
#include <vector>
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<KeyPoint> v;
Ptr<FastFeatureDetector> 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>/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)
platforms/android/build_sdk.py
View file @ 2b35c170
...@@ -48,10 +48,6 @@ def check_dir(d, create=False, clean=False): ...@@ -48,10 +48,6 @@ def check_dir(d, create=False, clean=False):
os.makedirs(d) os.makedirs(d)
return 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): 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 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 # version in master - CV_VERSION_MAJOR.CV_VERSION_MINOR.CV_VERSION_REVISION-CV_VERSION_STATUS
...@@ -133,7 +129,6 @@ class Builder: ...@@ -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.docdest = check_dir(os.path.join(self.workdir, 'OpenCV-android-sdk', 'sdk', 'java', 'javadoc'), create=True, clean=True)
self.extra_packs = [] self.extra_packs = []
self.opencv_version = determine_opencv_version(os.path.join(self.opencvdir, "modules", "core", "include", "opencv2", "core", "version.hpp")) 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 self.use_ccache = False if config.no_ccache else True
def get_toolchain_file(self): def get_toolchain_file(self):
...@@ -163,6 +158,7 @@ class Builder: ...@@ -163,6 +158,7 @@ class Builder:
cmd = ["cmake", "-GNinja"] cmd = ["cmake", "-GNinja"]
cmake_vars = dict( cmake_vars = dict(
CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(), CMAKE_TOOLCHAIN_FILE=self.get_toolchain_file(),
INSTALL_CREATE_DISTRIB="ON",
WITH_OPENCL="OFF", WITH_OPENCL="OFF",
WITH_IPP=("ON" if abi.haveIPP() else "OFF"), WITH_IPP=("ON" if abi.haveIPP() else "OFF"),
WITH_TBB="ON", WITH_TBB="ON",
...@@ -186,51 +182,7 @@ class Builder: ...@@ -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 += [ "-D%s='%s'" % (k, v) for (k, v) in cmake_vars.items() if v is not None]
cmd.append(self.opencvdir) cmd.append(self.opencvdir)
execute(cmd) execute(cmd)
if do_install: execute(["ninja", "install/strip"])
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
def build_javadoc(self): def build_javadoc(self):
classpaths = [] classpaths = []
...@@ -251,7 +203,7 @@ class Builder: ...@@ -251,7 +203,7 @@ class Builder:
] ]
execute(cmd) execute(cmd)
def gather_results(self, engines): def gather_results(self):
# Copy all files # Copy all files
root = os.path.join(self.libdest, "install") root = os.path.join(self.libdest, "install")
for item in os.listdir(root): for item in os.listdir(root):
...@@ -270,25 +222,6 @@ class Builder: ...@@ -270,25 +222,6 @@ class Builder:
else: else:
shutil.move(src, dst) 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__": ...@@ -296,14 +229,13 @@ if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Build OpenCV for Android SDK') parser = argparse.ArgumentParser(description='Build OpenCV for Android SDK')
parser.add_argument("work_dir", nargs='?', default='.', help="Working directory (and output)") 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("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('--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('--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("--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('--sign_with', help="Certificate to sign the Manager apk")
parser.add_argument('--build_doc', action="store_true", help="Build javadoc") 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('--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 <version>:<path-to-native-libs>, 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_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") parser.add_argument('--force_opencv_toolchain', action="store_true", help="Do not use toolchain from Android NDK")
args = parser.parse_args() args = parser.parse_args()
...@@ -316,6 +248,9 @@ if __name__ == "__main__": ...@@ -316,6 +248,9 @@ if __name__ == "__main__":
if args.sdk_path is not None: if args.sdk_path is not None:
os.environ["ANDROID_SDK"] = args.sdk_path 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): if os.path.realpath(args.work_dir) == os.path.realpath(SCRIPT_DIR):
raise Fail("Specify workdir (building from script directory is not supported)") raise Fail("Specify workdir (building from script directory is not supported)")
if os.path.realpath(args.work_dir) == os.path.realpath(args.opencv_dir): if os.path.realpath(args.work_dir) == os.path.realpath(args.opencv_dir):
...@@ -348,20 +283,9 @@ if __name__ == "__main__": ...@@ -348,20 +283,9 @@ if __name__ == "__main__":
builder = Builder(args.work_dir, args.opencv_dir, args) builder = Builder(args.work_dir, args.opencv_dir, args)
log.info("Detected OpenCV version: %s", builder.opencv_version) 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 '<version>:<path-to-native-libs>'" % one)
engines = []
for i, abi in enumerate(ABIs): for i, abi in enumerate(ABIs):
do_install = (i == 0) 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("=====")
log.info("===== Building library for %s", abi) log.info("===== Building library for %s", abi)
...@@ -371,15 +295,7 @@ if __name__ == "__main__": ...@@ -371,15 +295,7 @@ if __name__ == "__main__":
builder.clean_library_build_dir() builder.clean_library_build_dir()
builder.build_library(abi, do_install) builder.build_library(abi, do_install)
log.info("=====") builder.gather_results()
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)
if args.build_doc: if args.build_doc:
builder.build_javadoc() builder.build_javadoc()
......
platforms/android/ndk-18.config.py 0 → 100644
View file @ 2b35c170
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),
]
platforms/android/service/CMakeLists.txt
View file @ 2b35c170
if(NOT ANDROID_PROJECTS_BUILD_TYPE STREQUAL "ANT")
message(STATUS "Android OpenCV Manager is ignored")
return()
endif()
if(BUILD_ANDROID_SERVICE) if(BUILD_ANDROID_SERVICE)
add_subdirectory(engine) add_subdirectory(engine)
endif() endif()
......
samples/android/15-puzzle/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/15-puzzle/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.puzzle15"
>
<application
android:icon="@drawable/icon"
android:label="@string/app_name"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity
android:name=".Puzzle15Activity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/CMakeLists.txt
View file @ 2b35c170
...@@ -15,12 +15,3 @@ add_subdirectory(tutorial-1-camerapreview) ...@@ -15,12 +15,3 @@ add_subdirectory(tutorial-1-camerapreview)
add_subdirectory(tutorial-2-mixedprocessing) add_subdirectory(tutorial-2-mixedprocessing)
add_subdirectory(tutorial-3-cameracontrol) add_subdirectory(tutorial-3-cameracontrol)
add_subdirectory(tutorial-4-opencl) 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()
samples/android/build.gradle.in 0 → 100644
View file @ 2b35c170
// 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
}
}
}
}
}
samples/android/camera-calibration/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/camera-calibration/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.cameracalibration"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
<activity android:name="CameraCalibrationActivity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/color-blob-detection/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/color-blob-detection/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.colorblobdetect"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="ColorBlobDetectionActivity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/face-detection/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/face-detection/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.facedetect"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="FdActivity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/face-detection/jni/CMakeLists.txt 0 → 100644
View file @ 2b35c170
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})
samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp
View file @ 2b35c170
...@@ -96,8 +96,8 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker ...@@ -96,8 +96,8 @@ JNIEXPORT jlong JNICALL Java_org_opencv_samples_facedetect_DetectionBasedTracker
je = jenv->FindClass("java/lang/Exception"); je = jenv->FindClass("java/lang/Exception");
jenv->ThrowNew(je, e.what()); jenv->ThrowNew(je, e.what());
} }
catch (...) catch (...)
{ {
LOGD("nativeCreateObject caught unknown exception"); LOGD("nativeCreateObject caught unknown exception");
jclass je = jenv->FindClass("java/lang/Exception"); jclass je = jenv->FindClass("java/lang/Exception");
jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeCreateObject()"); jenv->ThrowNew(je, "Unknown exception in JNI code of DetectionBasedTracker.nativeCreateObject()");
......
samples/android/hello-android/CMakeLists.txt deleted 100644 → 0
View file @ d5f430cc
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()
samples/android/hello-android/cmake_android.cmd deleted 100644 → 0
View file @ d5f430cc
@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
samples/android/hello-android/cmake_android.sh deleted 100755 → 0
View file @ d5f430cc
#!/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
samples/android/hello-android/main.cpp deleted 100644 → 0
View file @ d5f430cc
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
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;
}
samples/android/hello-android/run.cmd deleted 100644 → 0
View file @ d5f430cc
:: 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
samples/android/hello-android/run.sh deleted 100755 → 0
View file @ d5f430cc
#!/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
samples/android/image-manipulations/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/image-manipulations/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.imagemanipulations"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="ImageManipulationsActivity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/mobilenet-objdetect/AndroidManifest.xml
View file @ 2b35c170
...@@ -2,27 +2,27 @@ ...@@ -2,27 +2,27 @@
<manifest xmlns:android="http://schemas.android.com/apk/res/android" <manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.opencv_mobilenet"> package="org.opencv.samples.opencv_mobilenet">
<application <application
android:allowBackup="true" android:allowBackup="true"
android:icon="@mipmap/ic_launcher" android:icon="@mipmap/ic_launcher"
android:label="@string/app_name" android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round" android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true" android:supportsRtl="true"
android:theme="@style/Theme.AppCompat.NoActionBar"> <!--Full screen mode--> android:theme="@style/Theme.AppCompat.NoActionBar"> <!--Full screen mode-->
<activity android:name=".MainActivity" <activity android:name=".MainActivity"
android:screenOrientation="landscape"> <!--Screen orientation--> android:screenOrientation="landscape"> <!--Screen orientation-->
<intent-filter> <intent-filter>
<action android:name="android.intent.action.MAIN" /> <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" /> <category android:name="android.intent.category.LAUNCHER" />
</intent-filter> </intent-filter>
</activity> </activity>
</application> </application>
<!--Allow to use a camera--> <!--Allow to use a camera-->
<uses-permission android:name="android.permission.CAMERA"/> <uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/> <uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/> <uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/> <uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/> <uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest> </manifest>
samples/android/mobilenet-objdetect/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/mobilenet-objdetect/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.opencv_mobilenet"
>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.AppCompat.NoActionBar"> <!--Full screen mode-->
<activity android:name=".MainActivity"
android:screenOrientation="landscape"> <!--Screen orientation-->
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<!--Allow to use a camera-->
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/tutorial-1-camerapreview/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/tutorial-1-camerapreview/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.tutorial1"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="Tutorial1Activity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/tutorial-2-mixedprocessing/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/tutorial-2-mixedprocessing/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.tutorial2"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="Tutorial2Activity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
</manifest>
samples/android/tutorial-2-mixedprocessing/jni/CMakeLists.txt 0 → 100644
View file @ 2b35c170
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})
samples/android/tutorial-3-cameracontrol/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/tutorial-3-cameracontrol/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.tutorial3"
>
<application
android:label="@string/app_name"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity android:name="Tutorial3Activity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<supports-screens android:resizeable="true"
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:anyDensity="true" />
<uses-permission android:name="android.permission.CAMERA"/>
<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front" android:required="false"/>
<uses-feature android:name="android.hardware.camera.front.autofocus" android:required="false"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
</manifest>
samples/android/tutorial-4-opencl/build.gradle.in 0 → 100644
View file @ 2b35c170
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')
}
samples/android/tutorial-4-opencl/gradle/AndroidManifest.xml 0 → 100644
View file @ 2b35c170
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.samples.tutorial4"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="14"
android:targetSdkVersion="21" />
<uses-feature android:glEsVersion="0x00020000" android:required="true"/>
<uses-feature android:name="android.hardware.camera"/>
<uses-feature android:name="android.hardware.camera2" android:required="false"/>
<uses-permission android:name="android.permission.CAMERA"/>
<application
android:allowBackup="true"
android:icon="@drawable/icon"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<activity
android:name=".Tutorial4Activity"
android:label="@string/app_name"
android:screenOrientation="landscape"
android:configChanges="keyboardHidden|orientation">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
samples/android/tutorial-4-opencl/jni/CMakeLists.txt 0 → 100644
View file @ 2b35c170
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)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment