Skip to content

Simplify Java TurboModule lookup #45322

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
javache wants to merge 1 commit into from
Closed

Simplify Java TurboModule lookup #45322

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
328 changes: 164 additions & 164 deletions ...act-native/ReactAndroid/src/main/jni/react/turbomodule/ReactCommon/TurboModuleManager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,8 @@
* LICENSE file in the root directory of this source tree.
*/

#include "TurboModuleManager.h"

#include <memory>
#include <stdexcept>
#include <string>
Expand All @@ -18,8 +20,7 @@
#include <ReactCommon/TurboCxxModule.h>
#include <ReactCommon/TurboModuleBinding.h>
#include <ReactCommon/TurboModulePerfLogger.h>

#include "TurboModuleManager.h"
#include <react/jni/CxxModuleWrapper.h>

namespace facebook::react {

Expand Down Expand Up @@ -101,9 +102,7 @@ TurboModuleManager::TurboModuleManager(
: runtimeExecutor_(std::move(runtimeExecutor)),
jsCallInvoker_(std::move(jsCallInvoker)),
nativeMethodCallInvoker_(std::move(nativeMethodCallInvoker)),
delegate_(jni::make_global(delegate)),
turboModuleCache_(std::make_shared<ModuleCache>()),
legacyModuleCache_(std::make_shared<ModuleCache>()) {}
delegate_(jni::make_global(delegate)) {}

jni::local_ref<TurboModuleManager::jhybriddata> TurboModuleManager::initHybrid(
jni::alias_ref<jhybridobject> /* unused */,
Expand Down Expand Up @@ -131,197 +130,198 @@ TurboModuleProviderFunctionType TurboModuleManager::createTurboModuleProvider(
jni::alias_ref<jhybridobject> javaPart,
jsi::Runtime* runtime,
bool enableSyncVoidMethods) {
return [turboModuleCache_ = std::weak_ptr<ModuleCache>(turboModuleCache_),
runtime,
jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
nativeMethodCallInvoker_ =
std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
weakDelegate = jni::make_weak(delegate_),
weakJavaPart = jni::make_weak(javaPart),
enableSyncVoidMethods](
const std::string& name) -> std::shared_ptr<TurboModule> {
const char* moduleName = name.c_str();
TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);

auto turboModuleCache = turboModuleCache_.lock();
if (!turboModuleCache) {
return nullptr;
}
return
[runtime, weakJavaPart = jni::make_weak(javaPart), enableSyncVoidMethods](
const std::string& name) -> std::shared_ptr<TurboModule> {
auto javaPart = weakJavaPart.lockLocal();
if (!javaPart) {
return nullptr;
}

auto turboModuleLookup = turboModuleCache->find(moduleName);
if (turboModuleLookup != turboModuleCache->end()) {
TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
return turboModuleLookup->second;
}
auto cxxPart = javaPart->cthis();
if (cxxPart == nullptr) {
return nullptr;
}

auto jsCallInvoker = jsCallInvoker_.lock();
auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
auto delegate = weakDelegate.lockLocal();
auto javaPart = weakJavaPart.lockLocal();
return cxxPart->getTurboModule(
javaPart, name, *runtime, enableSyncVoidMethods);
};
}

if (!jsCallInvoker || !nativeMethodCallInvoker || !delegate || !javaPart) {
return nullptr;
}
std::shared_ptr<TurboModule> TurboModuleManager::getTurboModule(
jni::alias_ref<jhybridobject> javaPart,
const std::string& name,
jsi::Runtime& runtime,
bool enableSyncVoidMethods) {
const char* moduleName = name.c_str();
TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);

auto turboModuleLookup = turboModuleCache_.find(name);
if (turboModuleLookup != turboModuleCache_.end()) {
TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
return turboModuleLookup->second;
}

auto cxxModule = delegate->cthis()->getTurboModule(name, jsCallInvoker);
if (cxxModule) {
turboModuleCache->insert({name, cxxModule});
return cxxModule;
}
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);

auto& cxxTurboModuleMapProvider = globalExportedCxxTurboModuleMap();
auto it = cxxTurboModuleMapProvider.find(name);
if (it != cxxTurboModuleMapProvider.end()) {
auto turboModule = it->second(jsCallInvoker);
turboModuleCache->insert({name, turboModule});
return turboModule;
}
auto cxxDelegate = delegate_->cthis();

static auto getTurboJavaModule =
javaPart->getClass()
->getMethod<jni::alias_ref<JTurboModule>(const std::string&)>(
"getTurboJavaModule");
auto moduleInstance = getTurboJavaModule(javaPart.get(), name);
if (moduleInstance) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
JavaTurboModule::InitParams params = {
.moduleName = name,
.instance = moduleInstance,
.jsInvoker = jsCallInvoker,
.nativeMethodCallInvoker = nativeMethodCallInvoker,
.shouldVoidMethodsExecuteSync = enableSyncVoidMethods};

auto turboModule = delegate->cthis()->getTurboModule(name, params);
if (moduleInstance->isInstanceOf(
JTurboModuleWithJSIBindings::javaClassStatic())) {
static auto getBindingsInstaller =
JTurboModuleWithJSIBindings::javaClassStatic()
->getMethod<BindingsInstallerHolder::javaobject()>(
"getBindingsInstaller");
auto installer = getBindingsInstaller(moduleInstance);
if (installer) {
installer->cthis()->installBindings(*runtime);
}
}
auto cxxModule = cxxDelegate->getTurboModule(name, jsCallInvoker_);
if (cxxModule) {
turboModuleCache_.insert({name, cxxModule});
return cxxModule;
}

turboModuleCache->insert({name, turboModule});
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}
auto& cxxTurboModuleMapProvider = globalExportedCxxTurboModuleMap();
auto it = cxxTurboModuleMapProvider.find(name);
if (it != cxxTurboModuleMapProvider.end()) {
auto turboModule = it->second(jsCallInvoker_);
turboModuleCache_.insert({name, turboModule});
return turboModule;
}

static auto getTurboLegacyCxxModule =
javaPart->getClass()
->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
const std::string&)>("getTurboLegacyCxxModule");
auto legacyCxxModule = getTurboLegacyCxxModule(javaPart.get(), name);
if (legacyCxxModule) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);

