// Copyright (c) 2020-2026 The Khronos Group Inc. // Copyright (c) 2020-2021, Collabora, Ltd. // // SPDX-License-Identifier: Apache-2.0 OR MIT // // Initial Author: Rylie Pavlik #include "android_utilities.h" #ifdef __ANDROID__ #include #include #include #include #include #include #include #include #define LOG_TAG "OpenXR-Loader" #include "android_logging.h" namespace openxr_android { using wrap::android::database::Cursor; using wrap::android::net::Uri; using wrap::android::net::Uri_Builder; // Code in here corresponds roughly to the Java "BrokerContract" class and subclasses. namespace { constexpr auto AUTHORITY = "org.khronos.openxr.runtime_broker"; constexpr auto SYSTEM_AUTHORITY = "org.khronos.openxr.system_runtime_broker"; constexpr auto BASE_PATH = "openxr"; constexpr auto ABI_PATH = "abi"; constexpr auto RUNTIMES_PATH = "runtimes"; constexpr const char *getBrokerAuthority(bool systemBroker) { return systemBroker ? SYSTEM_AUTHORITY : AUTHORITY; } struct BaseColumns { /** * The unique ID for a row. */ [[maybe_unused]] static constexpr auto ID = "_id"; }; /** * Contains details for the /openxr/[major_ver]/abi/[abi]/runtimes/active URI. *

* This URI represents a "table" containing at most one item, the currently active runtime. The * policy of which runtime is chosen to be active (if more than one is installed) is left to the * content provider. *

* No sort order is required to be honored by the content provider. */ namespace active_runtime { /** * Final path component to this URI. */ static constexpr auto TABLE_PATH = "active"; /** * Create a content URI for querying the data on the active runtime for a * given major version of OpenXR. * * @param systemBroker If the system runtime broker (instead of the installable one) should be queried. * @param majorVer The major version of OpenXR. * @param abi The Android ABI name in use. * @return A content URI for a single item: the active runtime. */ static Uri makeContentUri(bool systemBroker, int majorVersion, const char *abi) { auto builder = Uri_Builder::construct(); builder.scheme("content") .authority(getBrokerAuthority(systemBroker)) .appendPath(BASE_PATH) .appendPath(std::to_string(majorVersion)) .appendPath(ABI_PATH) .appendPath(abi) .appendPath(RUNTIMES_PATH) .appendPath(TABLE_PATH); return builder.build(); } struct Columns : BaseColumns { /** * Constant for the PACKAGE_NAME column name */ static constexpr auto PACKAGE_NAME = "package_name"; /** * Constant for the NATIVE_LIB_DIR column name */ static constexpr auto NATIVE_LIB_DIR = "native_lib_dir"; /** * Constant for the SO_FILENAME column name */ static constexpr auto SO_FILENAME = "so_filename"; /** * Constant for the HAS_FUNCTIONS column name. *

* If this column contains true, you should check the /functions/ URI for that runtime. */ static constexpr auto HAS_FUNCTIONS = "has_functions"; }; } // namespace active_runtime /** * Contains details for the /openxr/[major_ver]/abi/[abi]/runtimes/[package]/functions URI. *

* This URI is for package-specific function name remapping. Since this is an optional field in * the corresponding JSON manifests for OpenXR, it is optional here as well. If the active * runtime contains "true" in its "has_functions" column, then this table must exist and be * queryable. *

