react-native-windows 0.74.35 → 0.74.37

package/Shared/Networking/WinRTWebSocketResource.cpp

@@ -21,16 +21,18 @@
 
 using Microsoft::Common::Utilities::CheckedReinterpretCast;
 
+using Mso::DispatchQueue;
+
 using std::function;
 using std::lock_guard;
 using std::mutex;
-using std::size_t;
 using std::string;
 using std::vector;
 
 using winrt::fire_and_forget;
 using winrt::hresult;
 using winrt::hresult_error;
+using winrt::hstring;
 using winrt::resume_background;
 using winrt::resume_on_signal;
 using winrt::Windows::Foundation::IAsyncAction;
@@ -38,6 +40,7 @@ using winrt::Windows::Foundation::Uri;
 using winrt::Windows::Networking::Sockets::IMessageWebSocket;
 using winrt::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs;
 using winrt::Windows::Networking::Sockets::IWebSocket;
+using winrt::Windows::Networking::Sockets::IWebSocketClosedEventArgs;
 using winrt::Windows::Networking::Sockets::MessageWebSocket;
 using winrt::Windows::Networking::Sockets::SocketMessageType;
 using winrt::Windows::Networking::Sockets::WebSocketClosedEventArgs;
@@ -54,9 +57,9 @@ namespace {
 ///
 /// Implements an awaiter for Mso::DispatchQueue
 ///
-auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
+auto resume_in_queue(const DispatchQueue &queue) noexcept {
   struct awaitable {
-    awaitable(const Mso::DispatchQueue &queue) noexcept : m_queue{queue} {}
+    awaitable(const DispatchQueue &queue) noexcept : m_queue{queue} {}
 
     bool await_ready() const noexcept {
       return false;
@@ -79,10 +82,367 @@ auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
   return awaitable{queue};
 } // resume_in_queue
 
+DispatchQueue GetCurrentOrSerialQueue() noexcept {
+  auto queue = DispatchQueue::CurrentQueue();
+  if (!queue)
+    queue = DispatchQueue::MakeSerialQueue();
+
+  return queue;
+}
+
 } // namespace
 
 namespace Microsoft::React::Networking {
 
+#pragma region WinRTWebSocketResource2
+
+WinRTWebSocketResource2::WinRTWebSocketResource2(
+    IMessageWebSocket &&socket,
+    IDataWriter &&writer,
+    vector<ChainValidationResult> &&certExceptions,
+    DispatchQueue callingQueue)
+    : m_socket{std::move(socket)},
+      m_writer(std::move(writer)),
+      m_readyState{ReadyState::Connecting},
+      m_connectPerformed{CreateEvent(/*attributes*/ nullptr, /*manual reset*/ true, /*state*/ false, /*name*/ nullptr)},
+      m_callingQueue{callingQueue} {
+  for (const auto &certException : certExceptions) {
+    m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
+  }
+}
+
+// private
+WinRTWebSocketResource2::WinRTWebSocketResource2(
+    IMessageWebSocket &&socket,
+    vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource2(
+          std::move(socket),
+          DataWriter{socket.OutputStream()},
+          std::move(certExceptions),
+          GetCurrentOrSerialQueue()) {}
+
+WinRTWebSocketResource2::WinRTWebSocketResource2(vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource2(MessageWebSocket{}, std::move(certExceptions)) {}
+
+WinRTWebSocketResource2::~WinRTWebSocketResource2() noexcept /*override*/
+{}
+
+void WinRTWebSocketResource2::Fail(string &&message, ErrorType type) noexcept {
+  auto self = shared_from_this();
+
+  self->m_backgroundQueue.Post([self, message = std::move(message), type]() {
+    self->m_readyState = ReadyState::Closed;
+    self->m_callingQueue.Post([self, message = std::move(message), type]() {
+      if (self->m_errorHandler) {
+        self->m_errorHandler({std::move(message), type});
+      }
+    });
+  });
+}
+
+void WinRTWebSocketResource2::Fail(hresult &&error, ErrorType type) noexcept {
+  Fail(Utilities::HResultToString(std::move(error)), type);
+}
+
+void WinRTWebSocketResource2::Fail(hresult_error const &error, ErrorType type) noexcept {
+  Fail(Utilities::HResultToString(error), type);
+}
+
+void WinRTWebSocketResource2::OnMessageReceived(
+    IMessageWebSocket const &,
+    IMessageWebSocketMessageReceivedEventArgs const &args) {
+  auto self = shared_from_this();
+  string response;
+
+  IDataReader reader{nullptr};
+  // Use WinRT ABI to avoid throwing exceptions on expected code paths
+  HRESULT hr =
+      reinterpret_cast<ABI::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs *>(
+          winrt::get_abi(args))
+          ->GetDataReader(reinterpret_cast<ABI::Windows::Storage::Streams::IDataReader **>(winrt::put_abi(reader)));
+
+  if (FAILED(hr)) {
+    string errorMessage;
+    ErrorType errorType;
+    // See
+    // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-22621#remarks
+    if (hr == WININET_E_CONNECTION_ABORTED) {
+      errorMessage = "[0x80072EFE] Underlying TCP connection suddenly terminated";
+      errorType = ErrorType::Connection;
+      // Note: It is not clear whether all read-related errors should close the socket.
+      Close(CloseCode::BadPayload, std::move(errorMessage));
+    } else {
+      errorMessage = Utilities::HResultToString(hr);
+      errorType = ErrorType::Receive;
+    }
+
+    self->Fail(std::move(errorMessage), errorType);
+
+    return;
+  }
+
+  try {
+    auto len = reader.UnconsumedBufferLength();
+    if (args.MessageType() == SocketMessageType::Utf8) {
+      reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      vector<uint8_t> data(len);
+      reader.ReadBytes(data);
+
+      response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
+    } else {
+      auto buffer = reader.ReadBuffer(len);
+      auto data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+      response = winrt::to_string(std::wstring_view(data));
+    }
+  } catch (hresult_error const &e) {
+    return self->Fail(e, ErrorType::Receive);
+  }
+
+  // Posting inside try-catch block causes errors.
+  self->m_callingQueue.Post([self, response = std::move(response), messageType = args.MessageType()]() {
+    if (self->m_readHandler) {
+      self->m_readHandler(response.length(), response, messageType == SocketMessageType::Binary);
+    }
+  });
+}
+
+void WinRTWebSocketResource2::OnClosed(IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
+  auto self = shared_from_this();
+
+  self->m_backgroundQueue.Post([self]() { self->m_readyState = ReadyState::Closed; });
+
+  self->m_callingQueue.Post([self]() {
+    if (self->m_closeHandler) {
+      self->m_closeHandler(self->m_closeCode, self->m_closeReason);
+    }
+  });
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformConnect(Uri &&uri) noexcept {
+  auto self = shared_from_this();
+  auto coUri = std::move(uri);
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  auto async = self->m_socket.ConnectAsync(coUri);
+  co_await lessthrow_await_adapter<IAsyncAction>{async};
+
+  co_await resume_in_queue(self->m_callingQueue);
+
+  auto result = async.ErrorCode();
+
+  try {
+    if (result >= 0) { // Non-failing HRESULT
+      co_await resume_in_queue(self->m_backgroundQueue);
+      self->m_readyState = ReadyState::Open;
+
+      co_await resume_in_queue(self->m_callingQueue);
+      if (self->m_connectHandler) {
+        self->m_connectHandler();
+      }
+    } else {
+      self->Fail(std::move(result), ErrorType::Connection);
+    }
+  } catch (hresult_error const &e) {
+    self->Fail(e, ErrorType::Connection);
+  } catch (std::exception const &e) {
+    self->Fail(e.what(), ErrorType::Connection);
+  }
+
+  SetEvent(self->m_connectPerformed.get());
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformClose() noexcept {
+  auto self = shared_from_this();
+
+  co_await resume_on_signal(self->m_connectPerformed.get());
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  // See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+  co_await self->SendPendingMessages();
+
+  try {
+    self->m_socket.Close(static_cast<uint16_t>(m_closeCode), winrt::to_hstring(m_closeReason));
+    self->m_readyState = ReadyState::Closing;
+  } catch (winrt::hresult_invalid_argument const &e) {
+    Fail(e, ErrorType::Close);
+  } catch (hresult_error const &e) {
+    Fail(e, ErrorType::Close);
+  } catch (const std::exception &e) {
+    Fail(e.what(), ErrorType::Close);
+  }
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformWrite(string &&message, bool isBinary) noexcept {
+  auto self = shared_from_this();
+  string coMessage = std::move(message);
+
+  co_await resume_in_queue(self->m_backgroundQueue); // Ensure writes happen sequentially
+  self->m_outgoingMessages.emplace(std::move(coMessage), isBinary);
+
+  co_await resume_on_signal(self->m_connectPerformed.get());
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  co_await self->SendPendingMessages();
+}
+
+IAsyncAction WinRTWebSocketResource2::SendPendingMessages() noexcept {
+  auto self = shared_from_this();
+
+  while (!self->m_outgoingMessages.empty()) {
+    if (self->m_readyState != ReadyState::Open) {
+      co_return;
+    }
+
+    size_t length = 0;
+    string messageLocal;
+    bool isBinaryLocal;
+    try {
+      std::tie(messageLocal, isBinaryLocal) = self->m_outgoingMessages.front();
+      self->m_outgoingMessages.pop();
+      if (isBinaryLocal) {
+        self->m_socket.Control().MessageType(SocketMessageType::Binary);
+
+        auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(messageLocal));
+        if (buffer) {
+          length = buffer.Length();
+          self->m_writer.WriteBuffer(buffer);
+        }
+      } else {
+        self->m_socket.Control().MessageType(SocketMessageType::Utf8);
+
+        length = messageLocal.size();
+        winrt::array_view<const uint8_t> view(
+            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()),
+            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()) + messageLocal.length());
+        self->m_writer.WriteBytes(view);
+      }
+    } catch (hresult_error const &e) { // TODO: Remove after fixing unit tests exceptions.
+      self->Fail(e, ErrorType::Send);
+      co_return;
+    } catch (const std::exception &e) {
+      self->Fail(e.what(), ErrorType::Send);
+      co_return;
+    }
+
+    auto async = self->m_writer.StoreAsync();
+    co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
+
+    auto result = async.ErrorCode();
+    if (result < 0) {
+      Fail(std::move(result), ErrorType::Send);
+    }
+  }
+}
+
+#pragma region IWebSocketResource
+
+void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
+  // Register MessageReceived BEFORE calling Connect
+  // https://learn.microsoft.com/en-us/uwp/api/windows.networking.sockets.messagewebsocket.messagereceived?view=winrt-22621
+  m_socket.MessageReceived([self = shared_from_this()](
+                               IMessageWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
+    self->OnMessageReceived(sender, args);
+  });
+
+  m_socket.Closed([self = shared_from_this()](IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
+    self->OnClosed(sender, args);
+  });
+
+  auto supportedProtocols = m_socket.Control().SupportedProtocols();
+  for (const auto &protocol : protocols) {
+    supportedProtocols.Append(winrt::to_hstring(protocol));
+  }
+
+  Uri uri{nullptr};
+  bool hasOriginHeader{false};
+  try {
+    uri = Uri{winrt::to_hstring(url)};
+
+    for (const auto &header : options) {
+      m_socket.SetRequestHeader(header.first, winrt::to_hstring(header.second));
+      if (boost::iequals(header.first, L"Origin")) {
+        hasOriginHeader = true;
+      }
+    }
+
+    // #12626 - If Origin header is not provided, set to connect endpoint.
+    if (!hasOriginHeader) {
+      auto scheme = uri.SchemeName();
+      auto host = uri.Host();
+      auto port = uri.Port();
+
+      if (scheme == L"ws") {
+        scheme = L"http";
+      } else if (scheme == L"wss") {
+        scheme = L"https";
+      }
+
+      // Only add a port if a port is defined.
+      hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
+      auto origin = hstring{scheme + L"://" + host + originPort};
+
+      m_socket.SetRequestHeader(L"Origin", std::move(origin));
+    }
+  } catch (hresult_error const &e) {
+    Fail(e, ErrorType::Connection);
+
+    SetEvent(m_connectPerformed.get());
+
+    return;
+  }
+
+  PerformConnect(std::move(uri));
+}
+
+void WinRTWebSocketResource2::Ping() noexcept {}
+
+void WinRTWebSocketResource2::Send(string &&message) noexcept {
+  PerformWrite(std::move(message), false);
+}
+
+void WinRTWebSocketResource2::SendBinary(string &&base64String) noexcept {
+  PerformWrite(std::move(base64String), true);
+}
+
+void WinRTWebSocketResource2::Close(CloseCode code, const string &reason) noexcept {
+  m_closeCode = code;
+  m_closeReason = reason;
+  PerformClose();
+}
+
+IWebSocketResource::ReadyState WinRTWebSocketResource2::GetReadyState() const noexcept {
+  return m_readyState;
+}
+
+void WinRTWebSocketResource2::SetOnConnect(function<void()> &&handler) noexcept {
+  m_connectHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnPing(function<void()> && /*handler*/) noexcept {}
+
+void WinRTWebSocketResource2::SetOnSend(function<void(size_t)> && /*handler*/) noexcept {}
+
+void WinRTWebSocketResource2::SetOnMessage(function<void(size_t, const string &, bool isBinary)> &&handler) noexcept {
+  m_readHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnClose(function<void(CloseCode, const string &)> &&handler) noexcept {
+  m_closeHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnError(function<void(Error &&)> &&handler) noexcept {
+  m_errorHandler = std::move(handler);
+}
+
+#pragma endregion IWebSocketResource
+
+#pragma endregion WinRTWebSocketResource2
+
+#pragma region Legacy resource
 // private
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
@@ -331,7 +691,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
         response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
       } else {
         auto buffer = reader.ReadBuffer(len);
-        winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
+        hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
 
         response = winrt::to_string(std::wstring_view(data));
       }
@@ -360,7 +720,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
     }
   }
 
-  winrt::Windows::Foundation::Collections::IVector<winrt::hstring> supportedProtocols =
+  winrt::Windows::Foundation::Collections::IVector<hstring> supportedProtocols =
       m_socket.Control().SupportedProtocols();
   for (const auto &protocol : protocols) {
     supportedProtocols.Append(winrt::to_hstring(protocol));
@@ -382,7 +742,10 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
         scheme = L"https";
       }
 
-      auto origin = winrt::hstring{scheme + L"://" + host + L":" + winrt::to_hstring(port)};
+      // Only add a port if a port is defined
+      hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
+      auto origin = hstring{scheme + L"://" + host + originPort};
+
       m_socket.SetRequestHeader(L"Origin", std::move(origin));
     }
 
@@ -458,4 +821,6 @@ void WinRTWebSocketResource::SetOnError(function<void(Error &&)> &&handler) noex
 
 #pragma endregion IWebSocketResource
 
+#pragma endregion Legacy resource
+
 } // namespace Microsoft::React::Networking

package/Shared/Networking/WinRTWebSocketResource.h

@@ -16,6 +16,124 @@
 
 namespace Microsoft::React::Networking {
 
+class WinRTWebSocketResource2 : public IWebSocketResource,
+                                public std::enable_shared_from_this<WinRTWebSocketResource2> {
+  winrt::Windows::Networking::Sockets::IMessageWebSocket m_socket;
+
+  ///
+  // Connection attempt performed, either succeeding or failing
+  ///
+  winrt::handle m_connectPerformed;
+
+  ReadyState m_readyState;
+  Mso::DispatchQueue m_callingQueue;
+  Mso::DispatchQueue m_backgroundQueue;
+  std::queue<std::pair<std::string, bool>> m_outgoingMessages;
+  CloseCode m_closeCode{CloseCode::Normal};
+  std::string m_closeReason;
+
+  std::function<void()> m_connectHandler;
+  std::function<void(std::size_t, const std::string &, bool)> m_readHandler;
+  std::function<void(CloseCode, const std::string &)> m_closeHandler;
+  std::function<void(Error &&)> m_errorHandler;
+
+  winrt::Windows::Storage::Streams::IDataWriter m_writer;
+
+  void Fail(std::string &&message, ErrorType type) noexcept;
+  void Fail(winrt::hresult &&e, ErrorType type) noexcept;
+  void Fail(winrt::hresult_error const &e, ErrorType type) noexcept;
+
+  void OnMessageReceived(
+      winrt::Windows::Networking::Sockets::IMessageWebSocket const &,
+      winrt::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs const &args);
+
+  void OnClosed(
+      winrt::Windows::Networking::Sockets::IWebSocket const &,
+      winrt::Windows::Networking::Sockets::IWebSocketClosedEventArgs const &args);
+
+  winrt::fire_and_forget PerformConnect(winrt::Windows::Foundation::Uri &&uri) noexcept;
+  winrt::fire_and_forget PerformWrite(std::string &&message, bool isBinary) noexcept;
+  winrt::fire_and_forget PerformClose() noexcept;
+  winrt::Windows::Foundation::IAsyncAction SendPendingMessages() noexcept;
+
+  WinRTWebSocketResource2(
+      winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
+      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
+
+ public:
+  WinRTWebSocketResource2(
+      winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
+      winrt::Windows::Storage::Streams::IDataWriter &&writer,
+      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions,
+      Mso::DispatchQueue callingQueue);
+
+  WinRTWebSocketResource2(
+      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
+
+  ~WinRTWebSocketResource2() noexcept override;
+
+#pragma region IWebSocketResource
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::Connect" />
+  /// </summary>
+  void Connect(std::string &&url, const Protocols &protocols, const Options &options) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::Ping" />
+  /// </summary>
+  void Ping() noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::Send" />
+  /// </summary>
+  void Send(std::string &&message) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SendBinary" />
+  /// </summary>
+  void SendBinary(std::string &&base64String) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::Close" />
+  /// </summary>
+  void Close(CloseCode code, const std::string &reason) noexcept override;
+
+  ReadyState GetReadyState() const noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnConnect" />
+  /// </summary>
+  void SetOnConnect(std::function<void()> &&handler) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnPing" />
+  /// </summary>
+  void SetOnPing(std::function<void()> &&handler) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnSend" />
+  /// </summary>
+  void SetOnSend(std::function<void(std::size_t)> &&handler) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnMessage" />
+  /// </summary>
+  void SetOnMessage(std::function<void(std::size_t, const std::string &, bool isBinary)> &&handler) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnClose" />
+  /// </summary>
+  void SetOnClose(std::function<void(CloseCode, const std::string &)> &&handler) noexcept override;
+
+  /// <summary>
+  /// <see cref="IWebSocketResource::SetOnError" />
+  /// </summary>
+  void SetOnError(std::function<void(Error &&)> &&handler) noexcept override;
+
+#pragma endregion IWebSocketResource
+};
+
 class WinRTWebSocketResource : public IWebSocketResource, public std::enable_shared_from_this<WinRTWebSocketResource> {
   winrt::Windows::Networking::Sockets::IMessageWebSocket m_socket;
   // TODO: Use or remove.

package/codegen/react/components/rnwcore/ActivityIndicatorView.g.h

@@ -147,7 +147,7 @@ void RegisterActivityIndicatorViewNativeComponent(
           userData->UpdateEventEmitter(std::make_shared<ActivityIndicatorViewEventEmitter>(eventEmitter));
         });
 
-        if constexpr (&TUserData::FinalizeUpdate != &BaseActivityIndicatorView<TUserData>::FinalizeUpdate) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::FinalizeUpdate != &BaseActivityIndicatorView<TUserData>::FinalizeUpdate) {
             builder.SetFinalizeUpdateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                      winrt::Microsoft::ReactNative::ComponentViewUpdateMask mask) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -155,7 +155,7 @@ void RegisterActivityIndicatorViewNativeComponent(
           });
         } 
 
-        if constexpr (&TUserData::UpdateState != &BaseActivityIndicatorView<TUserData>::UpdateState) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::UpdateState != &BaseActivityIndicatorView<TUserData>::UpdateState) {
           builder.SetUpdateStateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                      const winrt::Microsoft::ReactNative::IComponentState &newState) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -163,7 +163,7 @@ void RegisterActivityIndicatorViewNativeComponent(
           });
         }
 
