Files
breeze/droid/app/src/main/cpp/CMakeLists.txt
T
waozi 955fe51d17 Buy Dew through Google Play in the Google Play version
The Google Play edition (the gplay build type) now builds its native code
with GOOGLE_PLAY and adds Kryon's Play Billing (its gplay sources from the
Kryon package and billing 9.1); the direct and F-Droid builds carry no
Google billing. Top up lists Entity's Dew packs at Google Play's price in the
buyer's currency once Play answers. Breeze sends each purchase to the node
with its own signed-in request through entity/dew_play, and Play forgets it
only after the node has credited the Dew. The Play edition's Top up shows no
Monero address or other coins, and running out of Dew no longer names
Monero. The old payment bridge stubs are gone.

Kryon and Entity move to their Play Billing commits; liboqs stays pinned.
2026-10-27 18:06:54 -03:00

341 lines
16 KiB
CMake

cmake_minimum_required(VERSION 3.22)
project(App C)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM AND EXISTS "${CCACHE_PROGRAM}")
set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
else()
set(CMAKE_C_COMPILER_LAUNCHER "")
set(CMAKE_C_COMPILER_LAUNCHER "" CACHE STRING "" FORCE)
endif()
get_filename_component(REPO_ROOT "${CMAKE_CURRENT_LIST_DIR}/../../../../.." ABSOLUTE)
set(SRC_DIR "${REPO_ROOT}/src")
if(NOT EXISTS "${REPO_ROOT}/build/packages/.complete")
message(FATAL_ERROR "Run sh scripts/packages.sh to fetch the dependencies pinned in ziran.lock")
endif()
set(MONOCYPHER_DIR "${REPO_ROOT}/build/packages/monocypher/src")
if(NOT DEFINED KRYON_DIR)
set(KRYON_DIR "${REPO_ROOT}/build/packages/kryon")
endif()
get_filename_component(KRYON_DIR "${KRYON_DIR}" ABSOLUTE BASE_DIR "${REPO_ROOT}")
set(RAYLIB_DIR "${REPO_ROOT}/build/packages/raylib/src")
set(SQLITE_DIR "${REPO_ROOT}/build/packages/sqlite")
set(SQLITE_BUILD_DIR "${CMAKE_BINARY_DIR}/sqlite")
set(SQLITE_AMALGAMATION_C "${SQLITE_BUILD_DIR}/sqlite3.c")
set(SQLITE_AMALGAMATION_H "${SQLITE_BUILD_DIR}/sqlite3.h")
include("${KRYON_DIR}/cmake/KryonAndroid.cmake")
kryon_android_reproducible_paths("${REPO_ROOT}")
# Size-optimize static dependencies in release builds. Kryon compiles the
# host and raylib for speed, after this option, because they draw every frame.
add_compile_options("$<$<NOT:$<CONFIG:Debug>>:-Oz>")
set(OQS_BUILD_ONLY_LIB ON CACHE BOOL "" FORCE)
set(OQS_USE_OPENSSL OFF CACHE BOOL "" FORCE)
set(OQS_MINIMAL_BUILD "SIG_ml_dsa_44;KEM_ml_kem_768" CACHE STRING "" FORCE)
set(OQS_DIST_BUILD OFF CACHE BOOL "" FORCE)
set(OQS_OPT_TARGET generic CACHE STRING "" FORCE)
foreach(oqs_x86_feature
ADX AES AVX AVX2 AVX512 AVX512BW AVX512DQ AVX512F
BMI1 BMI2 FMA PCLMULQDQ POPCNT SSE SSE2 SSE3 VPCLMULQDQ)
set(OQS_USE_${oqs_x86_feature}_INSTRUCTIONS OFF CACHE BOOL "" FORCE)
endforeach()
add_subdirectory("${REPO_ROOT}/build/packages/liboqs" "${CMAKE_BINARY_DIR}/liboqs")
if(NOT TARGET oqs)
message(FATAL_ERROR "Android builds require liboqs for sync account crypto")
endif()
set(ZIRAN_DIR "${REPO_ROOT}/build/packages/ziran")
set(ZIRAN_BUILD_DIR "${REPO_ROOT}/build/ziran-toolchain")
set(ZI2C_BIN "${ZIRAN_BUILD_DIR}/bin/zi2c")
set(ZI2ZIR_BIN "${ZIRAN_BUILD_DIR}/bin/zi2zir")
file(GLOB ZIRAN_SOURCES CONFIGURE_DEPENDS
"${ZIRAN_DIR}/cmd/zir/*.c" "${ZIRAN_DIR}/cmd/zir/*.h"
"${ZIRAN_DIR}/cmd/zir-c/*.c" "${ZIRAN_DIR}/cmd/zir-c/*.h"
"${ZIRAN_DIR}/cmd/zir-ir/*.c" "${ZIRAN_DIR}/cmd/zir-ir/*.h")
find_program(HOST_MAKE NAMES make gmake REQUIRED)
find_program(HOST_PYTHON NAMES python3 REQUIRED)
find_program(HOST_CC NAMES cc gcc REQUIRED NO_CMAKE_FIND_ROOT_PATH)
set(ZIRAN_BIN "${ZIRAN_BUILD_DIR}/bin/ziran")
add_custom_target(app_build_laws
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-version.py"
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/font_glyph_coverage_test.py"
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_translated_test.py"
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_used_keys_test.py"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/sync_retry_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/practice_lifecycle_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/sync_recovery_policy_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/habit_merge_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/sync_restore_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/modal_rules_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/storage_layout_laws.zi"
COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" --module-path "${KRYON_DIR}/src/ui" --module-path "${ZIRAN_DIR}/std" "${SRC_DIR}/guide_laws.zi"
DEPENDS "${ZI2C_BIN}"
WORKING_DIRECTORY "${REPO_ROOT}"
COMMENT "Checking release consistency and proving app laws"
VERBATIM
)
add_custom_command(
OUTPUT "${ZI2C_BIN}"
BYPRODUCTS "${ZI2ZIR_BIN}"
COMMAND "${HOST_MAKE}" -j1 -C "${ZIRAN_DIR}"
"CC=${HOST_CC}" "HOST_CC=${HOST_CC}"
"BUILD_DIR=${ZIRAN_BUILD_DIR}" all
DEPENDS ${ZIRAN_SOURCES} "${ZIRAN_DIR}/Makefile"
VERBATIM
)
set(APP_ZIRAN_GEN_DIR "${CMAKE_BINARY_DIR}/ziran/generated")
set(APP_ZIRAN_MANIFEST "${CMAKE_BINARY_DIR}/ziran/generated-sources.cmake")
file(GLOB_RECURSE APP_ZIRAN_SOURCES CONFIGURE_DEPENDS "${SRC_DIR}/*.zi")
list(APPEND APP_ZIRAN_SOURCES "${REPO_ROOT}/apps/practice/hold_reminder.zi")
file(GLOB_RECURSE APP_LIBRARY_ZIRAN_SOURCES CONFIGURE_DEPENDS
"${KRYON_DIR}/src/ui/*.zi" "${KRYON_DIR}/src/backend/*.zi"
"${REPO_ROOT}/build/packages/kss/src/*.zi" "${REPO_ROOT}/build/packages/oqs/src/*.zi" "${REPO_ROOT}/build/packages/game2d/src/*.zi"
"${REPO_ROOT}/build/packages/qrcode/src/*.zi"
"${REPO_ROOT}/build/packages/entity/src/*.zi"
"${ZIRAN_DIR}/std/*.zi" "${REPO_ROOT}/build/packages/daochi-client/*.zi")
set(APP_ZIRAN_DEFINES --define ANDROID_BUILD --define KRYON_ANDROID_HOST)
set(APP_ZIRAN_CHECK_DEFINES "ANDROID_BUILD KRYON_ANDROID_HOST")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
list(APPEND APP_ZIRAN_DEFINES --define ANDROID_DEBUG)
string(APPEND APP_ZIRAN_CHECK_DEFINES " ANDROID_DEBUG")
endif()
# The Google Play edition (build.gradle's gplay type) buys Dew through Play
# Billing (entity/dew_play).
if(APP_EDITION STREQUAL "gplay")
list(APPEND APP_ZIRAN_DEFINES --define GOOGLE_PLAY)
string(APPEND APP_ZIRAN_CHECK_DEFINES " GOOGLE_PLAY")
endif()
if(ANDROID_ABI STREQUAL "arm64-v8a")
set(APP_ZIRAN_ARCH __aarch64__)
elseif(ANDROID_ABI STREQUAL "armeabi-v7a")
set(APP_ZIRAN_ARCH __arm__)
elseif(ANDROID_ABI STREQUAL "x86_64")
set(APP_ZIRAN_ARCH __x86_64__)
elseif(ANDROID_ABI STREQUAL "x86")
set(APP_ZIRAN_ARCH __i386__)
else()
message(FATAL_ERROR "Unsupported Android ABI: ${ANDROID_ABI}")
endif()
list(APPEND APP_ZIRAN_DEFINES --define ${APP_ZIRAN_ARCH})
string(APPEND APP_ZIRAN_CHECK_DEFINES " ${APP_ZIRAN_ARCH}")
# CMake needs the complete emitted import graph before it creates build rules.
# Run the same required law gates before this initial source generation.
execute_process(COMMAND "${HOST_MAKE}" -j1 -C "${ZIRAN_DIR}"
"CC=${HOST_CC}" "HOST_CC=${HOST_CC}"
"BUILD_DIR=${ZIRAN_BUILD_DIR}" all COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-version.py"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/font_glyph_coverage_test.py"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_translated_test.py"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_used_keys_test.py"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/app/sync_retry_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/app/practice_lifecycle_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/app/sync_recovery_policy_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/storage/habit_merge_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/storage/sync_restore_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/app/modal_rules_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
"${SRC_DIR}/storage/storage_layout_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
--module-path "${KRYON_DIR}/src/ui" --module-path "${ZIRAN_DIR}/std"
"${SRC_DIR}/guide_laws.zi"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
set(APP_GENERATE_ZIRAN_COMMAND "${HOST_PYTHON}"
"${REPO_ROOT}/scripts/generate-android-sources.py"
--compiler "${ZI2C_BIN}" --root "${REPO_ROOT}" --kryon "${KRYON_DIR}"
--output "${APP_ZIRAN_GEN_DIR}" --manifest "${APP_ZIRAN_MANIFEST}"
${APP_ZIRAN_DEFINES})
set(APP_ZIRAN_STAMP "${CMAKE_BINARY_DIR}/ziran/generated.stamp")
set(APP_ZIRAN_INPUTS_FILE "${CMAKE_BINARY_DIR}/ziran/generation-inputs.txt")
set(APP_ZIRAN_INPUTS "${APP_GENERATE_ZIRAN_COMMAND};${APP_ZIRAN_SOURCES};${APP_LIBRARY_ZIRAN_SOURCES}")
set(APP_ZIRAN_GENERATE TRUE)
if(EXISTS "${APP_ZIRAN_MANIFEST}" AND EXISTS "${APP_ZIRAN_STAMP}" AND
EXISTS "${APP_ZIRAN_INPUTS_FILE}")
file(READ "${APP_ZIRAN_INPUTS_FILE}" APP_ZIRAN_OLD_INPUTS)
if(APP_ZIRAN_OLD_INPUTS STREQUAL APP_ZIRAN_INPUTS)
set(APP_ZIRAN_GENERATE FALSE)
include("${APP_ZIRAN_MANIFEST}")
foreach(input ${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES}
"${ZI2C_BIN}" "${REPO_ROOT}/scripts/generate-android-sources.py")
if("${input}" IS_NEWER_THAN "${APP_ZIRAN_STAMP}")
set(APP_ZIRAN_GENERATE TRUE)
endif()
endforeach()
foreach(output ${APP_ZIRAN_GENERATED_SOURCES} ${APP_ZIRAN_GENERATED_HEADERS})
if(NOT EXISTS "${output}")
set(APP_ZIRAN_GENERATE TRUE)
endif()
endforeach()
endif()
endif()
if(APP_ZIRAN_GENERATE)
execute_process(COMMAND ${APP_GENERATE_ZIRAN_COMMAND}
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
file(WRITE "${APP_ZIRAN_INPUTS_FILE}" "${APP_ZIRAN_INPUTS}")
file(TOUCH "${APP_ZIRAN_STAMP}")
endif()
include("${APP_ZIRAN_MANIFEST}")
add_custom_command(
OUTPUT "${APP_ZIRAN_STAMP}"
BYPRODUCTS ${APP_ZIRAN_GENERATED_SOURCES} ${APP_ZIRAN_GENERATED_HEADERS}
COMMAND ${APP_GENERATE_ZIRAN_COMMAND}
COMMAND ${CMAKE_COMMAND} -E touch "${APP_ZIRAN_STAMP}"
DEPENDS ${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES} "${ZI2C_BIN}"
"${REPO_ROOT}/scripts/generate-android-sources.py"
"${REPO_ROOT}/scripts/run-ziran.sh"
WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_custom_target(app_ziran_generated DEPENDS "${APP_ZIRAN_STAMP}")
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES}
"${REPO_ROOT}/scripts/generate-android-sources.py")
set_source_files_properties(${APP_ZIRAN_GENERATED_SOURCES}
${APP_ZIRAN_GENERATED_HEADERS} PROPERTIES GENERATED TRUE)
add_custom_target(app_clean_runtime_api
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-clean-text-api.py" "${SRC_DIR}"
WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_custom_target(app_zi_check
COMMAND ${CMAKE_COMMAND} -E env "ZI_CHECK_DEFINES=${APP_ZIRAN_CHECK_DEFINES}"
"${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-zi-sources.py" "${ZI2ZIR_BIN}"
DEPENDS "${ZI2C_BIN}" WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_dependencies(app_zi_check app_build_laws)
add_dependencies(app_ziran_generated app_build_laws app_clean_runtime_api app_zi_check)
foreach(mode light dark)
file(SHA256 "${REPO_ROOT}/themes/catalog_${mode}.kss" APP_CATALOG_HASH)
file(SHA256 "${KRYON_DIR}/themes/catalog_${mode}.kss" KRYON_CATALOG_HASH)
if(NOT APP_CATALOG_HASH STREQUAL KRYON_CATALOG_HASH)
message(FATAL_ERROR "Packaged ${mode} theme catalog differs from Kryon")
endif()
endforeach()
# Gradle builds and stages the portable package independently of ABI-specific
# native compilation. Artwork changes must not reconfigure every native host.
set(APP_BUNDLE_RUNTIME_DIR "${CMAKE_BINARY_DIR}/bundle-runtime")
set(APP_BUNDLE_RUNTIME "${APP_BUNDLE_RUNTIME_DIR}/libziran.a")
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/build-bundle-runtime.py"
--source "${ZIRAN_DIR}" --output "${APP_BUNDLE_RUNTIME_DIR}"
--cc "${CMAKE_C_COMPILER} --target=${CMAKE_C_COMPILER_TARGET} --sysroot=${CMAKE_SYSROOT}"
--ar "${CMAKE_AR}" --objcopy "${CMAKE_OBJCOPY}"
"--flags=-O2 -fPIC -ffunction-sections -fdata-sections"
WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
"${REPO_ROOT}/scripts/build-bundle-runtime.py" "${REPO_ROOT}/ziran.lock")
set(APP_EMBEDDED_INPUTS
apps/publishers.json
assets/app/icon.png
)
set(APP_EMBEDDED_DEPS)
foreach(asset ${APP_EMBEDDED_INPUTS})
list(APPEND APP_EMBEDDED_DEPS "${REPO_ROOT}/${asset}")
endforeach()
set(APP_EMBEDDED_ASSETS_C "${CMAKE_BINARY_DIR}/app_embedded_assets.c")
add_custom_command(
OUTPUT "${APP_EMBEDDED_ASSETS_C}"
COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/embed-app-assets.py"
"${APP_EMBEDDED_ASSETS_C}" ${APP_EMBEDDED_INPUTS}
DEPENDS "${REPO_ROOT}/scripts/embed-app-assets.py" ${APP_EMBEDDED_DEPS}
WORKING_DIRECTORY "${REPO_ROOT}"
VERBATIM
)
add_custom_command(
OUTPUT "${SQLITE_AMALGAMATION_C}" "${SQLITE_AMALGAMATION_H}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${SQLITE_BUILD_DIR}"
COMMAND sh -c "cd '${SQLITE_BUILD_DIR}' && '${SQLITE_DIR}/configure'"
COMMAND make -C "${SQLITE_BUILD_DIR}" sqlite3.c sqlite3.h
DEPENDS "${SQLITE_DIR}/configure" "${SQLITE_DIR}/manifest"
VERBATIM
)
kryon_android_raylib("${RAYLIB_DIR}")
add_library(main SHARED
"${MONOCYPHER_DIR}/monocypher.c"
"${MONOCYPHER_DIR}/optional/monocypher-ed25519.c"
"${SQLITE_AMALGAMATION_C}"
"${APP_EMBEDDED_ASSETS_C}"
${APP_ZIRAN_GENERATED_SOURCES}
)
kryon_android_app(main)
# Optimize across generated modules while retaining the Android export map.
# Use the NDK's ThinLTO directly: older CMake IPO selects the retired gold
# linker, whereas Android's Clang already uses lld. Keep debug builds separate.
target_compile_options(main PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-flto=thin>")
target_link_options(main PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-flto=thin>")
# Prefix maps do not normalize the source filename in LLVM bitcode. Keep
# compiler inputs relative so ThinLTO's symbol hashes and build IDs match
# across the release runner and F-Droid, while retaining native crash symbols.
set(APP_COMPILER_LAUNCHER "${HOST_PYTHON}" "${REPO_ROOT}/scripts/relative-compile.py")
list(APPEND APP_COMPILER_LAUNCHER ${CMAKE_C_COMPILER_LAUNCHER})
set_property(TARGET main PROPERTY C_COMPILER_LAUNCHER "${APP_COMPILER_LAUNCHER}")
add_dependencies(main app_ziran_generated app_clean_runtime_api app_build_laws app_zi_check)
target_include_directories(main PRIVATE
"${ZIRAN_DIR}/include"
"${MONOCYPHER_DIR}"
"${MONOCYPHER_DIR}/optional"
"${SRC_DIR}/app"
"${SQLITE_BUILD_DIR}"
)
# Generated module names such as math.h must not shadow libc's <math.h>
# in SQLite and other native dependencies. Zi imports use quoted includes.
foreach(directory ${APP_ZIRAN_INCLUDE_DIRS})
target_compile_options(main PRIVATE "-iquote${directory}")
endforeach()
target_compile_definitions(main PRIVATE
UTF8PROC_STATIC
MG_TLS=MG_TLS_BUILTIN
MG_ENABLE_EPOLL=0
MG_ENABLE_POLL=1
MG_ENABLE_POSIX_FS=0
SUPPORT_MODULE_RAUDIO=1
SUPPORT_FILEFORMAT_OGG=1
UI_EMBEDDED_ONLY=1
HAS_LIBOQS=1
KRYON_WITH_SYNC=1
KRYON_WITH_PHYSICS=0
)
# The VM locates this exported entry before native methods are registered.
foreach(source ${APP_ZIRAN_GENERATED_SOURCES})
get_filename_component(source_name "${source}" NAME)
if(source_name STREQUAL "android_insets.c")
set_source_files_properties("${source}"
PROPERTIES COMPILE_OPTIONS "-fvisibility=default")
elseif(source_name STREQUAL "main.c")
# Raylib invokes this shared-library entry itself; its Zi argv is
# byte pointers, so hosted C's spelling rule for main does not apply.
set_source_files_properties("${source}"
PROPERTIES COMPILE_OPTIONS "-ffreestanding")
endif()
endforeach()
target_link_libraries(main oqs z "${APP_BUNDLE_RUNTIME}")
# Keep the Android entry points public and let the linker discard unreachable
# functions from the statically linked runtime and graphics dependencies.
set(APP_EXPORT_MAP "${CMAKE_CURRENT_SOURCE_DIR}/libmain.map.txt")
target_link_options(main PRIVATE
"$<$<NOT:$<CONFIG:Debug>>:-Wl,-O2,--icf=safe>"
"-Wl,--version-script,${APP_EXPORT_MAP}"
"-Wl,--no-undefined-version")
set_property(TARGET main APPEND PROPERTY LINK_DEPENDS "${APP_EXPORT_MAP}")