* No sort order is required to be honored by the content provider. */ namespace functions { /** * Final path component to this URI. */ static constexpr auto TABLE_PATH = "functions"; /** * Create a content URI for querying all rows of the runtime function remapping data for a given * runtime package and major version of OpenXR. * * @param systemBroker If the system runtime broker (instead of the installable one) should be queried. * @param majorVer The major version of OpenXR. * @param packageName The package name of the runtime. * @param abi The Android ABI name in use. * @return A content URI for the entire table: the function remapping for that runtime. */ static Uri makeRuntimeContentUri(bool systemBroker, int majorVersion, std::string const &packageName, const char *abi) { auto builder = Uri_Builder::construct(); builder.scheme("content") .authority(getBrokerAuthority(systemBroker)) .appendPath(BASE_PATH) .appendPath(std::to_string(majorVersion)) .appendPath(ABI_PATH) .appendPath(abi) .appendPath(RUNTIMES_PATH) .appendPath(packageName) .appendPath(TABLE_PATH); return builder.build(); } struct Columns : BaseColumns { /** * Constant for the FUNCTION_NAME column name */ static constexpr auto FUNCTION_NAME = "function_name"; /** * Constant for the SYMBOL_NAME column name */ static constexpr auto SYMBOL_NAME = "symbol_name"; }; } // namespace functions } // namespace static inline jni::Array makeArray(std::initializer_list &&list) { auto ret = jni::Array{(long)list.size()}; long i = 0; for (auto &&elt : list) { ret.setElement(i, elt); ++i; } return ret; } #if defined(__arm__) static constexpr auto ABI = "armeabi-v7l"; #elif defined(__aarch64__) static constexpr auto ABI = "arm64-v8a"; #elif defined(__i386__) static constexpr auto ABI = "x86"; #elif defined(__x86_64__) static constexpr auto ABI = "x86_64"; #else #error "Unknown ABI!" #endif static inline Json::Value makeMinimumVirtualRuntimeManifest(const std::string &libraryPath) { Json::Value root_node(Json::objectValue); root_node["file_format_version"] = "1.0.0"; root_node["instance_extensions"] = Json::Value(Json::arrayValue); root_node["functions"] = Json::Value(Json::objectValue); root_node["runtime"] = Json::objectValue; root_node["runtime"]["library_path"] = libraryPath; return root_node; } static constexpr const char *getBrokerTypeName(bool systemBroker) { return systemBroker ? "system" : "installable"; } // The current file relies on android-jni-wrappers and jnipp, which may throw on failure. // This is problematic when the loader is compiled with exception handling disabled - the consumers can reasonably // expect that the compilation with -fno-exceptions will succeed, but the compiler will not accept the code that // uses `try` & `catch` keywords. We cannot use the `exception_handling.hpp` here since we're not at an ABI boundary, // so we define helper macros here. This is fine for now since the only occurrence of exception-handling code is in this file. #ifdef XRLOADER_DISABLE_EXCEPTION_HANDLING #define ANDROID_UTILITIES_TRY #define ANDROID_UTILITIES_CATCH_FALLBACK(...) #else #define ANDROID_UTILITIES_TRY try #define ANDROID_UTILITIES_CATCH_FALLBACK(...) \ catch (const std::exception &e) { \ __VA_ARGS__ \ } #endif // XRLOADER_DISABLE_EXCEPTION_HANDLING /// Generic content resolver query function static bool getCursor(wrap::android::content::Context const &context, jni::Array const &projection, Uri const &uri, bool systemBroker, const char *contentDesc, Cursor &out_cursor) { ALOGI("getCursor: Querying URI: %s", uri.toString().c_str()); ANDROID_UTILITIES_TRY { out_cursor = context.getContentResolver().query(uri, projection); } ANDROID_UTILITIES_CATCH_FALLBACK({ ALOGI("Exception when querying %s content resolver for %s: %s", getBrokerTypeName(systemBroker), contentDesc, e.what()); out_cursor = {}; return false; }) if (out_cursor.isNull()) { ALOGI("Null cursor when querying %s content resolver for %s.", getBrokerTypeName(systemBroker), contentDesc); out_cursor = {}; return false; } if (out_cursor.getCount() < 1) { ALOGI("Non-null but empty cursor when querying %s content resolver for %s.", getBrokerTypeName(systemBroker), contentDesc); out_cursor.close(); out_cursor = {}; return false; } return true; } static int populateRuntimeFunctions(wrap::android::content::Context const &context, bool systemBroker, const std::string &packageName, Json::Value &manifest) { const jni::Array projection = makeArray({functions::Columns::FUNCTION_NAME, functions::Columns::SYMBOL_NAME}); auto uri = functions::makeRuntimeContentUri(systemBroker, XR_VERSION_MAJOR(XR_CURRENT_API_VERSION), packageName, ABI); ALOGI("populateFunctions: Querying URI: %s", uri.toString().c_str()); Cursor cursor; if (!getCursor(context, projection, uri, systemBroker, "functions", cursor)) { return -1; } auto functionIndex = cursor.getColumnIndex(functions::Columns::FUNCTION_NAME); auto symbolIndex = cursor.getColumnIndex(functions::Columns::SYMBOL_NAME); while (cursor.moveToNext()) { manifest["functions"][cursor.getString(functionIndex)] = cursor.getString(symbolIndex); } cursor.close(); return 0; } /// Get cursor for active runtime, parameterized by whether or not we use the system broker static bool getActiveRuntimeCursor(wrap::android::content::Context const &context, jni::Array const &projection, bool systemBroker, Cursor &cursor) { auto uri = active_runtime::makeContentUri(systemBroker, XR_VERSION_MAJOR(XR_CURRENT_API_VERSION), ABI); ALOGI("getActiveRuntimeCursor: Querying URI: %s", uri.toString().c_str()); return getCursor(context, projection, uri, systemBroker, "active runtime", cursor); } int getActiveRuntimeVirtualManifest(wrap::android::content::Context const &context, Json::Value &virtualManifest) { jni::Array projection = makeArray({active_runtime::Columns::PACKAGE_NAME, active_runtime::Columns::NATIVE_LIB_DIR, active_runtime::Columns::SO_FILENAME, active_runtime::Columns::HAS_FUNCTIONS}); // First, try getting the installable broker's provider bool systemBroker = false; Cursor cursor; if (!getActiveRuntimeCursor(context, projection, systemBroker, cursor)) { // OK, try the system broker as a fallback. systemBroker = true; getActiveRuntimeCursor(context, projection, systemBroker, cursor); } if (cursor.isNull()) { // Couldn't find either broker ALOGI("Could access neither the installable nor system runtime broker."); return -1; } cursor.moveToFirst(); do { auto filename = cursor.getString(cursor.getColumnIndex(active_runtime::Columns::SO_FILENAME)); auto libDir = cursor.getString(cursor.getColumnIndex(active_runtime::Columns::NATIVE_LIB_DIR)); auto packageName = cursor.getString(cursor.getColumnIndex(active_runtime::Columns::PACKAGE_NAME)); auto hasFunctions = cursor.getInt(cursor.getColumnIndex(active_runtime::Columns::HAS_FUNCTIONS)) == 1; ALOGI("Got runtime: package: %s, so filename: %s, native lib dir: %s, has functions: %s", packageName.c_str(), filename.c_str(), libDir.c_str(), (hasFunctions ? "yes" : "no")); auto lib_path = libDir + "/" + filename; auto *lib = dlopen(lib_path.c_str(), RTLD_LAZY | RTLD_LOCAL); if (lib) { // we found a runtime that we can dlopen, use it. dlclose(lib); Json::Value manifest = makeMinimumVirtualRuntimeManifest(lib_path); if (hasFunctions) { int result = populateRuntimeFunctions(context, systemBroker, packageName, manifest); if (result != 0) { ALOGW("Unable to populate functions from runtime: %s, checking for more records...", lib_path.c_str()); continue; } } virtualManifest = manifest; cursor.close(); return 0; } // this runtime was not accessible, see if the broker has more runtimes on // offer. ALOGV("Unable to open broker provided runtime at %s, checking for more records...", lib_path.c_str()); } while (cursor.moveToNext()); ALOGW("Unable to open any of the broker provided runtimes."); cursor.close(); return -1; } } // namespace openxr_android #endif // __ANDROID__