Skip to content

Commit 6d30954

Browse files
coadometa-codesync[bot]
coado
authored and
meta-codesync[bot]
committed
Move renderer color parsing out of headers (#58521)
Summary: Pull Request resolved: #58521 Move shared and platform-specific Graphics color-parsing implementations from exported headers into owned source files across generic C++, Android, Apple, and Windows targets. Preserve the existing public entry points and parsing behavior. Update Buck source selection so default configurations link the generic C++ parser, and keep the React Native macOS and Windows mirrors synchronized. Changelog: [Internal] Reviewed By: javache Differential Revision: D119500849 fbshipit-source-id: 97dcbe2efd9434e39e6cdafd67b68c55ef62b6f3
1 parent 3d3f919 commit 6d30954

7 files changed

Lines changed: 235 additions & 168 deletions

File tree

‎packages/react-native/ReactCommon/react/renderer/graphics/fromRawValueShared.cpp‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
/*
2+
* Copyright (c) Meta Platforms, Inc. and affiliates.
3+
*
4+
* This source code is licensed under the MIT license found in the
5+
* LICENSE file in the root directory of this source tree.
6+
*/
7+
8+
#include <react/renderer/graphics/fromRawValueShared.h>
9+
10+
#include <react/debug/react_native_expect.h>
11+
#include <react/featureflags/ReactNativeFeatureFlags.h>
12+
#include <react/renderer/css/CSSColor.h>
13+
#include <react/renderer/css/CSSValueParser.h>
14+
15+
namespace facebook::react {
16+
17+
void fromRawValueShared(
18+
const ContextContainer& contextContainer,
19+
int32_t surfaceId,
20+
const RawValue& value,
21+
SharedColor& result,
22+
parsePlatformColorFn parsePlatformColor) {
23+
ColorComponents colorComponents = {
24+
.red = 0, .green = 0, .blue = 0, .alpha = 0};
25+
26+
if (ReactNativeFeatureFlags::enableNativeCSSParsing() &&
27+
value.hasType<std::string>()) {
28+
auto cssColor = parseCSSProperty<CSSColor>((std::string)value);
29+
if (std::holds_alternative<CSSColor>(cssColor)) {
30+
auto c = std::get<CSSColor>(cssColor);
31+
result = hostPlatformColorFromRGBA(c.r, c.g, c.b, c.a);
32+
return;
33+
}
34+
// Unparseable string - fall through to parsePlatformColor
35+
result = parsePlatformColor(contextContainer, surfaceId, value);
36+
} else if (value.hasType<int>()) {
37+
auto argb = (int64_t)value;
38+
auto ratio = 255.f;
39+
colorComponents.alpha = ((argb >> 24) & 0xFF) / ratio;
40+
colorComponents.red = ((argb >> 16) & 0xFF) / ratio;
41+
colorComponents.green = ((argb >> 8) & 0xFF) / ratio;
42+
colorComponents.blue = (argb & 0xFF) / ratio;
43+
44+
result = colorFromComponents(colorComponents);
45+
} else if (value.hasType<std::vector<float>>()) {
46+
auto items = (std::vector<float>)value;
47+
auto length = items.size();
48+
react_native_expect(length == 3 || length == 4);
49+
colorComponents.red = items.at(0);
50+
colorComponents.green = items.at(1);
51+
colorComponents.blue = items.at(2);
52+
colorComponents.alpha = length == 4 ? items.at(3) : 1.0f;
53+
54+
result = colorFromComponents(colorComponents);
55+
} else {
56+
if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
57+
const auto& items = (std::unordered_map<std::string, RawValue>)value;
58+
if (items.find("space") != items.end()) {
59+
colorComponents.red = (float)items.at("r");
60+
colorComponents.green = (float)items.at("g");
61+
colorComponents.blue = (float)items.at("b");
62+
colorComponents.alpha = (float)items.at("a");
63+
colorComponents.colorSpace = getDefaultColorSpace();
64+
std::string space = (std::string)items.at("space");
65+
if (space == "display-p3") {
66+
colorComponents.colorSpace = ColorSpace::DisplayP3;
67+
} else if (space == "srgb") {
68+
colorComponents.colorSpace = ColorSpace::sRGB;
69+
}
70+
result = colorFromComponents(colorComponents);
71+
return;
72+
}
73+
}
74+
result = parsePlatformColor(contextContainer, surfaceId, value);
75+
}
76+
}
77+
78+
} // namespace facebook::react

‎packages/react-native/ReactCommon/react/renderer/graphics/fromRawValueShared.h‎

