react-native/ReactCommon/fabric/uimanager/ReactBytecodeInterpreter.cpp

/**
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

#include "ReactBytecodeInterpreter.h"

#include <glog/logging.h>

#include <fabric/components/view/ViewComponentDescriptor.h>
#include <fabric/components/view/ViewProps.h>
#include <fabric/components/view/ViewShadowNode.h>
#include <fabric/core/LayoutContext.h>
#include <fabric/core/ShadowNodeFragment.h>
#include <fabric/core/componentDescriptor.h>
#include <fabric/debug/DebugStringConvertible.h>
#include <fabric/debug/DebugStringConvertibleItem.h>
#include <folly/json.h>

namespace facebook {
namespace react {

struct RBCContext {
  const Tag rootTag;
  const std::vector<SharedShadowNode> &nodes;
  const std::vector<folly::dynamic> &registers;
  const ComponentDescriptorRegistry &componentDescriptorRegistry;
  const NativeModuleRegistry &nativeModuleRegistry;
};

// TODO: use RBCContext instead of all the separate arguments.
SharedShadowNode ReactBytecodeInterpreter::runCommand(
    const folly::dynamic &command,
    Tag rootTag,
    std::vector<SharedShadowNode> &nodes,
    std::vector<folly::dynamic> &registers,
    const ComponentDescriptorRegistry &componentDescriptorRegistry,
    const NativeModuleRegistry &nativeModuleRegistry) {
  const std::string &opcode = command[0].asString();
  const int tagOffset = 420000;
  if (opcode == "createNode") {
    int tag = command[1].asInt();
    const auto &type = command[2].asString();
    const auto parentTag = command[3].asInt();
    const auto &props = command[4];
    nodes[tag] = componentDescriptorRegistry.createNode(
        tag + tagOffset, type, rootTag, props, nullptr);
    if (parentTag > -1) { // parentTag == -1 indicates root node
      auto parentShadowNode = nodes[parentTag];
      const SharedComponentDescriptor &componentDescriptor =
          componentDescriptorRegistry[parentShadowNode];
      componentDescriptor->appendChild(parentShadowNode, nodes[tag]);
    }
  } else if (opcode == "childSetNode") {
    LOG(INFO)
        << "(stop) ReactBytecodeInterpreter inject serialized 'server rendered' view tree";
    return nodes[command[1].asInt()];
  } else if (opcode == "loadNativeBool") {
    int registerNumber = command[1].asInt();
    const folly::dynamic &value = nativeModuleRegistry.call(
        command[2].asString(), command[3].asString(), command[4]);
    registers[registerNumber] = value.asBool();
  } else if (opcode == "conditional") {
    int registerNumber = command[1].asInt();
    auto conditionDynamic = registers[registerNumber];
    if (conditionDynamic.isNull()) {
      // TODO: provide original command or command line?
      auto err = std::runtime_error(
          "register " + command[1].asString() +
          " wasn't loaded before access");
      throw err;
    } else if (conditionDynamic.type() != folly::dynamic::BOOL) {
      // TODO: provide original command or command line?
      auto err = std::runtime_error(
          "register " + command[1].asString() + " had type '" +
          conditionDynamic.typeName() +
          "' but needs to be 'boolean' for conditionals");
      throw err;
    }
    const auto &nextCommands =
        conditionDynamic.asBool() ? command[2] : command[3];
    for (const auto &nextCommand : nextCommands) {
      runCommand(
          nextCommand,
          rootTag,
          nodes,
          registers,
          componentDescriptorRegistry,
          nativeModuleRegistry);
    }
  } else {
    throw std::runtime_error("Unsupported opcode: " + command[0].asString());
  }
  return nullptr;
}

SharedShadowNode ReactBytecodeInterpreter::buildShadowTree(
    const std::string &jsonStr,
    Tag rootTag,
    const folly::dynamic &params,
    const ComponentDescriptorRegistry &componentDescriptorRegistry,
    const NativeModuleRegistry &nativeModuleRegistry) {
  LOG(INFO)
      << "(strt) ReactBytecodeInterpreter inject hardcoded 'server rendered' view tree";
  std::string content = jsonStr;
  for (const auto &param : params.items()) {
    const auto &key = param.first.asString();
    size_t start_pos = content.find(key);
    if (start_pos != std::string::npos) {
      content.replace(start_pos, key.length(), param.second.asString());
    }
  }
  auto parsed = folly::parseJson(content);
  auto commands = parsed["commands"];
  std::vector<SharedShadowNode> nodes(commands.size() * 2);
  std::vector<folly::dynamic> registers(32);
  for (const auto &command : commands) {
    auto ret = runCommand(
        command,
        rootTag,
        nodes,
        registers,
        componentDescriptorRegistry,
        nativeModuleRegistry);
    if (ret != nullptr) {
      return ret;
    }
  }
  throw std::runtime_error(
      "Missing childSetNode command in template content:\n" + content);
  return SharedShadowNode{};
}

} // namespace react
} // namespace facebook