auto turboModule = std::make_shared<react::TurboCxxModule>(
legacyCxxModule->cthis()->getModule(), jsCallInvoker);
turboModuleCache->insert({name, turboModule});

TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
static auto getTurboJavaModule =
javaPart->getClass()
->getMethod<jni::alias_ref<JTurboModule>(const std::string&)>(
"getTurboJavaModule");
auto moduleInstance = getTurboJavaModule(javaPart.get(), name);
if (moduleInstance) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
JavaTurboModule::InitParams params = {
.moduleName = name,
.instance = moduleInstance,
.jsInvoker = jsCallInvoker_,
.nativeMethodCallInvoker = nativeMethodCallInvoker_,
.shouldVoidMethodsExecuteSync = enableSyncVoidMethods};

auto turboModule = cxxDelegate->getTurboModule(name, params);
if (moduleInstance->isInstanceOf(
JTurboModuleWithJSIBindings::javaClassStatic())) {
static auto getBindingsInstaller =
JTurboModuleWithJSIBindings::javaClassStatic()
->getMethod<BindingsInstallerHolder::javaobject()>(
"getBindingsInstaller");
auto installer = getBindingsInstaller(moduleInstance);
if (installer) {
installer->cthis()->installBindings(runtime);
}
}

return nullptr;
};
turboModuleCache_.insert({name, turboModule});
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}

static auto getTurboLegacyCxxModule =
javaPart->getClass()
->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
const std::string&)>("getTurboLegacyCxxModule");
auto legacyCxxModule = getTurboLegacyCxxModule(javaPart.get(), name);
if (legacyCxxModule) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);

auto turboModule = std::make_shared<react::TurboCxxModule>(
legacyCxxModule->cthis()->getModule(), jsCallInvoker_);
turboModuleCache_.insert({name, turboModule});

TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}

return nullptr;
}

TurboModuleProviderFunctionType TurboModuleManager::createLegacyModuleProvider(
jni::alias_ref<jhybridobject> javaPart) {
return [legacyModuleCache_ = std::weak_ptr<ModuleCache>(legacyModuleCache_),
jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
nativeMethodCallInvoker_ =
std::weak_ptr<NativeMethodCallInvoker>(nativeMethodCallInvoker_),
weakDelegate = jni::make_weak(delegate_),
weakJavaPart = jni::make_weak(javaPart)](
return [weakJavaPart = jni::make_weak(javaPart)](
const std::string& name) -> std::shared_ptr<TurboModule> {
const char* moduleName = name.c_str();
TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);

auto legacyModuleCache = legacyModuleCache_.lock();
auto legacyModuleLookup = legacyModuleCache->find(name);
if (legacyModuleLookup != legacyModuleCache->end()) {
TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
return legacyModuleLookup->second;
}

auto jsCallInvoker = jsCallInvoker_.lock();
auto nativeMethodCallInvoker = nativeMethodCallInvoker_.lock();
auto delegate = weakDelegate.lockLocal();
auto javaPart = weakJavaPart.lockLocal();
if (!javaPart) {
return nullptr;
}

if (!legacyModuleCache || !jsCallInvoker || !nativeMethodCallInvoker ||
!delegate || !javaPart) {
auto cxxPart = javaPart->cthis();
if (cxxPart == nullptr) {
return nullptr;
}

return cxxPart->getLegacyModule(javaPart, name);
};
}

std::shared_ptr<TurboModule> TurboModuleManager::getLegacyModule(
jni::alias_ref<jhybridobject> javaPart,
const std::string& name) {
const char* moduleName = name.c_str();
TurboModulePerfLogger::moduleJSRequireBeginningStart(moduleName);

auto legacyModuleLookup = legacyModuleCache_.find(name);
if (legacyModuleLookup != legacyModuleCache_.end()) {
TurboModulePerfLogger::moduleJSRequireBeginningCacheHit(moduleName);
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
return legacyModuleLookup->second;
}

static auto getLegacyCxxModule =
javaPart->getClass()
->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
const std::string&)>("getLegacyCxxModule");
auto legacyCxxModule = getLegacyCxxModule(javaPart.get(), name);
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);