Lines changed: 3 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -8,74 +8,19 @@
88
#pragma once
99

1010
#include <react/cxxstableapi/UmbrellaGuard.h>
11-
#include <react/debug/react_native_expect.h>
12-
#include <react/featureflags/ReactNativePublicFeatureFlags.h>
1311
#include <react/renderer/core/RawValue.h>
14-
#include <react/renderer/css/CSSColor.h>
15-
#include <react/renderer/css/CSSValueParser.h>
1612
#include <react/renderer/graphics/Color.h>
1713
#include <react/utils/ContextContainer.h>
1814

1915
namespace facebook::react {
16+
2017
using parsePlatformColorFn = SharedColor (*)(const ContextContainer &, int32_t, const RawValue &);
2118

22-
inline void fromRawValueShared(
19+
void fromRawValueShared(
2320
const ContextContainer &contextContainer,
2421
int32_t surfaceId,
2522
const RawValue &value,
2623
SharedColor &result,
27-
parsePlatformColorFn parsePlatformColor)
28-
{
29-
ColorComponents colorComponents = {0, 0, 0, 0};
30-
31-
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing() && value.hasType<std::string>()) {
32-
auto cssColor = parseCSSProperty<CSSColor>((std::string)value);
33-
if (std::holds_alternative<CSSColor>(cssColor)) {
34-
auto c = std::get<CSSColor>(cssColor);
35-
result = hostPlatformColorFromRGBA(c.r, c.g, c.b, c.a);
36-
return;
37-
}
38-
// Unparseable string - fall through to parsePlatformColor
39-
result = parsePlatformColor(contextContainer, surfaceId, value);
40-
} else if (value.hasType<int>()) {
41-
auto argb = (int64_t)value;
42-
auto ratio = 255.f;
43-
colorComponents.alpha = ((argb >> 24) & 0xFF) / ratio;
44-
colorComponents.red = ((argb >> 16) & 0xFF) / ratio;
45-
colorComponents.green = ((argb >> 8) & 0xFF) / ratio;
46-
colorComponents.blue = (argb & 0xFF) / ratio;
47-
48-
result = colorFromComponents(colorComponents);
49-
} else if (value.hasType<std::vector<float>>()) {
50-
auto items = (std::vector<float>)value;
51-
auto length = items.size();
52-
react_native_expect(length == 3 || length == 4);
53-
colorComponents.red = items.at(0);
54-
colorComponents.green = items.at(1);
55-
colorComponents.blue = items.at(2);
56-
colorComponents.alpha = length == 4 ? items.at(3) : 1.0f;
24+
parsePlatformColorFn parsePlatformColor);
5725

58-
result = colorFromComponents(colorComponents);
59-
} else {
60-
if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
61-
const auto &items = (std::unordered_map<std::string, RawValue>)value;
62-
if (items.find("space") != items.end()) {
63-
colorComponents.red = (float)items.at("r");
64-
colorComponents.green = (float)items.at("g");
65-
colorComponents.blue = (float)items.at("b");
66-
colorComponents.alpha = (float)items.at("a");
67-
colorComponents.colorSpace = getDefaultColorSpace();
68-
std::string space = (std::string)items.at("space");
69-
if (space == "display-p3") {
70-
colorComponents.colorSpace = ColorSpace::DisplayP3;
71-
} else if (space == "srgb") {
72-
colorComponents.colorSpace = ColorSpace::sRGB;
73-
}
74-
result = colorFromComponents(colorComponents);
75-
return;
76-
}
77-
}
78-
result = parsePlatformColor(contextContainer, surfaceId, value);
79-
}
80-
}
8126
} // namespace facebook::react

