react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/jsi/React-jsi.podspec

@@ -23,7 +23,8 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
 
 Pod::Spec.new do |s|
   s.name                   = "React-jsi"
@@ -37,11 +38,15 @@ Pod::Spec.new do |s|
 
   s.header_dir    = "jsi"
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\"",
-                               "DEFINES_MODULE" => "YES" }
+  s.pod_target_xcconfig    = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fast_float/include\" \"$(PODS_ROOT)/fmt/include\"",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "DEFINES_MODULE" => "YES"
+  }
 
   s.dependency "boost"
   s.dependency "DoubleConversion"
+  s.dependency "fast_float", "6.1.4"
   s.dependency "fmt", "9.1.0"
   s.dependency "RCT-Folly", folly_version
   s.dependency "glog"

package/ReactCommon/jsi/jsi/decorator.h

@@ -225,6 +225,13 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_.utf8(s);
   }
 
+  std::u16string utf16(const String& str) override {
+    return plain_.utf16(str);
+  }
+  std::u16string utf16(const PropNameID& sym) override {
+    return plain_.utf16(sym);
+  }
+
   Object createObject() override {
     return plain_.createObject();
   };
@@ -674,6 +681,15 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::utf8(s);
   }
 
+  std::u16string utf16(const String& str) override {
+    Around around{with_};
+    return RD::utf16(str);
+  }
+  std::u16string utf16(const PropNameID& sym) override {
+    Around around{with_};
+    return RD::utf16(sym);
+  }
+
   Value createValueFromJsonUtf8(const uint8_t* json, size_t length) override {
     Around around{with_};
     return RD::createValueFromJsonUtf8(json, length);

package/ReactCommon/jsi/jsi/jsi.cpp

@@ -62,6 +62,107 @@ Value callGlobalFunction(Runtime& runtime, const char* name, const Value& arg) {
   return f.call(runtime, arg);
 }
 
+// Given a sequence of UTF8 encoded bytes, advance the input to past where a
+// 32-bit unicode codepoint as been decoded and return the codepoint. If the
+// UTF8 encoding is invalid, then return the value with the unicode replacement
+// character (U+FFFD). This decoder also relies on zero termination at end of
+// the input for bound checks.
+// \param input char pointer pointing to the current character
+// \return Unicode codepoint
+uint32_t decodeUTF8(const char*& input) {
+  uint32_t ch = (unsigned char)input[0];
+  if (ch <= 0x7f) {
+    input += 1;
+    return ch;
+  }
+  uint32_t ret;
+  constexpr uint32_t replacementCharacter = 0xFFFD;
+  if ((ch & 0xE0) == 0xC0) {
+    uint32_t ch1 = (unsigned char)input[1];
+    if ((ch1 & 0xC0) != 0x80) {
+      input += 1;
+      return replacementCharacter;
+    }
+    ret = ((ch & 0x1F) << 6) | (ch1 & 0x3F);
+    input += 2;
+    if (ret <= 0x7F) {
+      return replacementCharacter;
+    }
+  } else if ((ch & 0xF0) == 0xE0) {
+    uint32_t ch1 = (unsigned char)input[1];
+    if ((ch1 & 0x40) != 0 || (ch1 & 0x80) == 0) {
+      input += 1;
+      return replacementCharacter;
+    }
+    uint32_t ch2 = (unsigned char)input[2];
+    if ((ch2 & 0x40) != 0 || (ch2 & 0x80) == 0) {
+      input += 2;
+      return replacementCharacter;
+    }
+    ret = ((ch & 0x0F) << 12) | ((ch1 & 0x3F) << 6) | (ch2 & 0x3F);
+    input += 3;
+    if (ret <= 0x7FF) {
+      return replacementCharacter;
+    }
+  } else if ((ch & 0xF8) == 0xF0) {
+    uint32_t ch1 = (unsigned char)input[1];
+    if ((ch1 & 0x40) != 0 || (ch1 & 0x80) == 0) {
+      input += 1;
+      return replacementCharacter;
+    }
+    uint32_t ch2 = (unsigned char)input[2];
+    if ((ch2 & 0x40) != 0 || (ch2 & 0x80) == 0) {
+      input += 2;
+      return replacementCharacter;
+    }
+    uint32_t ch3 = (unsigned char)input[3];
+    if ((ch3 & 0x40) != 0 || (ch3 & 0x80) == 0) {
+      input += 3;
+      return replacementCharacter;
+    }
+    ret = ((ch & 0x07) << 18) | ((ch1 & 0x3F) << 12) | ((ch2 & 0x3F) << 6) |
+        (ch3 & 0x3F);
+    input += 4;
+    if (ret <= 0xFFFF) {
+      return replacementCharacter;
+    }
+    if (ret > 0x10FFFF) {
+      return replacementCharacter;
+    }
+  } else {
+    input += 1;
+    return replacementCharacter;
+  }
+  return ret;
+}
+
+// Given a valid 32-bit unicode codepoint, encode it as UTF-16 into the output.
+void encodeUTF16(std::u16string& out, uint32_t cp) {
+  if (cp < 0x10000) {
+    out.push_back((uint16_t)cp);
+    return;
+  }
+  cp -= 0x10000;
+  uint16_t highSurrogate = 0xD800 + ((cp >> 10) & 0x3FF);
+  out.push_back(highSurrogate);
+  uint16_t lowSurrogate = 0xDC00 + (cp & 0x3FF);
+  out.push_back(lowSurrogate);
+}
+
+// Convert the UTF8 encoded string into a UTF16 encoded string. If the
+// input is not valid UTF8, the replacement character (U+FFFD) is used to
+// represent the invalid sequence.
+std::u16string convertUTF8ToUTF16(const std::string& utf8) {
+  std::u16string ret;
+  const char* curr = utf8.data();
+  const char* end = curr + utf8.length();
+  while (curr < end) {
+    auto cp = decodeUTF8(curr);
+    encodeUTF16(ret, cp);
+  }
+  return ret;
+}
+
 } // namespace
 
 Buffer::~Buffer() = default;
