void ScrollViewEventEmitter::dispatchScrollViewEvent(
const std::string &name,
const ScrollViewMetrics &scrollViewMetrics,
const folly::dynamic &payload) const {
folly::dynamic compoundPayload = folly::dynamic::object();
compoundPayload["contentOffset"] =
folly::dynamic::object("x", scrollViewMetrics.contentOffset.x)(
"y", scrollViewMetrics.contentOffset.y);
compoundPayload["contentInset"] =
folly::dynamic::object("top", scrollViewMetrics.contentInset.top)(
"left", scrollViewMetrics.contentInset.left)(
"bottom", scrollViewMetrics.contentInset.bottom)(
"right", scrollViewMetrics.contentInset.right);
compoundPayload["contentSize"] =
folly::dynamic::object("width", scrollViewMetrics.contentSize.width)(
"height", scrollViewMetrics.contentSize.height);
compoundPayload["layoutMeasurement"] =
folly::dynamic::object("width", scrollViewMetrics.containerSize.width)(
"height", scrollViewMetrics.containerSize.height);
compoundPayload["zoomScale"] = scrollViewMetrics.zoomScale;
if (!payload.isNull()) {
compoundPayload.merge_patch(payload);
}
dispatchEvent(name, compoundPayload);
}
fbstring phpSerialize(const folly::dynamic& d) {
if (d.isNull()) {
return "N;";
}
if (d.isBool()) {
return d.asBool() ? "b:1;" : "b:0;";
}
if (d.isInt()) {
return "i:" + d.asString() + ";";
}
if (d.isDouble()) {
return "d:" + d.asString() + ";";
}
if (d.isString()) {
auto str = d.asString();
return folly::to<fbstring>("s:", str.size(), ":\"", str, "\";");
}
if (d.isArray()) {
fbstring ret = folly::to<fbstring>("a:", d.size(), ":{");
int i = 0;
for (auto &v : d) {
ret += folly::to<fbstring>("i:", i, ";", phpSerialize(v));
}
return ret + "};";
}
if (d.isObject()) {
fbstring ret = folly::to<fbstring>("a:", d.size(), ":{");
int nextindex = 0;
for (auto &k : d.keys()) {
if (k.isNull()) {
ret += "i:0;";
if (nextindex <= 0) {
nextindex = 1;
}
} else if (k.isInt() || k.isDouble()) {
int i = k.asInt();
ret += folly::to<fbstring>("i:", i, ";");
if (nextindex <= i) {
nextindex = i + 1;
}
} else if (k.isString()) {
ret += folly::to<fbstring>("s:", k.size(), ":\"",
escapeCpp(k.asString()), "\";");
} else {
/* Should never be reached, but cover it to be safe */
ret += folly::to<fbstring>("i:", nextindex++, ";");
}
ret += phpSerialize(d[k]);
}
return ret + "};";
}
throw std::logic_error("Unhandled dynamic type in php serialization");
return "N;";
}
McrouterRouteHandlePtr makeErrorRoute(
RouteHandleFactory<McrouterRouteHandleIf>& factory,
const folly::dynamic& json) {
checkLogic(json.isObject() || json.isString() || json.isNull(),
"ErrorRoute: should be string or object");
std::string response;
if (json.isString()) {
response = json.stringPiece().str();
} else if (json.isObject()) {
if (auto jResponse = json.get_ptr("response")) {
checkLogic(jResponse->isString(), "ErrorRoute: response is not a string");
response = jResponse->stringPiece().str();
}
}
return makeErrorRoute(std::move(response));
}
static unsigned long parseFlags(const folly::dynamic &flags) {
if (flags.isNull()) {
return 0;
}
if (!flags.isArray()) {
throw std::logic_error("'flags' field must be an array");
}
unsigned long ret = 0;
for (auto &flag : flags) {
auto f = g_flagsMap.find(flag.asString());
if (f == g_flagsMap.end()) {
throw std::logic_error(
folly::format("Unknown flag '{0}' specified", flag.asString()).str()
);
}
ret |= f->second;
}
return ret;
}
jni::local_ref<NativeArray::jhybridobject>
createReadableNativeArrayWithContents(folly::dynamic array) {
if (array.isNull()) {
return jni::local_ref<NativeArray::jhybridobject>();
}
if (!array.isArray()) {
jni::throwNewJavaException("com/facebook/react/bridge/UnexpectedNativeTypeException",
"expected Array, got a %s", array.typeName());
}
static auto readableNativeArrayClass =
jni::findClassStatic("com/facebook/react/bridge/ReadableNativeArray");
static auto readableNativeArrayCtor =
readableNativeArrayClass->getConstructor<NativeArray::jhybridobject()>();
auto jnewArray = readableNativeArrayClass->newObject(readableNativeArrayCtor);
jni::cthis(jnewArray)->array = std::move(array);
return jnewArray;
}
// Infer type from an actual value, e.g. 123, "foo", null, true, etc...
static DataType kindOfFromValue(const folly::dynamic& v) {
if (v.isNull()) {
return KindOfNull;
}
if (v.isBool()) {
return KindOfBoolean;
}
if (v.isInt()) {
return KindOfInt64;
}
if (v.isDouble()) {
return KindOfDouble;
}
if (v.isString()) {
return KindOfString;
}
if (v.isArray()) {
return KindOfArray;
}
if (v.isObject()) {
return KindOfObject;
}
return KindOfInvalid;
}