Addons CMake for includes/libs and src

Author: danoli3

scripts/templates/android/ofApp/build.gradle

@@ -25,51 +25,148 @@ tasks.register("prepareKotlinBuildScriptModel"){
 def projectRoot = rootProject.projectDir.absolutePath
 def addonFile = new File(projectRoot, "addons.make")
 
+println "projectRoot = ${projectRoot}"
+println "addonFile = ${addonFile.absolutePath}"
+
+
 // Get all addon paths from addons.make
+
+def ofRoot = "/../../../"
+
 def addonPaths = []
 if (addonFile.exists()) {
 	addonFile.eachLine { line ->
-		def addonPath = ofRoot + "addons/" + line
-		if (new File(addonPath).exists()) {
+		def addonRelPath = ofRoot + "/addons/" + line.trim()
+		def addonPath = new File(projectRoot, addonRelPath).canonicalFile
+		println "Resolved addon path: ${addonPath}"
+		if (addonPath.exists()) {
 			addonPaths.add(addonPath)
+		} else {
+			println "Missing addon path: ${addonPath}"
 		}
 	}
 }
 
+println "Checking path: ${addonPaths}"
+
+
 def addonIncludeDirs = []
+def addonSourceFiles = []
 def addonLibs = []
 
 // Collect include directories and libraries for each addon
 addonPaths.each { addon ->
+	// Add addon/src
 	def includePath = new File(addon, "src")
 	if (includePath.exists()) {
 		addonIncludeDirs.add(includePath.absolutePath)
+		includePath.eachFileRecurse { file ->
+			if (file.name.endsWith(".cpp") || file.name.endsWith(".c")) {
+				println "Found C/CPP source: ${file}"
+				addonSourceFiles.add(file.absolutePath)
+			}
+		}
+		def javaDirs = [
+			new File(addon, "java"),
+			new File(addon, "kotlin"),
+			new File(addon, "srcJava"),
+			new File(addon, "src")
+		]
+		javaDirs.each { dir ->
+			if (dir.exists()) {
+				dir.eachFileRecurse { file ->
+					if (file.name.endsWith(".java") || file.name.endsWith(".kt")) {
+						println "Found Java/Kotlin source: ${file}"
+						addonSourceFiles.add(file.absolutePath)
+					}
+				}
+			}
+		}
+	}
+	// Add libs/*/include/
+	def libsDir = new File(addon, "libs")
+	if (libsDir.exists()) {
+		libsDir.eachDir { subLib ->
+			def includeDir = new File(subLib, "include").canonicalFile
+			if (includeDir.exists()) {
+				println "Found sublib include: ${includeDir}"
+				addonIncludeDirs.add(includeDir.absolutePath)
+			}
+		}
 	}
 }
-
 // Define supported Android ABIs
 def supportedAbis = ["arm64-v8a", "armeabi-v7a", "x86_64"]
+def currentAbis = []
+if (android.defaultConfig.ndk.abiFilters != null && !android.defaultConfig.ndk.abiFilters.isEmpty()) {
+	currentAbis = android.defaultConfig.ndk.abiFilters.toList()
+} else {
+	currentAbis = supportedAbis
+}
+println "abiFilters type: ${android.defaultConfig.ndk.abiFilters?.getClass()}"
+println "abiFilters value: ${android.defaultConfig.ndk.abiFilters}"
+println "currentAbis value: ${currentAbis}"
 
+def addonLibMap = [:].withDefault { [] }
+
+supportedAbis.each { abi -> addonLibMap[abi] = [] }
 addonPaths.each { addon ->
-	supportedAbis.each { abi ->
-		def libPath = new File(addon, "libs/android/${abi}")
-		if (libPath.exists()) {
-			def libFiles = libPath.listFiles()?.findAll { it.name.endsWith(".so") || it.name.endsWith(".a") }
-			if (libFiles) {
-				addonLibs.addAll(libFiles*.absolutePath)
+	def libsDir = new File(addon, "libs")
+	if (libsDir.exists() && libsDir.isDirectory()) {
+		libsDir.eachDir { subLib ->
+			def libRoot = new File(subLib, "lib/android")
+			supportedAbis.each { abi ->
+				def archDir = new File(libRoot, abi).canonicalFile
+				if (archDir.exists() && archDir.isDirectory()) {
+					def libFiles = archDir.listFiles()?.findAll {
+						it.name.endsWith(".so") || it.name.endsWith(".a")
+					}
+					if (libFiles) {
+						addonLibMap[abi].addAll(libFiles*.absolutePath)
+					}
+				}
 			}
 		}
 	}
 }
-println "Addon Libraries found: ${addonLibs}"
+
+addonPaths.each { addon ->
+	def libsDir = new File(addon, "libs")
+	if (libsDir.exists() && libsDir.isDirectory()) {
+		libsDir.eachDir { subLib ->
+			def libRoot = new File(subLib, "lib/android")
+			supportedAbis.each { abi ->
+				def archDir = new File(libRoot, abi).canonicalFile
+				println "Checking: ${archDir}"
+				if (archDir.exists() && archDir.isDirectory()) {
+					def libFiles = archDir.listFiles()?.findAll {
+						it.name.endsWith(".so") || it.name.endsWith(".a")
+					}
+					if (libFiles && !libFiles.isEmpty()) {
+						println "Found ${libFiles.size()} libraries in ${archDir}:"
+						libFiles.each { lib -> println "    - ${lib.absolutePath}" }
+						addonLibs.addAll(libFiles*.absolutePath)
+					} else {
+						println "No libs found in ${archDir}"
+					}
+				}
+			}
+		}
+	} else {
+		println "No 'libs/' folder in ${addon.name}"
+	}
+}
+println "Addon Libraries found: [${addonLibs}]"
 
 // Convert lists to CMake arguments
-def cmakeIncludeArgs = "-DADDON_INCLUDE_DIRS=" + addonIncludeDirs.join(";")
-def cmakeLibArgs = "-DADDON_LIBS=" + addonLibs.join(";")
+def cmakeIncludeArgs = "-DADDON_INCLUDE_DIRS=\"" + addonIncludeDirs.join(";") + "\""
+def cmakeLibArgs = "-DADDON_LIBS=\"" + addonLibs.join(";") + "\""
+def cmakeSrcArgs = "-DADDON_SOURCES=" + addonSourceFiles.join(";")
 
 println "Found addons: " + addonPaths
 println "Include directories: " + addonIncludeDirs
-println "Libraries: " + addonLibs
+
+
 
 android {
     compileSdkVersion 34
@@ -91,30 +188,27 @@ android {
         }
     }
     defaultConfig {
-        applicationId "cc.openframeworks.emptyExample"  // IMPORTANT : THIS DEFINES THE ID OF THE APK
+        applicationId "cc.openframeworks.androidAssimpExample"  // IMPORTANT : THIS DEFINES THE ID OF THE APK
         minSdkVersion 24
         targetSdkVersion 34
         versionCode 12
         versionName '12.0'
         ndk.abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'
 
+		def androidSTL = "-DANDROID_STL=c++_shared"
+		if (project.hasProperty("OF_STATIC") && project.OF_STATIC.toBoolean()) {
+			androidSTL "-DANDROID_STL=c++_static"
+		}
+
         externalNativeBuild {
 			cmake {
 				arguments "-DANDROID_TOOLCHAIN=clang",
-					"-DTARGET_OPENGLES=TRUE"
-
-				// Use c++_static if building OpenFrameworks as a STATIC library
-				if (project.hasProperty("OF_STATIC") && project.OF_STATIC.toBoolean()) {
-					arguments "-DANDROID_STL=c++_static"
-				} else {
-					arguments "-DANDROID_STL=c++_shared"
-				}
-
-				// Enable NEON only for ARM architectures
-				if (android.defaultConfig.ndk.abiFilters.contains("armeabi-v7a") || android.defaultConfig.ndk.abiFilters.contains("arm64-v8a")) {
-					arguments "-DANDROID_ARM_NEON=TRUE"
-				}
-
+					"-DTARGET_OPENGLES=TRUE",
+					"-DCMAKE_VERBOSE_MAKEFILE=ON",
+					cmakeIncludeArgs,
+					cmakeLibArgs,
+					cmakeSrcArgs,
+					androidSTL
 				abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86_64'
 				version '3.22.1'
 			}
@@ -173,7 +267,6 @@ android {
 		cmake {
 			path "${CMAKELIST_PATH}/CMakeLists.txt"
 		}
-
     }
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8

scripts/templates/android/ofApp/src/CMakeLists.txt

@@ -50,8 +50,9 @@ set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(TARGET_ANDROID ON)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ferror-limit=0 -std=c17 -Oz -Wall -fno-short-enums -fPIE -fPIC -fexceptions -ffunction-sections -fdata-sections")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ferror-limit=0 -std=c++23 -Oz -stdlib=libc++ -Wall -fno-short-enums -fPIE -fPIC -fexceptions -ffunction-sections -fdata-sections")
+add_definitions(-DANDROID)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ferror-limit=0 -std=c17 -O3 -Wall -fno-short-enums -fPIE -fPIC -ffunction-sections -fdata-sections")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ferror-limit=0 -std=c++23 -O3 -stdlib=libc++ -Wall -fno-short-enums -fPIE -fPIC -fexceptions -ffunction-sections -fdata-sections")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-export-dynamic")
 print_all_variables()
 set(OF_LIBRARY_TYPE "SHARED")  # or "STATIC"
@@ -110,16 +111,45 @@ include_directories(
 )
 
 # Load add-on include directories from Gradle
+
+if(DEFINED ADDON_SOURCES)
+    message(STATUS "Adding addon sources: ${ADDON_SOURCES}")
+    foreach(SRC ${ADDON_SOURCES})
+        message(STATUS " - ${SRC}")
+        list(APPEND ADDON_SRC_LIST ${SRC})
+    endforeach()
+    target_sources(${PROJECT_NAME} PRIVATE ${ADDON_SRC_LIST})
+endif()
+
+
+if(NOT DEFINED ADDON_INCLUDE_DIRS AND DEFINED ENV{ADDON_INCLUDE_DIRS})
+    set(ADDON_INCLUDE_DIRS $ENV{ADDON_INCLUDE_DIRS})
+    message(STATUS "ADDON_INCLUDE_DIRS not defined, falling back to ENV: ${ADDON_INCLUDE_DIRS}")
+endif()
+
 if(DEFINED ADDON_INCLUDE_DIRS)
+    message(STATUS "Adding addon include dirs: ${ADDON_INCLUDE_DIRS}")
     foreach(DIR ${ADDON_INCLUDE_DIRS})
+        message(STATUS "Adding addon include DIR: ${DIR}")
         include_directories(${DIR})
     endforeach()
 endif()
+
+if(NOT DEFINED ADDON_LIBS AND DEFINED ENV{ADDON_LIBS})
+    set(ADDON_LIBS $ENV{ADDON_LIBS})
+    message(STATUS "ADDON_LIBS not defined, falling back to ENV: ${ADDON_LIBS}")
+endif()
+
 if(DEFINED ADDON_LIBS)
-    message(STATUS "Adding addon libraries: ${ADDON_LIBS}")
+    message(STATUS "Original ADDON_LIBS: ${ADDON_LIBS}")
+    set(FILTERED_ADDON_LIBS "")
     foreach(LIB ${ADDON_LIBS})
-        target_link_libraries(${PROJECT_NAME} ${LIB})
+        if("${LIB}" MATCHES "${ANDROID_ABI}")
+            list(APPEND FILTERED_ADDON_LIBS ${LIB})
+        endif()
     endforeach()
+    message(STATUS "Filtered ADDON_LIBS for ABI '${ANDROID_ABI}': ${FILTERED_ADDON_LIBS}")
+    target_link_libraries(${PROJECT_NAME} ${FILTERED_ADDON_LIBS})
 endif()
 
 find_library(ANDROID_LIB NAMES android)