1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "Properties.h"
18
19 #include "Debug.h"
20 #ifdef __ANDROID__
21 #include "HWUIProperties.sysprop.h"
22 #endif
23 #include "SkTraceEventCommon.h"
24
25 #include <algorithm>
26 #include <cstdlib>
27 #include <optional>
28
29 #include <android-base/properties.h>
30 #include <cutils/compiler.h>
31 #include <log/log.h>
32
33 namespace android {
34 namespace uirenderer {
35
36 #ifndef __ANDROID__ // Layoutlib does not compile HWUIProperties.sysprop as it depends on cutils properties
use_vulkan()37 std::optional<bool> use_vulkan() {
38 return base::GetBoolProperty("ro.hwui.use_vulkan", false);
39 }
40
render_ahead()41 std::optional<std::int32_t> render_ahead() {
42 return base::GetIntProperty("ro.hwui.render_ahead", 0);
43 }
44 #endif
45
46 bool Properties::debugLayersUpdates = false;
47 bool Properties::debugOverdraw = false;
48 bool Properties::showDirtyRegions = false;
49 bool Properties::skipEmptyFrames = true;
50 bool Properties::useBufferAge = true;
51 bool Properties::enablePartialUpdates = true;
52 // Default true unless otherwise specified in RenderThread Configuration
53 bool Properties::enableRenderEffectCache = true;
54
55 DebugLevel Properties::debugLevel = kDebugDisabled;
56 OverdrawColorSet Properties::overdrawColorSet = OverdrawColorSet::Default;
57
58 float Properties::overrideLightRadius = -1.0f;
59 float Properties::overrideLightPosY = -1.0f;
60 float Properties::overrideLightPosZ = -1.0f;
61 float Properties::overrideAmbientRatio = -1.0f;
62 int Properties::overrideAmbientShadowStrength = -1;
63 int Properties::overrideSpotShadowStrength = -1;
64
65 ProfileType Properties::sProfileType = ProfileType::None;
66 bool Properties::sDisableProfileBars = false;
67 RenderPipelineType Properties::sRenderPipelineType = RenderPipelineType::NotInitialized;
68 bool Properties::enableHighContrastText = false;
69
70 bool Properties::waitForGpuCompletion = false;
71
72 bool Properties::filterOutTestOverhead = false;
73 bool Properties::disableVsync = false;
74 bool Properties::skpCaptureEnabled = false;
75 bool Properties::enableRTAnimations = true;
76
77 bool Properties::runningInEmulator = false;
78 bool Properties::debuggingEnabled = false;
79 bool Properties::isolatedProcess = false;
80
81 int Properties::contextPriority = 0;
82 float Properties::defaultSdrWhitePoint = 200.f;
83
84 bool Properties::useHintManager = false;
85 int Properties::targetCpuTimePercentage = 70;
86
87 bool Properties::enableWebViewOverlays = true;
88
89 bool Properties::isHighEndGfx = true;
90 bool Properties::isLowRam = false;
91 bool Properties::isSystemOrPersistent = false;
92
93 float Properties::maxHdrHeadroomOn8bit = 5.f; // TODO: Refine this number
94
95 StretchEffectBehavior Properties::stretchEffectBehavior = StretchEffectBehavior::ShaderHWUI;
96
97 DrawingEnabled Properties::drawingEnabled = DrawingEnabled::NotInitialized;
98
load()99 bool Properties::load() {
100 bool prevDebugLayersUpdates = debugLayersUpdates;
101 bool prevDebugOverdraw = debugOverdraw;
102
103 debugOverdraw = false;
104 std::string debugOverdrawProperty = base::GetProperty(PROPERTY_DEBUG_OVERDRAW, "");
105 if (debugOverdrawProperty != "") {
106 INIT_LOGD(" Overdraw debug enabled: %s", debugOverdrawProperty.c_str());
107 if (debugOverdrawProperty == "show") {
108 debugOverdraw = true;
109 overdrawColorSet = OverdrawColorSet::Default;
110 } else if (debugOverdrawProperty == "show_deuteranomaly") {
111 debugOverdraw = true;
112 overdrawColorSet = OverdrawColorSet::Deuteranomaly;
113 }
114 }
115
116 sProfileType = ProfileType::None;
117 std::string profileProperty = base::GetProperty(PROPERTY_PROFILE, "");
118 if (profileProperty != "") {
119 if (profileProperty == PROPERTY_PROFILE_VISUALIZE_BARS) {
120 sProfileType = ProfileType::Bars;
121 } else if (profileProperty == "true") {
122 sProfileType = ProfileType::Console;
123 }
124 }
125
126 debugLayersUpdates = base::GetBoolProperty(PROPERTY_DEBUG_LAYERS_UPDATES, false);
127 INIT_LOGD(" Layers updates debug enabled: %d", debugLayersUpdates);
128
129 showDirtyRegions = base::GetBoolProperty(PROPERTY_DEBUG_SHOW_DIRTY_REGIONS, false);
130
131 debugLevel = (DebugLevel)base::GetIntProperty(PROPERTY_DEBUG, (int)kDebugDisabled);
132
133 skipEmptyFrames = base::GetBoolProperty(PROPERTY_SKIP_EMPTY_DAMAGE, true);
134 useBufferAge = base::GetBoolProperty(PROPERTY_USE_BUFFER_AGE, true);
135 enablePartialUpdates = base::GetBoolProperty(PROPERTY_ENABLE_PARTIAL_UPDATES, true);
136
137 filterOutTestOverhead = base::GetBoolProperty(PROPERTY_FILTER_TEST_OVERHEAD, false);
138
139 skpCaptureEnabled = debuggingEnabled && base::GetBoolProperty(PROPERTY_CAPTURE_SKP_ENABLED, false);
140
141 SkAndroidFrameworkTraceUtil::setEnableTracing(
142 base::GetBoolProperty(PROPERTY_SKIA_TRACING_ENABLED, false));
143 SkAndroidFrameworkTraceUtil::setUsePerfettoTrackEvents(
144 base::GetBoolProperty(PROPERTY_SKIA_USE_PERFETTO_TRACK_EVENTS, false));
145
146 runningInEmulator = base::GetBoolProperty(PROPERTY_IS_EMULATOR, false);
147
148 useHintManager = base::GetBoolProperty(PROPERTY_USE_HINT_MANAGER, false);
149 targetCpuTimePercentage = base::GetIntProperty(PROPERTY_TARGET_CPU_TIME_PERCENTAGE, 70);
150 if (targetCpuTimePercentage <= 0 || targetCpuTimePercentage > 100) targetCpuTimePercentage = 70;
151
152 enableWebViewOverlays = base::GetBoolProperty(PROPERTY_WEBVIEW_OVERLAYS_ENABLED, true);
153
154 auto hdrHeadroom = (float)atof(base::GetProperty(PROPERTY_8BIT_HDR_HEADROOM, "").c_str());
155 if (hdrHeadroom >= 1.f) {
156 maxHdrHeadroomOn8bit = std::min(hdrHeadroom, 100.f);
157 }
158
159 // call isDrawingEnabled to force loading of the property
160 isDrawingEnabled();
161
162 return (prevDebugLayersUpdates != debugLayersUpdates) || (prevDebugOverdraw != debugOverdraw);
163 }
164
overrideProperty(const char * name,const char * value)165 void Properties::overrideProperty(const char* name, const char* value) {
166 if (!strcmp(name, "disableProfileBars")) {
167 sDisableProfileBars = !strcmp(value, "true");
168 ALOGD("profile bars %s", sDisableProfileBars ? "disabled" : "enabled");
169 return;
170 } else if (!strcmp(name, "ambientRatio")) {
171 overrideAmbientRatio = std::min(std::max(atof(value), 0.0), 10.0);
172 ALOGD("ambientRatio = %.2f", overrideAmbientRatio);
173 return;
174 } else if (!strcmp(name, "lightRadius")) {
175 overrideLightRadius = std::min(std::max(atof(value), 0.0), 3000.0);
176 ALOGD("lightRadius = %.2f", overrideLightRadius);
177 return;
178 } else if (!strcmp(name, "lightPosY")) {
179 overrideLightPosY = std::min(std::max(atof(value), 0.0), 3000.0);
180 ALOGD("lightPos Y = %.2f", overrideLightPosY);
181 return;
182 } else if (!strcmp(name, "lightPosZ")) {
183 overrideLightPosZ = std::min(std::max(atof(value), 0.0), 3000.0);
184 ALOGD("lightPos Z = %.2f", overrideLightPosZ);
185 return;
186 } else if (!strcmp(name, "ambientShadowStrength")) {
187 overrideAmbientShadowStrength = atoi(value);
188 ALOGD("ambient shadow strength = 0x%x out of 0xff", overrideAmbientShadowStrength);
189 return;
190 } else if (!strcmp(name, "spotShadowStrength")) {
191 overrideSpotShadowStrength = atoi(value);
192 ALOGD("spot shadow strength = 0x%x out of 0xff", overrideSpotShadowStrength);
193 return;
194 }
195 ALOGD("failed overriding property %s to %s", name, value);
196 }
197
getProfileType()198 ProfileType Properties::getProfileType() {
199 if (CC_UNLIKELY(sDisableProfileBars && sProfileType == ProfileType::Bars))
200 return ProfileType::None;
201 return sProfileType;
202 }
203
peekRenderPipelineType()204 RenderPipelineType Properties::peekRenderPipelineType() {
205 // If sRenderPipelineType has been locked, just return the locked type immediately.
206 if (sRenderPipelineType != RenderPipelineType::NotInitialized) {
207 return sRenderPipelineType;
208 }
209 bool useVulkan = use_vulkan().value_or(false);
210 std::string rendererProperty = base::GetProperty(PROPERTY_RENDERER, useVulkan ? "skiavk" : "skiagl");
211 if (rendererProperty == "skiavk") {
212 return RenderPipelineType::SkiaVulkan;
213 }
214 return RenderPipelineType::SkiaGL;
215 }
216
getRenderPipelineType()217 RenderPipelineType Properties::getRenderPipelineType() {
218 sRenderPipelineType = peekRenderPipelineType();
219 return sRenderPipelineType;
220 }
221
overrideRenderPipelineType(RenderPipelineType type)222 void Properties::overrideRenderPipelineType(RenderPipelineType type) {
223 // If we're doing actual rendering then we can't change the renderer after it's been set.
224 // Unit tests can freely change this as often as it wants, though, as there's no actual
225 // GL rendering happening
226 if (sRenderPipelineType != RenderPipelineType::NotInitialized) {
227 LOG_ALWAYS_FATAL_IF(sRenderPipelineType != type,
228 "Trying to change pipeline but it's already set");
229 return;
230 }
231 sRenderPipelineType = type;
232 }
233
setDrawingEnabled(bool newDrawingEnabled)234 void Properties::setDrawingEnabled(bool newDrawingEnabled) {
235 drawingEnabled = newDrawingEnabled ? DrawingEnabled::On : DrawingEnabled::Off;
236 enableRTAnimations = newDrawingEnabled;
237 }
238
isDrawingEnabled()239 bool Properties::isDrawingEnabled() {
240 if (drawingEnabled == DrawingEnabled::NotInitialized) {
241 bool drawingEnabledProp = base::GetBoolProperty(PROPERTY_DRAWING_ENABLED, true);
242 drawingEnabled = drawingEnabledProp ? DrawingEnabled::On : DrawingEnabled::Off;
243 enableRTAnimations = drawingEnabledProp;
244 }
245 return drawingEnabled == DrawingEnabled::On;
246 }
247
248 } // namespace uirenderer
249 } // namespace android
250