Do not store .cpp/.h files inside src/main/java - turbomodule - take 2

Summary:
Currently we expose native code (.h, .cpp) inside the src/main/java folder.
This is making impossible for users on New Architecture to open the project
inside Android Studio.

The problem is that the src/main/java is reserved to Java/Kotlin sources only.
AGP 7.2 also removed support for mixed source roots:
https://developer.android.com/studio/releases/gradle-plugin#duplicate-content-roots

This is essentially forcing users to write Java code without any autocompletion
as all the React Native Java classes are considered C++ files.

I'm addressing this issue folder by folder by moving them
from ReactAndroid/src/main/java/com/facebook/... to ReactAndroid/src/main/jni/react/...

This is the diff for turbomodule

I've also updated all the internal usages and references to the new path.

Changelog:
[Internal] [Changed] - Do not store .cpp/.h files inside src/main/java - turbomodule

Reviewed By: cipolleschi

Differential Revision: D38820638

fbshipit-source-id: febb3f8cef18b30e82c3a4776baa85d0c0d19e4b
This commit is contained in:
Nicola Corti
2022-08-18 05:53:29 -07:00
committed by Facebook GitHub Bot
parent 33bd2f6eae
commit ba2dae3318
14 changed files with 4 additions and 4 deletions
@@ -28,12 +28,12 @@ rn_android_library(
react_native_dep("third-party/java/jsr-305:jsr-305"),
react_native_target("java/com/facebook/react/common:common"),
react_native_target("java/com/facebook/react/reactperflogger:reactperflogger"),
react_native_target("java/com/facebook/react/turbomodule/core/jni:jni"),
react_native_target("java/com/facebook/debug/holder:holder"),
react_native_target("java/com/facebook/react/bridge:interfaces"),
react_native_target("java/com/facebook/react/bridge:bridge"),
react_native_target("java/com/facebook/react/config:config"),
react_native_target("java/com/facebook/react/module/model:model"),
react_native_target("jni/react/turbomodule:jni"),
":callinvokerholder",
],
exported_deps = [
@@ -1,71 +0,0 @@
load("//tools/build_defs/oss:rn_defs.bzl", "ANDROID", "FBJNI_TARGET", "react_native_target", "react_native_xplat_shared_library_target", "react_native_xplat_target", "rn_xplat_cxx_library")
rn_xplat_cxx_library(
name = "jni",
srcs = [
"ReactCommon/CompositeTurboModuleManagerDelegate.cpp",
"ReactCommon/OnLoad.cpp",
"ReactCommon/TurboModuleManager.cpp",
],
header_namespace = "",
exported_headers = {
"ReactCommon/CompositeTurboModuleManagerDelegate.h": "ReactCommon/CompositeTurboModuleManagerDelegate.h",
"ReactCommon/TurboModuleManager.h": "ReactCommon/TurboModuleManager.h",
"ReactCommon/TurboModuleManagerDelegate.h": "ReactCommon/TurboModuleManagerDelegate.h",
},
fbandroid_allow_jni_merging = True,
labels = [
"pfh:ReactNative_CommonInfrastructurePlaceholder",
"supermodule:xplat/default/public.react_native.infra",
],
platforms = ANDROID,
preprocessor_flags = [
"-DLOG_TAG=\"ReactNative\"",
"-DWITH_FBSYSTRACE=1",
],
soname = "libturbomodulejsijni.$(ext)",
visibility = [
"PUBLIC",
],
deps = [
react_native_target("jni/react/jni:jni"),
FBJNI_TARGET,
],
exported_deps = [
":callinvokerholder",
react_native_xplat_shared_library_target("jsi:jsi"),
react_native_xplat_target("react/nativemodule/core:core"),
react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
react_native_target("jni/react/reactperflogger:jni"),
],
)
rn_xplat_cxx_library(
name = "callinvokerholder",
srcs = [
"ReactCommon/CallInvokerHolder.cpp",
],
header_namespace = "",
exported_headers = {
"ReactCommon/CallInvokerHolder.h": "ReactCommon/CallInvokerHolder.h",
},
fbandroid_deps = [
FBJNI_TARGET,
],
labels = [
"pfh:ReactNative_CommonInfrastructurePlaceholder",
"supermodule:xplat/default/public.react_native.infra",
],
platforms = ANDROID,
preferred_linkage = "static",
preprocessor_flags = [
"-DLOG_TAG=\"ReactNative\"",
"-DWITH_FBSYSTRACE=1",
],
visibility = [
"PUBLIC",
],
exported_deps = [
react_native_xplat_target("callinvoker:callinvoker"),
],
)
@@ -1,63 +0,0 @@
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
cmake_minimum_required(VERSION 3.13)
set(CMAKE_VERBOSE_MAKEFILE on)
add_compile_options(
-fexceptions
-frtti
-Wno-unused-lambda-capture
-std=c++17)
#########################
### callinvokerholder ###
#########################
# TODO This should be exported to its own folder hierarchy
add_library(
callinvokerholder
STATIC
ReactCommon/CallInvokerHolder.cpp
)
target_include_directories(callinvokerholder
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
)
target_link_libraries(callinvokerholder
fb
fbjni
runtimeexecutor
callinvoker
reactperfloggerjni)
##################################
### react_nativemodule_manager ###
##################################
# TODO: rename to react_nativemodule_manager
add_library(
turbomodulejsijni
SHARED
ReactCommon/CompositeTurboModuleManagerDelegate.cpp
ReactCommon/OnLoad.cpp
ReactCommon/TurboModuleManager.cpp
)
target_include_directories(
turbomodulejsijni
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}
)
target_link_libraries(turbomodulejsijni
fb
fbjni
jsi
react_nativemodule_core
callinvokerholder
reactperfloggerjni)
@@ -1,23 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "CallInvokerHolder.h"
namespace facebook {
namespace react {
CallInvokerHolder::CallInvokerHolder(std::shared_ptr<CallInvoker> callInvoker)
: _callInvoker(callInvoker) {}
std::shared_ptr<CallInvoker> CallInvokerHolder::getCallInvoker() {
return _callInvoker;
}
void CallInvokerHolder::registerNatives() {}
} // namespace react
} // namespace facebook
@@ -1,32 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <ReactCommon/CallInvoker.h>
#include <fbjni/fbjni.h>
#include <memory>
namespace facebook {
namespace react {
class CallInvokerHolder : public jni::HybridClass<CallInvokerHolder> {
public:
static auto constexpr kJavaDescriptor =
"Lcom/facebook/react/turbomodule/core/CallInvokerHolderImpl;";
static void registerNatives();
std::shared_ptr<CallInvoker> getCallInvoker();
private:
friend HybridBase;
CallInvokerHolder(std::shared_ptr<CallInvoker> callInvoker);
std::shared_ptr<CallInvoker> _callInvoker;
};
} // namespace react
} // namespace facebook
@@ -1,59 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include "CompositeTurboModuleManagerDelegate.h"
namespace facebook {
namespace react {
jni::local_ref<CompositeTurboModuleManagerDelegate::jhybriddata>
CompositeTurboModuleManagerDelegate::initHybrid(jni::alias_ref<jhybridobject>) {
return makeCxxInstance();
}
void CompositeTurboModuleManagerDelegate::registerNatives() {
registerHybrid({
makeNativeMethod(
"initHybrid", CompositeTurboModuleManagerDelegate::initHybrid),
makeNativeMethod(
"addTurboModuleManagerDelegate",
CompositeTurboModuleManagerDelegate::addTurboModuleManagerDelegate),
});
}
std::shared_ptr<TurboModule>
CompositeTurboModuleManagerDelegate::getTurboModule(
const std::string &moduleName,
const std::shared_ptr<CallInvoker> &jsInvoker) {
for (auto delegate : mDelegates_) {
if (auto turboModule = delegate->getTurboModule(moduleName, jsInvoker)) {
return turboModule;
}
}
return nullptr;
}
std::shared_ptr<TurboModule>
CompositeTurboModuleManagerDelegate::getTurboModule(
const std::string &moduleName,
const JavaTurboModule::InitParams &params) {
for (auto delegate : mDelegates_) {
if (auto turboModule = delegate->getTurboModule(moduleName, params)) {
return turboModule;
}
}
return nullptr;
}
void CompositeTurboModuleManagerDelegate::addTurboModuleManagerDelegate(
jni::alias_ref<TurboModuleManagerDelegate::javaobject>
turboModuleManagerDelegate) {
mDelegates_.insert(turboModuleManagerDelegate->cthis());
}
} // namespace react
} // namespace facebook
@@ -1,49 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <ReactCommon/TurboModuleManagerDelegate.h>
#include <fbjni/fbjni.h>
#include <memory>
#include <string>
#include <unordered_set>
namespace facebook {
namespace react {
class CompositeTurboModuleManagerDelegate
: public jni::HybridClass<
CompositeTurboModuleManagerDelegate,
TurboModuleManagerDelegate> {
public:
static auto constexpr kJavaDescriptor =
"Lcom/facebook/react/CompositeReactPackageTurboModuleManagerDelegate;";
static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject>);
static void registerNatives();
std::shared_ptr<TurboModule> getTurboModule(
const std::string &moduleName,
const std::shared_ptr<CallInvoker> &jsInvoker) override;
std::shared_ptr<TurboModule> getTurboModule(
const std::string &moduleName,
const JavaTurboModule::InitParams &params) override;
private:
friend HybridBase;
using HybridBase::HybridBase;
std::unordered_set<TurboModuleManagerDelegate *> mDelegates_;
void addTurboModuleManagerDelegate(
jni::alias_ref<TurboModuleManagerDelegate::javaobject>
turboModuleManagerDelegate);
};
} // namespace react
} // namespace facebook
@@ -1,35 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <ReactCommon/TurboModulePerfLogger.h>
#include <fbjni/fbjni.h>
#include <reactperflogger/JNativeModulePerfLogger.h>
#include "CompositeTurboModuleManagerDelegate.h"
#include "TurboModuleManager.h"
void jniEnableCppLogging(
facebook::jni::alias_ref<jclass> cls,
facebook::jni::alias_ref<
facebook::react::JNativeModulePerfLogger::javaobject> perfLogger) {
facebook::react::TurboModulePerfLogger::enableLogging(
perfLogger->cthis()->get());
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
return facebook::jni::initialize(vm, [] {
// TODO: dvacca ramanpreet unify this with the way
// "ComponentDescriptorFactory" is defined in Fabric
facebook::react::TurboModuleManager::registerNatives();
facebook::react::CompositeTurboModuleManagerDelegate::registerNatives();
facebook::jni::registerNatives(
"com/facebook/react/turbomodule/core/TurboModulePerfLogger",
{makeNativeMethod("jniEnableCppLogging", jniEnableCppLogging)});
});
}
@@ -1,194 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#include <memory>
#include <string>
#include <fbjni/fbjni.h>
#include <jsi/jsi.h>
#include <ReactCommon/TurboCxxModule.h>
#include <ReactCommon/TurboModuleBinding.h>
#include <ReactCommon/TurboModulePerfLogger.h>
#include "TurboModuleManager.h"
namespace facebook {
namespace react {
constexpr static auto ReactFeatureFlagsJavaDescriptor =
"com/facebook/react/config/ReactFeatureFlags";
static int getFeatureFlagValue(const char *name) {
static const auto reactFeatureFlagsJavaDescriptor =
jni::findClassStatic(ReactFeatureFlagsJavaDescriptor);
const auto field =
reactFeatureFlagsJavaDescriptor->getStaticField<jint>(name);
return reactFeatureFlagsJavaDescriptor->getStaticFieldValue(field);
}
TurboModuleManager::TurboModuleManager(
jni::alias_ref<TurboModuleManager::javaobject> jThis,
RuntimeExecutor runtimeExecutor,
std::shared_ptr<CallInvoker> jsCallInvoker,
std::shared_ptr<CallInvoker> nativeCallInvoker,
jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate,
bool useGlobalCallbackCleanupScopeUsingRetainJSCallback,
bool useTurboModuleManagerCallbackCleanupScope)
: javaPart_(jni::make_global(jThis)),
runtimeExecutor_(runtimeExecutor),
jsCallInvoker_(jsCallInvoker),
nativeCallInvoker_(nativeCallInvoker),
delegate_(jni::make_global(delegate)),
turboModuleCache_(std::make_shared<TurboModuleCache>()) {
if (useGlobalCallbackCleanupScopeUsingRetainJSCallback) {
longLivedObjectCollection_ = nullptr;
retainJSCallback_ = [](jsi::Function &&callback,
jsi::Runtime &runtime,
std::shared_ptr<CallInvoker> jsInvoker) {
return CallbackWrapper::createWeak(
std::move(callback), runtime, jsInvoker);
};
} else if (useTurboModuleManagerCallbackCleanupScope) {
longLivedObjectCollection_ = std::make_shared<LongLivedObjectCollection>();
retainJSCallback_ = [longLivedObjectCollection =
longLivedObjectCollection_](
jsi::Function &&callback,
jsi::Runtime &runtime,
std::shared_ptr<CallInvoker> jsInvoker) {
return CallbackWrapper::createWeak(
longLivedObjectCollection, std::move(callback), runtime, jsInvoker);
};
}
}
jni::local_ref<TurboModuleManager::jhybriddata> TurboModuleManager::initHybrid(
jni::alias_ref<jhybridobject> jThis,
jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
jni::alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
jni::alias_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder,
jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate,
bool useGlobalCallbackCleanupScopeUsingRetainJSCallback,
bool useTurboModuleManagerCallbackCleanupScope) {
auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
auto nativeCallInvoker = nativeCallInvokerHolder->cthis()->getCallInvoker();
return makeCxxInstance(
jThis,
runtimeExecutor->cthis()->get(),
jsCallInvoker,
nativeCallInvoker,
delegate,
useGlobalCallbackCleanupScopeUsingRetainJSCallback,
useTurboModuleManagerCallbackCleanupScope);
}
void TurboModuleManager::registerNatives() {
registerHybrid({
makeNativeMethod("initHybrid", TurboModuleManager::initHybrid),
makeNativeMethod(
"installJSIBindings", TurboModuleManager::installJSIBindings),
});
}
void TurboModuleManager::installJSIBindings() {
if (!jsCallInvoker_) {
return; // Runtime doesn't exist when attached to Chrome debugger.
}
runtimeExecutor_([this](jsi::Runtime &runtime) {
auto turboModuleProvider =
[turboModuleCache_ = std::weak_ptr<TurboModuleCache>(turboModuleCache_),
jsCallInvoker_ = std::weak_ptr<CallInvoker>(jsCallInvoker_),
nativeCallInvoker_ = std::weak_ptr<CallInvoker>(nativeCallInvoker_),
delegate_ = jni::make_weak(delegate_),
javaPart_ = jni::make_weak(javaPart_),
retainJSCallback = retainJSCallback_](
const std::string &name) -> std::shared_ptr<TurboModule> {
auto turboModuleCache = turboModuleCache_.lock();
auto jsCallInvoker = jsCallInvoker_.lock();
auto nativeCallInvoker = nativeCallInvoker_.lock();
auto delegate = delegate_.lockLocal();
auto javaPart = javaPart_.lockLocal();
if (!turboModuleCache || !jsCallInvoker || !nativeCallInvoker ||
!delegate || !javaPart) {
return nullptr;
}
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;
}
TurboModulePerfLogger::moduleJSRequireBeginningEnd(moduleName);
auto cxxModule = delegate->cthis()->getTurboModule(name, jsCallInvoker);
if (cxxModule) {
turboModuleCache->insert({name, cxxModule});
return cxxModule;
}
static auto getLegacyCxxModule =
javaPart->getClass()
->getMethod<jni::alias_ref<CxxModuleWrapper::javaobject>(
const std::string &)>("getLegacyCxxModule");
auto legacyCxxModule = getLegacyCxxModule(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 getJavaModule =
javaPart->getClass()
->getMethod<jni::alias_ref<JTurboModule>(const std::string &)>(
"getJavaModule");
auto moduleInstance = getJavaModule(javaPart.get(), name);
if (moduleInstance) {
TurboModulePerfLogger::moduleJSRequireEndingStart(moduleName);
JavaTurboModule::InitParams params = {
.moduleName = name,
.instance = moduleInstance,
.jsInvoker = jsCallInvoker,
.nativeInvoker = nativeCallInvoker,
.retainJSCallback = retainJSCallback};
auto turboModule = delegate->cthis()->getTurboModule(name, params);
turboModuleCache->insert({name, turboModule});
TurboModulePerfLogger::moduleJSRequireEndingEnd(moduleName);
return turboModule;
}
return nullptr;
};
TurboModuleBindingMode bindingMode = static_cast<TurboModuleBindingMode>(
getFeatureFlagValue("turboModuleBindingMode"));
TurboModuleBinding::install(
runtime,
std::move(turboModuleProvider),
bindingMode,
longLivedObjectCollection_);
});
}
} // namespace react
} // namespace facebook
@@ -1,74 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <ReactCommon/CallInvokerHolder.h>
#include <ReactCommon/JavaTurboModule.h>
#include <ReactCommon/LongLivedObject.h>
#include <ReactCommon/RuntimeExecutor.h>
#include <ReactCommon/TurboModule.h>
#include <ReactCommon/TurboModuleManagerDelegate.h>
#include <fbjni/fbjni.h>
#include <jsi/jsi.h>
#include <react/jni/CxxModuleWrapper.h>
#include <react/jni/JRuntimeExecutor.h>
#include <memory>
#include <unordered_map>
namespace facebook {
namespace react {
class TurboModuleManager : public jni::HybridClass<TurboModuleManager> {
public:
static auto constexpr kJavaDescriptor =
"Lcom/facebook/react/turbomodule/core/TurboModuleManager;";
static jni::local_ref<jhybriddata> initHybrid(
jni::alias_ref<jhybridobject> jThis,
jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
jni::alias_ref<CallInvokerHolder::javaobject> jsCallInvokerHolder,
jni::alias_ref<CallInvokerHolder::javaobject> nativeCallInvokerHolder,
jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate,
bool useGlobalCallbackCleanupScopeUsingRetainJSCallback,
bool useTurboModuleManagerCallbackCleanupScope);
static void registerNatives();
private:
friend HybridBase;
jni::global_ref<TurboModuleManager::javaobject> javaPart_;
RuntimeExecutor runtimeExecutor_;
std::shared_ptr<CallInvoker> jsCallInvoker_;
std::shared_ptr<CallInvoker> nativeCallInvoker_;
jni::global_ref<TurboModuleManagerDelegate::javaobject> delegate_;
JSCallbackRetainer retainJSCallback_;
std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
using TurboModuleCache =
std::unordered_map<std::string, std::shared_ptr<react::TurboModule>>;
/**
* TODO(T48018690):
* All modules are currently long-lived.
* We need to come up with a mechanism to allow modules to specify whether
* they want to be long-lived or short-lived.
*/
std::shared_ptr<TurboModuleCache> turboModuleCache_;
void installJSIBindings();
explicit TurboModuleManager(
jni::alias_ref<TurboModuleManager::jhybridobject> jThis,
RuntimeExecutor runtimeExecutor,
std::shared_ptr<CallInvoker> jsCallInvoker,
std::shared_ptr<CallInvoker> nativeCallInvoker,
jni::alias_ref<TurboModuleManagerDelegate::javaobject> delegate,
bool useGlobalCallbackCleanupScopeUsingRetainJSCallback,
bool useTurboModuleManagerCallbackCleanupScope);
};
} // namespace react
} // namespace facebook
@@ -1,37 +0,0 @@
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <ReactCommon/CallInvoker.h>
#include <ReactCommon/JavaTurboModule.h>
#include <fbjni/fbjni.h>
#include <memory>
#include <string>
namespace facebook {
namespace react {
class TurboModuleManagerDelegate
: public jni::HybridClass<TurboModuleManagerDelegate> {
public:
static auto constexpr kJavaDescriptor =
"Lcom/facebook/react/turbomodule/core/TurboModuleManagerDelegate;";
virtual std::shared_ptr<TurboModule> getTurboModule(
const std::string &name,
const JavaTurboModule::InitParams &params) = 0;
virtual std::shared_ptr<TurboModule> getTurboModule(
const std::string &name,
const std::shared_ptr<CallInvoker> &jsInvoker) = 0;
private:
friend HybridBase;
};
} // namespace react
} // namespace facebook