‎packages/react-native/ReactCommon/react/renderer/graphics/platform/android/react/renderer/graphics/PlatformColorParser.cpp‎

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
/*
2+
* Copyright (c) Meta Platforms, Inc. and affiliates.
3+
*
4+
* This source code is licensed under the MIT license found in the
5+
* LICENSE file in the root directory of this source tree.
6+
*/
7+
8+
#include <react/renderer/graphics/PlatformColorParser.h>
9+
10+
#include "configurePlatformColorCacheInvalidationHook.h"
11+
12+
#include <fbjni/fbjni.h>
13+
#include <folly/container/EvictingCacheMap.h>
14+
#include <react/renderer/css/CSSColor.h>
15+
#include <react/renderer/css/CSSValueParser.h>
16+
#include <functional>
17+
#include <mutex>
18+
#include <optional>
19+
#include <unordered_map>
20+
21+
namespace facebook::react {
22+
23+
size_t hashGetColourArguments(
24+
int32_t surfaceId,
25+
const std::vector<std::string>& resourcePaths) {
26+
size_t seed = std::hash<int32_t>{}(surfaceId);
27+
for (const auto& path : resourcePaths) {
28+
seed ^=
29+
std::hash<std::string>{}(path) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
30+
}
31+
return seed;
32+
}
33+
34+
SharedColor parsePlatformColor(
35+
const ContextContainer& contextContainer,
36+
int32_t surfaceId,
37+
const RawValue& value) {
38+
Color color{};
39+
if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
40+
// Mixed array + string values, so read as a map of RawValue (a map of
41+
// vector<string> would assert on the fallback string).
42+
auto map = (std::unordered_map<std::string, RawValue>)value;
43+
44+
std::vector<std::string> resourcePaths;
45+
auto resourcePathsIt = map.find("resource_paths");
46+
if (resourcePathsIt != map.end() &&
47+
resourcePathsIt->second.hasType<std::vector<std::string>>()) {
48+
resourcePaths = (std::vector<std::string>)resourcePathsIt->second;
49+
}
50+
51+
bool resolved = false;
52+
if (!resourcePaths.empty()) {
53+
// Cache the (costly) JNI results. A cached nullopt is an explicit miss,
54+
// distinct from a path that resolves to transparent (ARGB 0).
55+
static std::mutex getColorCacheMutex;
56+
static folly::EvictingCacheMap<size_t, std::optional<Color>>
57+
getColorCache(64);
58+
59+
// Listen for appearance changes, which should invalidate the cache
60+
static std::once_flag setupCacheInvalidation;
61+
std::call_once(
62+
setupCacheInvalidation,
63+
configurePlatformColorCacheInvalidationHook,
64+
[&] {
65+
std::scoped_lock lock(getColorCacheMutex);
66+
getColorCache.clear();
67+
});
68+
69+
auto hash = hashGetColourArguments(surfaceId, resourcePaths);
70+
std::optional<Color> resolvedColor;
71+
{
72+
std::scoped_lock lock(getColorCacheMutex);
73+
auto iterator = getColorCache.find(hash);
74+
if (iterator != getColorCache.end()) {
75+
resolvedColor = iterator->second;
76+
} else {
77+
const auto& fabricUIManager =
78+
contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
79+
// Boxed Integer: null is an explicit miss; a non-null value may be 0
80+
// (transparent black).
81+
static auto getColorFromJava =
82+
fabricUIManager->getClass()
83+
->getMethod<jni::JInteger::javaobject(
84+
jint, jni::JArrayClass<jni::JString>)>("getColor");
85+
auto javaResourcePaths =
86+
jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
87+
88+
for (int i = 0; i < resourcePaths.size(); i++) {
89+
javaResourcePaths->setElement(
90+
i, *jni::make_jstring(resourcePaths[i]));
91+
}
92+
auto boxedColor =
93+
getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
94+
if (boxedColor) {
95+
resolvedColor = static_cast<Color>(boxedColor->value());
96+
}
97+
getColorCache.set(hash, resolvedColor);
98+
}
99+
}
100+
if (resolvedColor.has_value()) {
101+
color = *resolvedColor;
102+
resolved = true;
103+
}
104+
}
105+
106+
// No path resolved: parse the raw fallback with the shared CSS parser (the
107+
// same parser iOS Fabric uses).
108+
if (!resolved) {
109+
auto fallbackIt = map.find("fallback");
110+
if (fallbackIt != map.end() &&
111+
fallbackIt->second.hasType<std::string>()) {
112+
auto cssColor =
113+
parseCSSProperty<CSSColor>((std::string)fallbackIt->second);
114+
if (std::holds_alternative<CSSColor>(cssColor)) {
115+
const auto& c = std::get<CSSColor>(cssColor);
116+
color = hostPlatformColorFromRGBA(c.r, c.g, c.b, c.a);
117+
}
118+
}
119+
}
120+
}
121+
122+
return color;
123+
}
124+
125+
} // namespace facebook::react

‎packages/react-native/ReactCommon/react/renderer/graphics/platform/android/react/renderer/graphics/PlatformColorParser.h‎

Lines changed: 3 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -8,112 +8,19 @@
88
#pragma once
99

