diff options
| -rw-r--r-- | include/nativebridge/native_bridge.h | 118 | ||||
| -rw-r--r-- | libnativebridge/Android.mk | 34 | ||||
| -rw-r--r-- | libnativebridge/native_bridge.cc | 106 |
3 files changed, 258 insertions, 0 deletions
diff --git a/include/nativebridge/native_bridge.h b/include/nativebridge/native_bridge.h new file mode 100644 index 000000000..2415e6bc5 --- /dev/null +++ b/include/nativebridge/native_bridge.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef NATIVE_BRIDGE_H_ +#define NATIVE_BRIDGE_H_ + +#include "jni.h" +#include <stdint.h> + +namespace android { + +struct NativeBridgeRuntimeCallbacks; + +// Initialize the native bridge, if any. Should be called by Runtime::Init(). +// A null library filename signals that we do not want to load a native bridge. +void SetupNativeBridge(const char* native_bridge_library_filename, + const NativeBridgeRuntimeCallbacks* runtime_callbacks); + +// Load a shared library that is supported by the native bridge. +void* NativeBridgeLoadLibrary(const char* libpath, int flag); + +// Get a native bridge trampoline for specified native method. +void* NativeBridgeGetTrampoline(void* handle, const char* name, const char* shorty, uint32_t len); + +// True if native library is valid and is for an ABI that is supported by native bridge. +bool NativeBridgeIsSupported(const char* libpath); + +// Native bridge interfaces to runtime. +struct NativeBridgeCallbacks { + // Initialize native bridge. Native bridge's internal implementation must ensure MT safety and + // that the native bridge is initialized only once. Thus it is OK to call this interface for an + // already initialized native bridge. + // + // Parameters: + // runtime_cbs [IN] the pointer to NativeBridgeRuntimeCallbacks. + // Returns: + // true iff initialization was successful. + bool (*initialize)(const NativeBridgeRuntimeCallbacks* runtime_cbs); + + // Load a shared library that is supported by the native bridge. + // + // Parameters: + // libpath [IN] path to the shared library + // flag [IN] the stardard RTLD_XXX defined in bionic dlfcn.h + // Returns: + // The opaque handle of the shared library if sucessful, otherwise NULL + void* (*loadLibrary)(const char* libpath, int flag); + + // Get a native bridge trampoline for specified native method. The trampoline has same + // sigature as the native method. + // + // Parameters: + // handle [IN] the handle returned from loadLibrary + // shorty [IN] short descriptor of native method + // len [IN] length of shorty + // Returns: + // address of trampoline if successful, otherwise NULL + void* (*getTrampoline)(void* handle, const char* name, const char* shorty, uint32_t len); + + // Check whether native library is valid and is for an ABI that is supported by native bridge. + // + // Parameters: + // libpath [IN] path to the shared library + // Returns: + // TRUE if library is supported by native bridge, FALSE otherwise + bool (*isSupported)(const char* libpath); +}; + +// Runtime interfaces to native bridge. +struct NativeBridgeRuntimeCallbacks { + // Get shorty of a Java method. The shorty is supposed to be persistent in memory. + // + // Parameters: + // env [IN] pointer to JNIenv. + // mid [IN] Java methodID. + // Returns: + // short descriptor for method. + const char* (*getMethodShorty)(JNIEnv* env, jmethodID mid); + + // Get number of native methods for specified class. + // + // Parameters: + // env [IN] pointer to JNIenv. + // clazz [IN] Java class object. + // Returns: + // number of native methods. + uint32_t (*getNativeMethodCount)(JNIEnv* env, jclass clazz); + + // Get at most 'method_count' native methods for specified class 'clazz'. Results are outputed + // via 'methods' [OUT]. The signature pointer in JNINativeMethod is reused as the method shorty. + // + // Parameters: + // env [IN] pointer to JNIenv. + // clazz [IN] Java class object. + // methods [OUT] array of method with the name, shorty, and fnPtr. + // method_count [IN] max number of elements in methods. + // Returns: + // number of method it actually wrote to methods. + uint32_t (*getNativeMethods)(JNIEnv* env, jclass clazz, JNINativeMethod* methods, + uint32_t method_count); +}; + +}; // namespace android + +#endif // NATIVE_BRIDGE_H_ diff --git a/libnativebridge/Android.mk b/libnativebridge/Android.mk new file mode 100644 index 000000000..8209bc794 --- /dev/null +++ b/libnativebridge/Android.mk @@ -0,0 +1,34 @@ +LOCAL_PATH:= $(call my-dir) + +NATIVE_BRIDGE_COMMON_SRC_FILES := \ + native_bridge.cc + +# Shared library for target +# ======================================================== +include $(CLEAR_VARS) + +LOCAL_MODULE:= libnativebridge + +LOCAL_SRC_FILES:= $(NATIVE_BRIDGE_COMMON_SRC_FILES) +LOCAL_CPP_EXTENSION := .cc +LOCAL_CFLAGS := -Werror +LOCAL_CPPFLAGS := -std=gnu++11 +LOCAL_LDFLAGS := -ldl +LOCAL_MULTILIB := both + +include $(BUILD_SHARED_LIBRARY) + +# Shared library for host +# ======================================================== +include $(CLEAR_VARS) + +LOCAL_MODULE:= libnativebridge + +LOCAL_SRC_FILES:= $(NATIVE_BRIDGE_COMMON_SRC_FILES) +LOCAL_CPP_EXTENSION := .cc +LOCAL_CFLAGS := -Werror +LOCAL_CPPFLAGS := -std=gnu++11 +LOCAL_LDFLAGS := -ldl +LOCAL_MULTILIB := both + +include $(BUILD_HOST_SHARED_LIBRARY) diff --git a/libnativebridge/native_bridge.cc b/libnativebridge/native_bridge.cc new file mode 100644 index 000000000..ad4ee73d6 --- /dev/null +++ b/libnativebridge/native_bridge.cc @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "nativebridge/native_bridge.h" + +#include <dlfcn.h> +#include <stdio.h> +#include "utils/Mutex.h" + + +namespace android { + +static Mutex native_bridge_lock("native bridge lock"); + +// The symbol name exposed by native-bridge with the type of NativeBridgeCallbacks. +static constexpr const char* kNativeBridgeInterfaceSymbol = "NativeBridgeItf"; + +// The path of the library we are supposed to load. +static const char* native_bridge_library_path = nullptr; + +// Whether a native bridge is available (loaded and ready). +static bool available = false; +// Whether we have already initialized (or tried to). +static bool initialized = false; + +static NativeBridgeCallbacks* callbacks = nullptr; +static const NativeBridgeRuntimeCallbacks* runtime_callbacks = nullptr; + +void SetupNativeBridge(const char* nb_library_path, + const NativeBridgeRuntimeCallbacks* runtime_cbs) { + Mutex::Autolock auto_lock(native_bridge_lock); + + native_bridge_library_path = nb_library_path; + runtime_callbacks = runtime_cbs; + + if (native_bridge_library_path == nullptr) { + initialized = true; + available = false; + } +} + +static bool NativeBridgeInitialize() { + Mutex::Autolock auto_lock(native_bridge_lock); + + if (initialized) { + // Somebody did it before. + return available; + } + + available = false; + + void* handle = dlopen(native_bridge_library_path, RTLD_LAZY); + if (handle != nullptr) { + callbacks = reinterpret_cast<NativeBridgeCallbacks*>(dlsym(handle, + kNativeBridgeInterfaceSymbol)); + + if (callbacks != nullptr) { + available = callbacks->initialize(runtime_callbacks); + } + + if (!available) { + dlclose(handle); + } + } + + initialized = true; + + return available; +} + +void* NativeBridgeLoadLibrary(const char* libpath, int flag) { + if (NativeBridgeInitialize()) { + return callbacks->loadLibrary(libpath, flag); + } + return nullptr; +} + +void* NativeBridgeGetTrampoline(void* handle, const char* name, const char* shorty, + uint32_t len) { + if (NativeBridgeInitialize()) { + return callbacks->getTrampoline(handle, name, shorty, len); + } + return nullptr; +} + +bool NativeBridgeIsSupported(const char* libpath) { + if (NativeBridgeInitialize()) { + return callbacks->isSupported(libpath); + } + return false; +} + +}; // namespace android |