-        if constexpr (&TUserData::MountChildComponentView != &BaseActivityIndicatorView<TUserData>::MountChildComponentView) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::MountChildComponentView != &BaseActivityIndicatorView<TUserData>::MountChildComponentView) {
           builder.SetMountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                       const winrt::Microsoft::ReactNative::MountChildComponentViewArgs &args) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -171,7 +171,7 @@ void RegisterActivityIndicatorViewNativeComponent(
           });
         }
 
-        if constexpr (&TUserData::UnmountChildComponentView != &BaseActivityIndicatorView<TUserData>::UnmountChildComponentView) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::UnmountChildComponentView != &BaseActivityIndicatorView<TUserData>::UnmountChildComponentView) {
           builder.SetUnmountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                       const winrt::Microsoft::ReactNative::UnmountChildComponentViewArgs &args) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -181,13 +181,13 @@ void RegisterActivityIndicatorViewNativeComponent(
 
         compBuilder.SetViewComponentViewInitializer([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
           auto userData = winrt::make_self<TUserData>();
-          if constexpr (&TUserData::Initialize != &BaseActivityIndicatorView<TUserData>::Initialize) {
+          if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::Initialize != &BaseActivityIndicatorView<TUserData>::Initialize) {
             userData->Initialize(view);
           }
           view.UserData(*userData);
         });
 
-        if constexpr (&TUserData::CreateVisual != &BaseActivityIndicatorView<TUserData>::CreateVisual) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::CreateVisual != &BaseActivityIndicatorView<TUserData>::CreateVisual) {
           compBuilder.SetCreateVisualHandler([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
             auto userData = view.UserData().as<TUserData>();
             return userData->CreateVisual(view);

package/codegen/react/components/rnwcore/AndroidDrawerLayout.g.h

@@ -224,7 +224,7 @@ void RegisterAndroidDrawerLayoutNativeComponent(
           userData->UpdateEventEmitter(std::make_shared<AndroidDrawerLayoutEventEmitter>(eventEmitter));
         });
 
-        if constexpr (&TUserData::FinalizeUpdate != &BaseAndroidDrawerLayout<TUserData>::FinalizeUpdate) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::FinalizeUpdate != &BaseAndroidDrawerLayout<TUserData>::FinalizeUpdate) {
             builder.SetFinalizeUpdateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                      winrt::Microsoft::ReactNative::ComponentViewUpdateMask mask) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -232,7 +232,7 @@ void RegisterAndroidDrawerLayoutNativeComponent(
           });
         } 
 