1010
#include <react/cxxstableapi/UmbrellaGuard.h>
11-
12-
#include "configurePlatformColorCacheInvalidationHook.h"
13-
14-
#include <fbjni/fbjni.h>
15-
#include <folly/container/EvictingCacheMap.h>
1611
#include <react/renderer/core/RawValue.h>
17-
#include <react/renderer/css/CSSColor.h>
18-
#include <react/renderer/css/CSSValueParser.h>
1912
#include <react/renderer/graphics/Color.h>
2013
#include <react/renderer/graphics/fromRawValueShared.h>
2114
#include <react/utils/ContextContainer.h>
22-
#include <functional>
23-
#include <mutex>
24-
#include <optional>
15+
#include <cstddef>
2516
#include <string>
26-
#include <unordered_map>
2717
#include <vector>
2818

2919
namespace facebook::react {
3020

31-
inline size_t hashGetColourArguments(int32_t surfaceId, const std::vector<std::string> &resourcePaths)
32-
{
33-
size_t seed = std::hash<int32_t>{}(surfaceId);
34-
for (const auto &path : resourcePaths) {
35-
seed ^= std::hash<std::string>{}(path) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
36-
}
37-
return seed;
38-
}
39-
40-
inline SharedColor
41-
parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value)
42-
{
43-
Color color{};
44-
if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
45-
// Mixed array + string values, so read as a map of RawValue (a map of
46-
// vector<string> would assert on the fallback string).
47-
auto map = (std::unordered_map<std::string, RawValue>)value;
48-
49-
std::vector<std::string> resourcePaths;
50-
auto resourcePathsIt = map.find("resource_paths");
51-
if (resourcePathsIt != map.end() && resourcePathsIt->second.hasType<std::vector<std::string>>()) {
52-
resourcePaths = (std::vector<std::string>)resourcePathsIt->second;
53-
}
21+
size_t hashGetColourArguments(int32_t surfaceId, const std::vector<std::string> &resourcePaths);
5422

55-
bool resolved = false;
56-
if (!resourcePaths.empty()) {
57-
// Cache the (costly) JNI results. A cached nullopt is an explicit miss,
58-
// distinct from a path that resolves to transparent (ARGB 0).
59-
static std::mutex getColorCacheMutex;
60-
static folly::EvictingCacheMap<size_t, std::optional<Color>> getColorCache(64);
61-
62-
// Listen for appearance changes, which should invalidate the cache
63-
static std::once_flag setupCacheInvalidation;
64-
std::call_once(setupCacheInvalidation, configurePlatformColorCacheInvalidationHook, [&] {
65-
std::scoped_lock lock(getColorCacheMutex);
66-
getColorCache.clear();
67-
});
68-
69-
auto hash = hashGetColourArguments(surfaceId, resourcePaths);
70-
std::optional<Color> resolvedColor;
71-
{
72-
std::scoped_lock lock(getColorCacheMutex);
73-
auto iterator = getColorCache.find(hash);
74-
if (iterator != getColorCache.end()) {
75-
resolvedColor = iterator->second;
76-
} else {
77-
const auto &fabricUIManager = contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
78-
// Boxed Integer: null is an explicit miss; a non-null value may be 0
79-
// (transparent black).
80-
static auto getColorFromJava =
81-
fabricUIManager->getClass()->getMethod<jni::JInteger::javaobject(jint, jni::JArrayClass<jni::JString>)>(
82-
"getColor");
83-
auto javaResourcePaths = jni::JArrayClass<jni::JString>::newArray(resourcePaths.size());
84-
85-
for (int i = 0; i < resourcePaths.size(); i++) {
86-
javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
87-
}
88-
auto boxedColor = getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
89-
if (boxedColor) {
90-
resolvedColor = static_cast<Color>(boxedColor->value());
91-
}
92-
getColorCache.set(hash, resolvedColor);
93-
}
94-
}
95-
if (resolvedColor.has_value()) {
96-
color = *resolvedColor;
97-
resolved = true;
98-
}
99-
}
100-
101-
// No path resolved: parse the raw fallback with the shared CSS parser (the
102-
// same parser iOS Fabric uses).
103-
if (!resolved) {
104-
auto fallbackIt = map.find("fallback");
105-
if (fallbackIt != map.end() && fallbackIt->second.hasType<std::string>()) {
106-
auto cssColor = parseCSSProperty<CSSColor>((std::string)fallbackIt->second);
107-
if (std::holds_alternative<CSSColor>(cssColor)) {
108-
const auto &c = std::get<CSSColor>(cssColor);
109-
color = hostPlatformColorFromRGBA(c.r, c.g, c.b, c.a);
110-
}
111-
}
112-
}
113-
}
114-
115-
return color;
116-
}
23+
SharedColor parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value);
11724

11825
inline void
11926
fromRawValue(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value, SharedColor &result)

0 commit comments

Comments
 (0)