status-im
/
react-native
mirror of https://github.com/status-im/react-native.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Reverted commit D3207541 

Reviewed By: michalgr

Differential Revision: D3207541

fbshipit-source-id: 36366188b7cb74c51d4aa974abd4a648498bcf78
This commit is contained in:
Clement Genzmer 2016-07-07 14:46:12 -07:00 committed by Facebook Github Bot 2
parent 6565edc9ed
commit 80c23ae324
11 changed files with 46 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ReactAndroid/src/main/java/com/facebook/react/XReactInstanceManagerImpl.java
View File

@ -412,12 +412,9 @@ import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
}
private void recreateReactContextInBackgroundFromBundleFile() {
boolean useLazyBundle = mJSCConfig.getConfigMap().hasKey("useLazyBundle") ?
mJSCConfig.getConfigMap().getBoolean("useLazyBundle") : false;
recreateReactContextInBackground(
new JSCJavaScriptExecutor.Factory(mJSCConfig.getConfigMap()),
JSBundleLoader.createFileLoader(mApplicationContext, mJSBundleFile, useLazyBundle));
JSBundleLoader.createFileLoader(mApplicationContext, mJSBundleFile));
}
/**

2
ReactAndroid/src/main/java/com/facebook/react/cxxbridge/CatalystInstanceImpl.java
View File

@ -161,7 +161,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
MessageQueueThread moduleQueue,
ModuleRegistryHolder registryHolder);
/* package */ native void loadScriptFromAssets(AssetManager assetManager, String assetURL, boolean useLazyBundle);
/* package */ native void loadScriptFromAssets(AssetManager assetManager, String assetURL);
/* package */ native void loadScriptFromFile(String fileName, String sourceURL);
@Override

9
ReactAndroid/src/main/java/com/facebook/react/cxxbridge/JSBundleLoader.java
View File