-        if constexpr (&TUserData::UpdateState != &BaseAndroidDrawerLayout<TUserData>::UpdateState) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::UpdateState != &BaseAndroidDrawerLayout<TUserData>::UpdateState) {
           builder.SetUpdateStateHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                      const winrt::Microsoft::ReactNative::IComponentState &newState) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -246,7 +246,7 @@ void RegisterAndroidDrawerLayoutNativeComponent(
           userData->HandleCommand(view, args);
         });
 
-        if constexpr (&TUserData::MountChildComponentView != &BaseAndroidDrawerLayout<TUserData>::MountChildComponentView) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::MountChildComponentView != &BaseAndroidDrawerLayout<TUserData>::MountChildComponentView) {
           builder.SetMountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                       const winrt::Microsoft::ReactNative::MountChildComponentViewArgs &args) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -254,7 +254,7 @@ void RegisterAndroidDrawerLayoutNativeComponent(
           });
         }
 
-        if constexpr (&TUserData::UnmountChildComponentView != &BaseAndroidDrawerLayout<TUserData>::UnmountChildComponentView) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::UnmountChildComponentView != &BaseAndroidDrawerLayout<TUserData>::UnmountChildComponentView) {
           builder.SetUnmountChildComponentViewHandler([](const winrt::Microsoft::ReactNative::ComponentView &view,
                                       const winrt::Microsoft::ReactNative::UnmountChildComponentViewArgs &args) noexcept {
             auto userData = view.UserData().as<TUserData>();
@@ -264,13 +264,13 @@ void RegisterAndroidDrawerLayoutNativeComponent(
 
         compBuilder.SetViewComponentViewInitializer([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
           auto userData = winrt::make_self<TUserData>();
-          if constexpr (&TUserData::Initialize != &BaseAndroidDrawerLayout<TUserData>::Initialize) {
+          if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::Initialize != &BaseAndroidDrawerLayout<TUserData>::Initialize) {
             userData->Initialize(view);
           }
           view.UserData(*userData);
         });
 
-        if constexpr (&TUserData::CreateVisual != &BaseAndroidDrawerLayout<TUserData>::CreateVisual) {
+        if CONSTEXPR_SUPPORTED_ON_VIRTUAL_FN_ADDRESS (&TUserData::CreateVisual != &BaseAndroidDrawerLayout<TUserData>::CreateVisual) {
           compBuilder.SetCreateVisualHandler([](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
             auto userData = view.UserData().as<TUserData>();
             return userData->CreateVisual(view);