if (legacyCxxModule) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
static auto getLegacyCxxModule =
javaPart->getClass()
->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
const std::string&)>("getLegacyCxxModule");
auto legacyCxxModule = getLegacyCxxModule(javaPart.get(), name);

auto turboModule = std::make_shared<react::TurboCxxModule>(
legacyCxxModule->cthis()->getModule(), jsCallInvoker);
legacyModuleCache->insert({name, turboModule});
if (legacyCxxModule) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);

TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}
auto turboModule = std::make_shared<react::TurboCxxModule>(
legacyCxxModule->cthis()->getModule(), jsCallInvoker_);
legacyModuleCache_.insert({name, turboModule});

static auto getLegacyJavaModule =
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}

static auto getLegacyJavaModule =
javaPart->getClass()
->getMethod<jni::alias_ref<JNativeModule>(const std::string&)>(
"getLegacyJavaModule");
auto moduleInstance = getLegacyJavaModule(javaPart.get(), name);

if (moduleInstance) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
JavaTurboModule::InitParams params = {
.moduleName = name,
.instance = moduleInstance,
.jsInvoker = jsCallInvoker_,
.nativeMethodCallInvoker = nativeMethodCallInvoker_,
.shouldVoidMethodsExecuteSync = false};

static auto getMethodDescriptorsFromModule =
javaPart->getClass()
->getMethod<jni::alias_ref<JNativeModule>(const std::string&)>(
"getLegacyJavaModule");
auto moduleInstance = getLegacyJavaModule(javaPart.get(), name);

if (moduleInstance) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
JavaTurboModule::InitParams params = {
.moduleName = name,
.instance = moduleInstance,
.jsInvoker = jsCallInvoker,
.nativeMethodCallInvoker = nativeMethodCallInvoker,
.shouldVoidMethodsExecuteSync = false};

static auto getMethodDescriptorsFromModule =
javaPart->getClass()
->getStaticMethod<jni::alias_ref<
jni::JList<JMethodDescriptor::javaobject>::javaobject>(
jni::alias_ref<JNativeModule>)>(
"getMethodDescriptorsFromModule");

auto javaMethodDescriptors =
getMethodDescriptorsFromModule(javaPart->getClass(), moduleInstance);

std::vector<JavaInteropTurboModule::MethodDescriptor> methodDescriptors;
for (jni::alias_ref<JMethodDescriptor> javaMethodDescriptor :
*javaMethodDescriptors) {
methodDescriptors.push_back(javaMethodDescriptor->toMethodDescriptor());
}
->getStaticMethod<jni::alias_ref<
jni::JList<JMethodDescriptor::javaobject>::javaobject>(
jni::alias_ref<JNativeModule>)>(
"getMethodDescriptorsFromModule");

auto javaMethodDescriptors =
getMethodDescriptorsFromModule(javaPart->getClass(), moduleInstance);

std::vector<JavaInteropTurboModule::MethodDescriptor> methodDescriptors;
for (jni::alias_ref<JMethodDescriptor> javaMethodDescriptor :
*javaMethodDescriptors) {
methodDescriptors.push_back(javaMethodDescriptor->toMethodDescriptor());
}

auto turboModule =
std::make_shared<JavaInteropTurboModule>(params, methodDescriptors);
auto turboModule =
std::make_shared<JavaInteropTurboModule>(params, methodDescriptors);

legacyModuleCache->insert({name, turboModule});
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}
legacyModuleCache_.insert({name, turboModule});
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}

return nullptr;
};
return nullptr;
}

void TurboModuleManager::installJSIBindings(
Expand Down
Loading