@ -28,18 +28,11 @@ public abstract class JSBundleLoader {
public static JSBundleLoader createFileLoader(
final Context context,
final String fileName) {
return createFileLoader(context, fileName, false);
}
public static JSBundleLoader createFileLoader(
final Context context,
final String fileName,
final boolean useLazyBundle) {
return new JSBundleLoader() {
@Override
public void loadScript(CatalystInstanceImpl instance) {
if (fileName.startsWith("assets://")) {
instance.loadScriptFromAssets(context.getAssets(), fileName, useLazyBundle);
instance.loadScriptFromAssets(context.getAssets(), fileName);
} else {
instance.loadScriptFromFile(fileName, fileName);
}

125
ReactAndroid/src/main/jni/xreact/jni/CatalystInstanceImpl.cpp
View File

@ -13,8 +13,6 @@
#include <jni/Countable.h>
#include <jni/LocalReference.h>
#include <sys/stat.h>
#include <cxxreact/Instance.h>
#include <cxxreact/MethodCall.h>
#include <cxxreact/ModuleRegistry.h>
@ -25,7 +23,6 @@
#include "ModuleRegistryHolder.h"
#include "NativeArray.h"
#include "JNativeRunnable.h"
#include "OnLoad.h"
using namespace facebook::jni;
@ -101,7 +98,7 @@ void CatalystInstanceImpl::registerNatives() {
makeNativeMethod("initHybrid", CatalystInstanceImpl::initHybrid),
makeNativeMethod("initializeBridge", CatalystInstanceImpl::initializeBridge),
makeNativeMethod("loadScriptFromAssets",
"(Landroid/content/res/AssetManager;Ljava/lang/String;Z)V",
"(Landroid/content/res/AssetManager;Ljava/lang/String;)V",
CatalystInstanceImpl::loadScriptFromAssets),
makeNativeMethod("loadScriptFromFile", CatalystInstanceImpl::loadScriptFromFile),
makeNativeMethod("callJSFunction", CatalystInstanceImpl::callJSFunction),
@ -152,132 +149,20 @@ void CatalystInstanceImpl::initializeBridge(
mrh->getModuleRegistry());
}
#ifdef WITH_FBJSCEXTENSIONS
static std::unique_ptr<const JSBigString> loadScriptFromCache(
AAssetManager* manager,
std::string& sourceURL) {
// 20-byte sha1 as hex
static const size_t HASH_STR_SIZE = 40;
// load bundle hash from the metadata file in the APK
auto hash = react::loadScriptFromAssets(manager, sourceURL + ".meta");
auto cacheDir = getApplicationCacheDir() + "/rn-bundle";
auto encoding = static_cast<JSBigMmapString::Encoding>(hash->c_str()[20]);
if (mkdir(cacheDir.c_str(), 0755) == -1 && errno != EEXIST) {
throw std::runtime_error("Can't create cache directory");
}
if (encoding != JSBigMmapString::Encoding::Ascii) {
throw std::runtime_error("Can't use mmap fastpath for non-ascii bundles");
}
// convert hash to string
char hashStr[HASH_STR_SIZE + 1];
for (size_t i = 0; i < HASH_STR_SIZE; i += 2) {
snprintf(hashStr + i, 3, "%02hhx", hash->c_str()[i / 2] & 0xFF);
}
// the name of the cached bundle file should be the hash
std::string cachePath = cacheDir + "/" + hashStr;
FILE *cache = fopen(cachePath.c_str(), "r");
SCOPE_EXIT { if (cache) fclose(cache); };
size_t size = 0;
if (cache == NULL) {
// delete old bundle, if there was one.
std::string metaPath = cacheDir + "/meta";
if (auto meta = fopen(metaPath.c_str(), "r")) {
char oldBundleHash[HASH_STR_SIZE + 1];
if (fread(oldBundleHash, HASH_STR_SIZE, 1, meta) == HASH_STR_SIZE) {
remove((cacheDir + "/" + oldBundleHash).c_str());
remove(metaPath.c_str());
}
fclose(meta);
}
// load script from the APK and write to temporary file
auto script = react::loadScriptFromAssets(manager, sourceURL);
auto tmpPath = cachePath + "_";
cache = fopen(tmpPath.c_str(), "w");
if (!cache) {
throw std::runtime_error("Can't open cache, errno: " + errno);
}
if (fwrite(script->c_str(), 1, script->size(), cache) != size) {
remove(tmpPath.c_str());
throw std::runtime_error("Failed to unpack bundle");
}
// force data to be written to disk
fsync(fileno(cache));
fclose(cache);
// move script to final path - atomic operation
if (rename(tmpPath.c_str(), cachePath.c_str())) {
throw std::runtime_error("Failed to update cache, errno: " + errno);
}
// store the bundle hash in a metadata file
auto meta = fopen(metaPath.c_str(), "w");
if (!meta) {
throw std::runtime_error("Failed to open metadata file to store bundle hash");
}
if (fwrite(hashStr, HASH_STR_SIZE, 1, meta) != HASH_STR_SIZE) {
throw std::runtime_error("Failed to write bundle hash to metadata file");
}
fsync(fileno(meta));
fclose(meta);
// return the final written cache
cache = fopen(cachePath.c_str(), "r");
if (!cache) {
throw std::runtime_error("Cache has been cleared");
}
} else {
struct stat fileInfo = {0};
if (fstat(fileno(cache), &fileInfo)) {
throw std::runtime_error("Failed to get cache stats, errno: " + errno);
}
size = fileInfo.st_size;
}
return folly::make_unique<const JSBigMmapString>(
dup(fileno(cache)),
size,
reinterpret_cast<const uint8_t*>(hash->c_str()),
encoding);
}
#endif
void CatalystInstanceImpl::loadScriptFromAssets(jobject assetManager,
const std::string& assetURL,
bool useLazyBundle) {
const std::string& assetURL) {
const int kAssetsLength = 9; // strlen("assets://");
auto sourceURL = assetURL.substr(kAssetsLength);
auto manager = react::extractAssetManager(assetManager);
auto manager = react::extractAssetManager(assetManager);
auto script = react::loadScriptFromAssets(manager, sourceURL);
if (JniJSModulesUnbundle::isUnbundle(manager, sourceURL)) {
auto script = react::loadScriptFromAssets(manager, sourceURL);
instance_->loadUnbundle(
folly::make_unique<JniJSModulesUnbundle>(manager, sourceURL),
std::move(script),
sourceURL);
return;
} else {
#ifdef WITH_FBJSCEXTENSIONS
if (useLazyBundle) {
try {
auto script = loadScriptFromCache(manager, sourceURL);
instance_->loadScriptFromString(std::move(script), sourceURL);
return;
} catch (...) {
LOG(WARNING) << "Failed to load bundle as Source Code";
}
}
#endif
auto script = react::loadScriptFromAssets(manager, sourceURL);
instance_->loadScriptFromString(std::move(script), sourceURL);
instance_->loadScriptFromString(std::move(script), std::move(sourceURL));
}
}

2
ReactAndroid/src/main/jni/xreact/jni/CatalystInstanceImpl.h
View File

@ -47,7 +47,7 @@ class CatalystInstanceImpl : public jni::HybridClass<CatalystInstanceImpl> {
jni::alias_ref<JavaMessageQueueThread::javaobject> jsQueue,
jni::alias_ref<JavaMessageQueueThread::javaobject> moduleQueue,
ModuleRegistryHolder* mrh);
void loadScriptFromAssets(jobject assetManager, const std::string& assetURL, bool useLazyBundle);
void loadScriptFromAssets(jobject assetManager, const std::string& assetURL);
void loadScriptFromFile(jni::alias_ref<jstring> fileName, const std::string& sourceURL);
void callJSFunction(JExecutorToken* token, std::string module, std::string method, NativeArray* arguments);
void callJSCallback(JExecutorToken* token, jint callbackId, NativeArray* arguments);

8
ReactAndroid/src/main/jni/xreact/jni/OnLoad.cpp
View File

@ -51,6 +51,10 @@ static std::string getApplicationDir(const char* methodName) {
return getAbsolutePathMethod(dirObj)->toStdString();
}
static std::string getApplicationCacheDir() {
return getApplicationDir("getCacheDir");
}
static std::string getApplicationPersistentDir() {
return getApplicationDir("getFilesDir");
}
@ -158,10 +162,6 @@ class JReactMarker : public JavaClass<JReactMarker> {
}
std::string getApplicationCacheDir() {
return getApplicationDir("getCacheDir");
}
extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
return initialize(vm, [] {
// Inject some behavior into react/

1
ReactAndroid/src/main/jni/xreact/jni/OnLoad.h
View File

@ -10,6 +10,5 @@ namespace facebook {
namespace react {
jmethodID getLogMarkerMethod();
std::string getApplicationCacheDir();
} // namespace react
} // namespace facebook

64
ReactCommon/cxxreact/Executor.h
View File

@ -7,8 +7,6 @@
#include <string>
#include <vector>
#include <sys/mman.h>
#include <folly/dynamic.h>
#include "JSModulesUnbundle.h"
@ -136,68 +134,6 @@ private:
size_t m_size;
};
class JSBigMmapString : public JSBigString {
public:
enum class Encoding {
Unknown,
Ascii,
Utf8,
Utf16,
};
JSBigMmapString(int fd, size_t size, const uint8_t sha1[20], Encoding encoding) :
m_fd(fd),
m_size(size),
m_encoding(encoding),
m_str(nullptr)
{
memcpy(m_hash, sha1, 20);
}
~JSBigMmapString() {
if (m_str) {
CHECK(munmap((void *)m_str, m_size) != -1);
}
close(m_fd);
}
bool isAscii() const override {
return m_encoding == Encoding::Ascii;
}
const char* c_str() const override {
if (!m_str) {
m_str = (const char *)mmap(0, m_size, PROT_READ, MAP_SHARED, m_fd, 0);
CHECK(m_str != MAP_FAILED);
}
return m_str;
}
size_t size() const override {
return m_size;
}
int fd() const {
return m_fd;
}
const uint8_t* hash() const {
return m_hash;
}
Encoding encoding() const {
return m_encoding;
}
private:
int m_fd;
size_t m_size;
uint8_t m_hash[20];
Encoding m_encoding;
mutable const char *m_str;
};
class JSExecutor {
public:
/**

23
ReactCommon/cxxreact/JSCExecutor.cpp
View File

@ -253,33 +253,10 @@ void JSCExecutor::terminateOnJSVMThread() {
m_context = nullptr;
}
#ifdef WITH_FBJSCEXTENSIONS
static void loadApplicationSource(
const JSGlobalContextRef context,
const JSBigMmapString* script,
const std::string& sourceURL) {
String jsSourceURL(sourceURL.c_str());
bool is8bit = script->encoding() == JSBigMmapString::Encoding::Ascii || script->encoding() == JSBigMmapString::Encoding::Utf8;
JSSourceCodeRef sourceCode = JSCreateSourceCode(script->fd(), script->size(), jsSourceURL, script->hash(), is8bit);
evaluateSourceCode(context, sourceCode, jsSourceURL);
JSReleaseSourceCode(sourceCode);
}
#endif
void JSCExecutor::loadApplicationScript(std::unique_ptr<const JSBigString> script, std::string sourceURL) throw(JSException) {
SystraceSection s("JSCExecutor::loadApplicationScript",
"sourceURL", sourceURL);
#ifdef WITH_FBJSCEXTENSIONS
if (auto source = dynamic_cast<const JSBigMmapString *>(script.get())) {
loadApplicationSource(m_context, source, sourceURL);
bindBridge();
flush();
ReactMarker::logMarker("CREATE_REACT_CONTEXT_END");
return;
}
#endif
#ifdef WITH_FBSYSTRACE
fbsystrace_begin_section(
TRACE_TAG_REACT_CXX_BRIDGE,

82
ReactCommon/cxxreact/JSCHelpers.cpp
View File

@ -44,63 +44,47 @@ JSValueRef evaluateScript(JSContextRef context, JSStringRef script, JSStringRef
JSValueRef exn, result;
result = JSEvaluateScript(context, script, NULL, source, 0, &exn);
if (result == nullptr) {
formatAndThrowJSException(context, exn, source);
}
return result;
}
Value exception = Value(context, exn);
#if WITH_FBJSCEXTENSIONS
JSValueRef evaluateSourceCode(JSContextRef context, JSSourceCodeRef source, JSStringRef sourceURL) {
JSValueRef exn, result;
result = JSEvaluateSourceCode(context, source, NULL, &exn);
if (result == nullptr) {
formatAndThrowJSException(context, exn, sourceURL);
}
return result;
}
#endif
std::string exceptionText = exception.toString().str();
void formatAndThrowJSException(JSContextRef context, JSValueRef exn, JSStringRef source) {
Value exception = Value(context, exn);
// The null/empty-ness of source tells us if the JS came from a
// file/resource, or was a constructed statement. The location
// info will include that source, if any.
std::string locationInfo = source != nullptr ? String::ref(source).str() : "";
Object exObject = exception.asObject();
auto line = exObject.getProperty("line");
if (line != nullptr && line.isNumber()) {
if (locationInfo.empty() && line.asInteger() != 1) {
// If there is a non-trivial line number, but there was no
// location info, we include a placeholder, and the line
// number.
locationInfo = folly::to<std::string>("<unknown file>:", line.asInteger());
} else if (!locationInfo.empty()) {
// If there is location info, we always include the line
// number, regardless of its value.
locationInfo += folly::to<std::string>(":", line.asInteger());
}
}
std::string exceptionText = exception.toString().str();
if (!locationInfo.empty()) {
exceptionText += " (" + locationInfo + ")";
}
// The null/empty-ness of source tells us if the JS came from a
// file/resource, or was a constructed statement. The location
// info will include that source, if any.
std::string locationInfo = source != nullptr ? String::ref(source).str() : "";
Object exObject = exception.asObject();
auto line = exObject.getProperty("line");
if (line != nullptr && line.isNumber()) {
if (locationInfo.empty() && line.asInteger() != 1) {
// If there is a non-trivial line number, but there was no
// location info, we include a placeholder, and the line
// number.
locationInfo = folly::to<std::string>("<unknown file>:", line.asInteger());
} else if (!locationInfo.empty()) {
// If there is location info, we always include the line
// number, regardless of its value.
locationInfo += folly::to<std::string>(":", line.asInteger());
LOG(ERROR) << "Got JS Exception: " << exceptionText;
Value jsStack = exObject.getProperty("stack");
if (jsStack.isNull() || !jsStack.isString()) {
throwJSExecutionException("%s", exceptionText.c_str());
} else {
LOG(ERROR) << "Got JS Stack: " << jsStack.toString().str();
throwJSExecutionExceptionWithStack(
exceptionText.c_str(), jsStack.toString().str().c_str());
}
}
if (!locationInfo.empty()) {
exceptionText += " (" + locationInfo + ")";
}
LOG(ERROR) << "Got JS Exception: " << exceptionText;
Value jsStack = exObject.getProperty("stack");
if (jsStack.isNull() || !jsStack.isString()) {
throwJSExecutionException("%s", exceptionText.c_str());
} else {
LOG(ERROR) << "Got JS Stack: " << jsStack.toString().str();
throwJSExecutionExceptionWithStack(
exceptionText.c_str(), jsStack.toString().str().c_str());
}
return result;
}
JSValueRef makeJSError(JSContextRef ctx, const char *error) {
JSValueRef nestedException = nullptr;
JSValueRef args[] = { Value(ctx, String(error)) };

12
ReactCommon/cxxreact/JSCHelpers.h
View File

@ -49,18 +49,6 @@ JSValueRef evaluateScript(
JSStringRef script,
JSStringRef sourceURL);
#if WITH_FBJSCEXTENSIONS
JSValueRef evaluateSourceCode(
JSContextRef ctx,
JSSourceCodeRef source,
JSStringRef sourceURL);
#endif
void formatAndThrowJSException(
JSContextRef ctx,
JSValueRef exn,
JSStringRef sourceURL);
JSValueRef makeJSError(JSContextRef ctx, const char *error);
JSValueRef translatePendingCppExceptionToJSError(JSContextRef ctx, const char *exceptionLocation);