@@ -147,7 +248,17 @@ Value Runtime::createValueFromJsonUtf8(const uint8_t* json, size_t length) {
   return parseJson.call(*this, String::createFromUtf8(*this, json, length));
 }
 
-Pointer& Pointer::operator=(Pointer&& other) {
+std::u16string Runtime::utf16(const PropNameID& sym) {
+  auto utf8Str = utf8(sym);
+  return convertUTF8ToUTF16(utf8Str);
+}
+
+std::u16string Runtime::utf16(const String& str) {
+  auto utf8Str = utf8(str);
+  return convertUTF8ToUTF16(utf8Str);
+}
+
+Pointer& Pointer::operator=(Pointer&& other) noexcept {
   if (ptr_) {
     ptr_->invalidate();
   }
@@ -222,7 +333,7 @@ Function Object::asFunction(Runtime& runtime) && {
   return std::move(*this).getFunction(runtime);
 }
 
-Value::Value(Value&& other) : Value(other.kind_) {
+Value::Value(Value&& other) noexcept : Value(other.kind_) {
   if (kind_ == BooleanKind) {
     data_.boolean = other.data_.boolean;
   } else if (kind_ == NumberKind) {

package/ReactCommon/jsi/jsi/jsi.h

@@ -288,7 +288,7 @@ class JSI_EXPORT Runtime {
   // rvalue arguments/methods would also reduce the number of clones.
 
   struct PointerValue {
-    virtual void invalidate() = 0;
+    virtual void invalidate() noexcept = 0;
 
    protected:
     virtual ~PointerValue() = default;
@@ -399,6 +399,9 @@ class JSI_EXPORT Runtime {
       const jsi::Object& obj,
       size_t amount) = 0;
 
+  virtual std::u16string utf16(const String& str);
+  virtual std::u16string utf16(const PropNameID& sym);
+
   // These exist so derived classes can access the private parts of
   // Value, Symbol, String, and Object, which are all friends of Runtime.
   template <typename T>
@@ -415,7 +418,7 @@ class JSI_EXPORT Runtime {
 // Base class for pointer-storing types.
 class JSI_EXPORT Pointer {
  protected:
-  explicit Pointer(Pointer&& other) : ptr_(other.ptr_) {
+  explicit Pointer(Pointer&& other) noexcept : ptr_(other.ptr_) {
     other.ptr_ = nullptr;
   }
 
@@ -425,7 +428,7 @@ class JSI_EXPORT Pointer {
     }
   }
 
-  Pointer& operator=(Pointer&& other);
+  Pointer& operator=(Pointer&& other) noexcept;
 
   friend class Runtime;
   friend class Value;
@@ -501,6 +504,11 @@ class JSI_EXPORT PropNameID : public Pointer {
     return runtime.utf8(*this);
   }
 
+  /// Copies the data in a PropNameID as utf16 into a C++ string.
+  std::u16string utf16(Runtime& runtime) const {
+    return runtime.utf16(*this);
+  }
+
   static bool compare(
       Runtime& runtime,
       const jsi::PropNameID& a,
@@ -651,6 +659,11 @@ class JSI_EXPORT String : public Pointer {
     return runtime.utf8(*this);
   }
 
+  /// Copies the data in a JS string as utf16 into a C++ string.
+  std::u16string utf16(Runtime& runtime) const {
+    return runtime.utf16(*this);
+  }
+
   friend class Runtime;
   friend class Value;
 };
@@ -1108,7 +1121,7 @@ class JSI_EXPORT Function : public Object {
 class JSI_EXPORT Value {
  public:
   /// Default ctor creates an \c undefined JS value.
-  Value() : Value(UndefinedKind) {}
+  Value() noexcept : Value(UndefinedKind) {}
 
   /// Creates a \c null JS value.
   /* implicit */ Value(std::nullptr_t) : kind_(NullKind) {}
@@ -1149,7 +1162,7 @@ class JSI_EXPORT Value {
         "Value cannot be constructed directly from const char*");
   }
 
-  Value(Value&& value);
+  Value(Value&& other) noexcept;
 
   /// Copies a Symbol lvalue into a new JS value.
   Value(Runtime& runtime, const Symbol& sym) : Value(SymbolKind) {
@@ -1204,7 +1217,7 @@ class JSI_EXPORT Value {
   /// https://262.ecma-international.org/11.0/#sec-strict-equality-comparison
   static bool strictEquals(Runtime& runtime, const Value& a, const Value& b);
 
-  Value& operator=(Value&& other) {
+  Value& operator=(Value&& other) noexcept {
     this->~Value();
     new (this) Value(std::move(other));
     return *this;

package/ReactCommon/jsi/jsi/test/testlib.cpp

@@ -1576,6 +1576,65 @@ TEST_P(JSITest, UTF8ExceptionTest) {
   }
 }
 
+TEST_P(JSITest, UTF16Test) {
+  // This Runtime Decorator is used to test the conversion from UTF-8 to UTF-16
+  // in the default utf16 method for runtimes that do not provide their own
+  // utf16 implementation.
+  class UTF16RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    UTF16RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    std::string utf8(const String&) override {
+      return utf8Str;
+    }
+
+    std::u16string utf16(const String& str) override {
+      return Runtime::utf16(str);
+    }
+
+    std::string utf8Str;
+  };
+
+  UTF16RD rd = UTF16RD(rt);
+  String str = String::createFromUtf8(rd, "placeholder");
+
+  rd.utf8Str = "foobar";
+  EXPECT_EQ(str.utf16(rd), u"foobar");
+
+  rd.utf8Str = "你好";
+  EXPECT_EQ(str.utf16(rd), u"你好");
+
+  rd.utf8Str = "👍";
+  EXPECT_EQ(str.utf16(rd), u"👍");
+
+  rd.utf8Str = "foobar👍你好";
+  EXPECT_EQ(str.utf16(rd), u"foobar👍你好");
+
+  // String ended before second byte of the encoding
+  rd.utf8Str = "\xcf";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD");
+
+  // Third byte should follow the pattern of 0b10xxxxxx
+  rd.utf8Str = "\xef\x8f\x29";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD\u0029");
+
+  // U+2200 should be encoded in 3 bytes as 0xE2 0x88 0x80, not 4 bytes
+  rd.utf8Str = "\xf0\x82\x88\x80";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD");
+
+  // Unicode Max Value is U+10FFFF, U+11FFFF is invalid
+  rd.utf8Str = "\xf4\x9f\xbf\xbf";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD");
+
+  // Missing the third byte of the 3-byte encoding, followed by 'z'
+  rd.utf8Str = "\xe1\xa0\x7a";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD\u007A");
+
+  // First byte is neither ASCII nor a valid continuation byte
+  rd.utf8Str = "\xea\x7a";
+  EXPECT_EQ(str.utf16(rd), u"\uFFFD\u007A");
+}
+
 INSTANTIATE_TEST_CASE_P(
     Runtimes,
     JSITest,

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -19,7 +19,8 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
 
 Pod::Spec.new do |s|
   s.name                   = "React-jsiexecutor"
@@ -32,7 +33,7 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files         = "jsireact/*.{cpp,h}"
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\"",
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fast_float/include\" \"$(PODS_ROOT)/fmt/include\"",
                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
   s.header_dir             = "jsireact"
 
@@ -41,6 +42,7 @@ Pod::Spec.new do |s|
   s.dependency "React-perflogger", version
   s.dependency "RCT-Folly", folly_version
   s.dependency "DoubleConversion"
+  s.dependency "fast_float", "6.1.4"
   s.dependency "fmt", "9.1.0"
   s.dependency "glog"
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -15,8 +15,6 @@
 
 #include <chrono>
 
-#include <reactperflogger/fusebox/FuseboxTracer.h>
-
 using namespace std::chrono;
 using namespace std::literals::string_view_literals;
 
@@ -36,7 +34,8 @@ HostAgent::HostAgent(
       targetController_(targetController),
       hostMetadata_(std::move(hostMetadata)),
       sessionState_(sessionState),
-      networkIOAgent_(NetworkIOAgent(frontendChannel, executor)) {}
+      networkIOAgent_(NetworkIOAgent(frontendChannel, std::move(executor))),
+      tracingAgent_(TracingAgent(frontendChannel)) {}
 
 void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
   bool shouldSendOKResponse = false;
@@ -149,43 +148,6 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
 
     shouldSendOKResponse = true;
     isFinishedHandlingRequest = true;
-  } else if (req.method == "Tracing.start") {
-    // @cdp Tracing.start support is experimental.
-    if (FuseboxTracer::getFuseboxTracer().startTracing()) {
-      shouldSendOKResponse = true;
-    } else {
-      frontendChannel_(cdp::jsonError(
-          req.id,
-          cdp::ErrorCode::InternalError,
-          "Tracing session already started"));
-      return;
-    }
-    isFinishedHandlingRequest = true;
-  } else if (req.method == "Tracing.end") {
-    // @cdp Tracing.end support is experimental.
-    bool firstChunk = true;
-    auto id = req.id;
-    bool wasStopped = FuseboxTracer::getFuseboxTracer().stopTracing(
-        [this, firstChunk, id](const folly::dynamic& eventsChunk) {
-          if (firstChunk) {
-            frontendChannel_(cdp::jsonResult(id));
-          }
-          frontendChannel_(cdp::jsonNotification(
-              "Tracing.dataCollected",
-              folly::dynamic::object("value", eventsChunk)));
-        });
-    if (!wasStopped) {
-      frontendChannel_(cdp::jsonError(
-          req.id,
-          cdp::ErrorCode::InternalError,
-          "Tracing session not started"));
-      return;
-    }
-    frontendChannel_(cdp::jsonNotification(
-        "Tracing.tracingComplete",
-        folly::dynamic::object("dataLossOccurred", false)));
-    shouldSendOKResponse = true;
-    isFinishedHandlingRequest = true;
   }
 
   if (!isFinishedHandlingRequest &&
@@ -193,6 +155,10 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
     return;
   }
 
+  if (!isFinishedHandlingRequest && tracingAgent_.handleRequest(req)) {
+    return;
+  }
+
   if (!isFinishedHandlingRequest && instanceAgent_ &&
       instanceAgent_->handleRequest(req)) {
     return;

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -11,6 +11,7 @@
 #include "HostTarget.h"
 #include "NetworkIOAgent.h"
 #include "SessionState.h"
+#include "TracingAgent.h"
 
 #include <jsinspector-modern/InspectorInterfaces.h>
 #include <jsinspector-modern/InstanceAgent.h>
@@ -77,7 +78,7 @@ class HostAgent final {
 
   /**
    * Send a simple Log.entryAdded notification with the given
-   * \param text. You must ensure that the frontend has enabled Log
+   * \param text . You must ensure that the frontend has enabled Log
    * notifications (using Log.enable) prior to calling this function. In Chrome
    * DevTools, the message will appear in the Console tab along with regular
    * console messages. The difference between Log.entryAdded and
@@ -110,6 +111,8 @@ class HostAgent final {
   SessionState& sessionState_;
 
   NetworkIOAgent networkIOAgent_;
+
+  TracingAgent tracingAgent_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -44,6 +44,8 @@ const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
           true,
 #elif defined(HERMES_ENABLE_DEBUGGER)
           ReactNativeFeatureFlags::fuseboxEnabledDebug(),
+#elif defined(REACT_NATIVE_ENABLE_FUSEBOX_RELEASE)
+          true,
 #else
           ReactNativeFeatureFlags::fuseboxEnabledRelease(),
 #endif

package/ReactCommon/jsinspector-modern/InspectorInterfaces.cpp

@@ -37,7 +37,7 @@ namespace {
 class InspectorImpl : public IInspector {
  public:
   int addPage(
-      const std::string& title,
+      const std::string& description,
       const std::string& vm,
       ConnectFunc connectFunc,
       InspectorTargetCapabilities capabilities) override;
@@ -66,7 +66,7 @@ class InspectorImpl : public IInspector {
 
    private:
     int id_;
-    std::string title_;
+    std::string description_;
     std::string vm_;
     ConnectFunc connectFunc_;
     InspectorTargetCapabilities capabilities_;
@@ -79,12 +79,12 @@ class InspectorImpl : public IInspector {
 
 InspectorImpl::Page::Page(
     int id,
-    const std::string& title,
+    const std::string& description,
     const std::string& vm,
     ConnectFunc connectFunc,
     InspectorTargetCapabilities capabilities)
     : id_(id),
-      title_(title),
+      description_(description),
       vm_(vm),
       connectFunc_(std::move(connectFunc)),
       capabilities_(std::move(capabilities)) {}
@@ -92,7 +92,7 @@ InspectorImpl::Page::Page(
 InspectorImpl::Page::operator InspectorPageDescription() const {
   return InspectorPageDescription{
       .id = id_,
-      .title = title_,
+      .description = description_,
       .vm = vm_,
       .capabilities = capabilities_,
   };
@@ -103,7 +103,7 @@ InspectorImpl::ConnectFunc InspectorImpl::Page::getConnectFunc() const {
 }
 
 int InspectorImpl::addPage(
-    const std::string& title,
+    const std::string& description,
     const std::string& vm,
     ConnectFunc connectFunc,
     InspectorTargetCapabilities capabilities) {
@@ -114,7 +114,8 @@ int InspectorImpl::addPage(
   int pageId = nextPageId_++;
   assert(pages_.count(pageId) == 0 && "Unexpected duplicate page ID");
   pages_.emplace(
-      pageId, Page{pageId, title, vm, std::move(connectFunc), capabilities});
+      pageId,
+      Page{pageId, description, vm, std::move(connectFunc), capabilities});
 
   return pageId;
 }

package/ReactCommon/jsinspector-modern/InspectorInterfaces.h

@@ -44,7 +44,7 @@ const folly::dynamic targetCapabilitiesToDynamic(
 
 struct InspectorPageDescription {
   const int id;
-  const std::string title;
+  const std::string description;
   const std::string vm;
   const InspectorTargetCapabilities capabilities;
 };
@@ -100,7 +100,7 @@ class JSINSPECTOR_EXPORT IInspector : public IDestructible {
    * \returns the ID assigned to the new page.
    */
   virtual int addPage(
-      const std::string& title,
+      const std::string& description,
       const std::string& vm,
       ConnectFunc connectFunc,
       InspectorTargetCapabilities capabilities = {}) = 0;

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -28,21 +28,25 @@ static constexpr const char* INVALID = "<invalid>";
 std::shared_ptr<InspectorPackagerConnection::Impl>
 InspectorPackagerConnection::Impl::create(
     std::string url,
-    std::string app,
+    std::string deviceName,
+    std::string appName,
     std::unique_ptr<InspectorPackagerConnectionDelegate> delegate) {
   // No make_shared because the constructor is private
   std::shared_ptr<InspectorPackagerConnection::Impl> impl(
-      new InspectorPackagerConnection::Impl(url, app, std::move(delegate)));
+      new InspectorPackagerConnection::Impl(
+          url, deviceName, appName, std::move(delegate)));
   getInspectorInstance().registerPageStatusListener(impl);
   return impl;
 }
 
 InspectorPackagerConnection::Impl::Impl(
     std::string url,
-    std::string app,
+    std::string deviceName,
+    std::string appName,
     std::unique_ptr<InspectorPackagerConnectionDelegate> delegate)
     : url_(std::move(url)),
-      app_(std::move(app)),
+      deviceName_(std::move(deviceName)),
+      appName_(std::move(appName)),
       delegate_(std::move(delegate)) {}
 
 void InspectorPackagerConnection::Impl::handleProxyMessage(
@@ -159,8 +163,9 @@ folly::dynamic InspectorPackagerConnection::Impl::pages() {
   for (const auto& page : pages) {
     folly::dynamic pageDescription = folly::dynamic::object;
     pageDescription["id"] = std::to_string(page.id);
-    pageDescription["title"] = page.title + " [C++ connection]";
-    pageDescription["app"] = app_;
+    pageDescription["title"] = appName_ + " (" + deviceName_ + ")";
+    pageDescription["description"] = page.description + " [C++ connection]";
+    pageDescription["app"] = appName_;
     pageDescription["capabilities"] =
         targetCapabilitiesToDynamic(page.capabilities);
 
@@ -175,7 +180,7 @@ void InspectorPackagerConnection::Impl::didFailWithError(
   if (webSocket_) {
     abort(posixCode, "WebSocket exception", error);
   }
-  if (!closed_ && posixCode != ECONNREFUSED) {
+  if (!closed_) {
     reconnect();
   }
 }
@@ -244,6 +249,10 @@ void InspectorPackagerConnection::Impl::reconnect() {
         if (strongSelf && !strongSelf->closed_) {
           strongSelf->reconnectPending_ = false;
           strongSelf->connect();
+
+          if (!strongSelf->isConnected()) {
+            strongSelf->reconnect();
+          }
         }
       },
       RECONNECT_DELAY);
@@ -341,9 +350,10 @@ void InspectorPackagerConnection::Impl::RemoteConnection::onDisconnect() {
 
 InspectorPackagerConnection::InspectorPackagerConnection(
     std::string url,
-    std::string app,
+    std::string deviceName,
+    std::string appName,
     std::unique_ptr<InspectorPackagerConnectionDelegate> delegate)
-    : impl_(Impl::create(url, app, std::move(delegate))) {}
+    : impl_(Impl::create(url, deviceName, appName, std::move(delegate))) {}
 
 bool InspectorPackagerConnection::isConnected() const {
   return impl_->isConnected();

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.h

@@ -33,13 +33,15 @@ class InspectorPackagerConnection {
    * Creates a new connection instance. Connections start in the disconnected
    * state; connect() should be called to establish a connection.
    * \param url The WebSocket URL where the inspector-proxy server is listening.
-   * \param app The name of the application being debugged.
+   * \param deviceName The host device name.
+   * \param appName The application name.
    * \param delegate An interface to platform-specific methods for creating a
    * WebSocket, scheduling async work, etc.
    */
   InspectorPackagerConnection(
       std::string url,
-      std::string app,
+      std::string deviceName,
+      std::string appName,
       std::unique_ptr<InspectorPackagerConnectionDelegate> delegate);
   bool isConnected() const;
   void connect();

package/ReactCommon/jsinspector-modern/InspectorPackagerConnectionImpl.h

@@ -31,7 +31,8 @@ class InspectorPackagerConnection::Impl
    */
   static std::shared_ptr<Impl> create(
       std::string url,
-      std::string app,
+      std::string deviceName,
+      std::string appName,
       std::unique_ptr<InspectorPackagerConnectionDelegate> delegate);
 
   // InspectorPackagerConnection's public API
@@ -61,7 +62,8 @@ class InspectorPackagerConnection::Impl
 
   Impl(
       std::string url,
-      std::string app,
+      std::string deviceName,
+      std::string appName,
       std::unique_ptr<InspectorPackagerConnectionDelegate> delegate);
   Impl(const Impl&) = delete;
   Impl& operator=(const Impl&) = delete;
@@ -91,7 +93,8 @@ class InspectorPackagerConnection::Impl
   virtual void onPageRemoved(int pageId) override;
 
   const std::string url_;
-  const std::string app_;
+  const std::string deviceName_;
+  const std::string appName_;
   const std::unique_ptr<InspectorPackagerConnectionDelegate> delegate_;
 
   std::unordered_map<std::string, Session> inspectorSessions_;