Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 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 | */ |
Mark Salyzyn | 52eb4e0 | 2016-09-28 16:15:30 -0700 | [diff] [blame] | 16 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 17 | #include "Properties.h" |
Alec Mouri | aa3e498 | 2020-12-14 14:47:57 -0800 | [diff] [blame] | 18 | |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 19 | #include <android-base/properties.h> |
| 20 | #include <cutils/compiler.h> |
| 21 | #include <log/log.h> |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 22 | |
John Reck | 6b50780 | 2015-11-03 10:09:59 -0800 | [diff] [blame] | 23 | #include <algorithm> |
| 24 | #include <cstdlib> |
Jerome Gaillard | 21e7e2d | 2019-05-14 14:34:46 +0100 | [diff] [blame] | 25 | #include <optional> |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 26 | |
Jerome Gaillard | ea9bf2a | 2024-03-13 19:32:31 +0000 | [diff] [blame] | 27 | #include "Debug.h" |
| 28 | #include "HWUIProperties.sysprop.h" |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 29 | #include "src/core/SkTraceEventCommon.h" |
| 30 | |
| 31 | #ifdef __ANDROID__ |
| 32 | #include <com_android_graphics_hwui_flags.h> |
| 33 | namespace hwui_flags = com::android::graphics::hwui::flags; |
| 34 | #else |
| 35 | namespace hwui_flags { |
| 36 | constexpr bool clip_surfaceviews() { |
| 37 | return false; |
| 38 | } |
Alec Mouri | 22ab7f3 | 2023-09-06 02:11:56 +0000 | [diff] [blame] | 39 | constexpr bool hdr_10bit_plus() { |
| 40 | return false; |
| 41 | } |
Leon Scroggins III | bac8706 | 2024-05-31 16:40:17 -0400 | [diff] [blame] | 42 | constexpr bool initialize_gl_always() { |
| 43 | return false; |
| 44 | } |
Tom Murphy | 102ba128 | 2024-07-25 12:50:46 +0000 | [diff] [blame] | 45 | |
| 46 | constexpr bool skip_eglmanager_telemetry() { |
| 47 | return false; |
| 48 | } |
| 49 | |
Alec Mouri | 7dcb7d2 | 2024-07-26 13:41:04 +0000 | [diff] [blame] | 50 | constexpr bool resample_gainmap_regions() { |
| 51 | return false; |
| 52 | } |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 53 | } // namespace hwui_flags |
| 54 | #endif |
Mark Salyzyn | 52eb4e0 | 2016-09-28 16:15:30 -0700 | [diff] [blame] | 55 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 56 | namespace android { |
| 57 | namespace uirenderer { |
| 58 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 59 | bool Properties::debugLayersUpdates = false; |
| 60 | bool Properties::debugOverdraw = false; |
Nolan Scobie | 1083707b | 2024-01-11 16:45:36 -0500 | [diff] [blame] | 61 | bool Properties::debugTraceGpuResourceCategories = false; |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 62 | bool Properties::showDirtyRegions = false; |
John Reck | d04794a | 2015-05-08 10:04:36 -0700 | [diff] [blame] | 63 | bool Properties::skipEmptyFrames = true; |
John Reck | 149173d | 2015-08-10 09:52:29 -0700 | [diff] [blame] | 64 | bool Properties::useBufferAge = true; |
| 65 | bool Properties::enablePartialUpdates = true; |
Nader Jawad | 086645d | 2021-09-24 13:42:47 -0700 | [diff] [blame] | 66 | // Default true unless otherwise specified in RenderThread Configuration |
| 67 | bool Properties::enableRenderEffectCache = true; |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 68 | |
| 69 | DebugLevel Properties::debugLevel = kDebugDisabled; |
| 70 | OverdrawColorSet Properties::overdrawColorSet = OverdrawColorSet::Default; |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 71 | |
| 72 | float Properties::overrideLightRadius = -1.0f; |
| 73 | float Properties::overrideLightPosY = -1.0f; |
| 74 | float Properties::overrideLightPosZ = -1.0f; |
| 75 | float Properties::overrideAmbientRatio = -1.0f; |
| 76 | int Properties::overrideAmbientShadowStrength = -1; |
| 77 | int Properties::overrideSpotShadowStrength = -1; |
| 78 | |
| 79 | ProfileType Properties::sProfileType = ProfileType::None; |
| 80 | bool Properties::sDisableProfileBars = false; |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 81 | RenderPipelineType Properties::sRenderPipelineType = RenderPipelineType::NotInitialized; |
John Reck | 938e884 | 2017-08-24 13:41:59 -0700 | [diff] [blame] | 82 | bool Properties::enableHighContrastText = false; |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 83 | |
John Reck | 682573c | 2015-10-30 10:37:35 -0700 | [diff] [blame] | 84 | bool Properties::waitForGpuCompletion = false; |
| 85 | |
John Reck | c7cd9cf | 2016-03-28 10:38:19 -0700 | [diff] [blame] | 86 | bool Properties::filterOutTestOverhead = false; |
John Reck | a896306 | 2017-06-14 10:47:50 -0700 | [diff] [blame] | 87 | bool Properties::disableVsync = false; |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 88 | bool Properties::skpCaptureEnabled = false; |
John Reck | 9f51644 | 2017-09-25 10:27:21 -0700 | [diff] [blame] | 89 | bool Properties::enableRTAnimations = true; |
John Reck | c7cd9cf | 2016-03-28 10:38:19 -0700 | [diff] [blame] | 90 | |
Lingfeng Yang | 3a9f223 | 2018-01-24 10:40:18 -0800 | [diff] [blame] | 91 | bool Properties::runningInEmulator = false; |
John Reck | 6afa009 | 2018-03-01 17:28:35 -0800 | [diff] [blame] | 92 | bool Properties::debuggingEnabled = false; |
John Reck | 5642847 | 2018-03-16 17:27:17 -0700 | [diff] [blame] | 93 | bool Properties::isolatedProcess = false; |
Lingfeng Yang | 3a9f223 | 2018-01-24 10:40:18 -0800 | [diff] [blame] | 94 | |
Jorim Jaggi | 767e25e | 2018-04-04 23:07:35 +0200 | [diff] [blame] | 95 | int Properties::contextPriority = 0; |
John Reck | f42ff76 | 2020-08-06 13:53:22 -0700 | [diff] [blame] | 96 | float Properties::defaultSdrWhitePoint = 200.f; |
Jorim Jaggi | 767e25e | 2018-04-04 23:07:35 +0200 | [diff] [blame] | 97 | |
Matt Buckley | 49602f5 | 2022-12-06 22:03:30 +0000 | [diff] [blame] | 98 | bool Properties::useHintManager = false; |
Bo Liu | 027b218 | 2021-03-18 16:50:38 -0400 | [diff] [blame] | 99 | int Properties::targetCpuTimePercentage = 70; |
| 100 | |
Huihong Luo | 35b1dde | 2021-08-13 10:28:10 -0700 | [diff] [blame] | 101 | bool Properties::enableWebViewOverlays = true; |
Huihong Luo | eb93107 | 2021-06-30 10:12:17 -0700 | [diff] [blame] | 102 | |
John Reck | 5f66fb8 | 2022-09-23 17:49:23 -0400 | [diff] [blame] | 103 | bool Properties::isHighEndGfx = true; |
| 104 | bool Properties::isLowRam = false; |
| 105 | bool Properties::isSystemOrPersistent = false; |
| 106 | |
John Reck | 342f621 | 2023-03-14 21:58:26 -0400 | [diff] [blame] | 107 | float Properties::maxHdrHeadroomOn8bit = 5.f; // TODO: Refine this number |
| 108 | |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 109 | bool Properties::clipSurfaceViews = false; |
Alec Mouri | 22ab7f3 | 2023-09-06 02:11:56 +0000 | [diff] [blame] | 110 | bool Properties::hdr10bitPlus = false; |
Tom Murphy | 102ba128 | 2024-07-25 12:50:46 +0000 | [diff] [blame] | 111 | bool Properties::skipTelemetry = false; |
Alec Mouri | 7dcb7d2 | 2024-07-26 13:41:04 +0000 | [diff] [blame] | 112 | bool Properties::resampleGainmapRegions = false; |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 113 | |
Jason Macnak | c355c23 | 2024-07-29 11:10:34 -0700 | [diff] [blame] | 114 | int Properties::timeoutMultiplier = 1; |
| 115 | |
Nader Jawad | 9272f21 | 2021-05-10 13:27:52 -0700 | [diff] [blame] | 116 | StretchEffectBehavior Properties::stretchEffectBehavior = StretchEffectBehavior::ShaderHWUI; |
John Reck | 8ed00dc | 2021-05-10 13:09:27 -0400 | [diff] [blame] | 117 | |
Brett Chabot | 074ba59 | 2021-07-16 14:38:11 -0700 | [diff] [blame] | 118 | DrawingEnabled Properties::drawingEnabled = DrawingEnabled::NotInitialized; |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 119 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 120 | bool Properties::load() { |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 121 | bool prevDebugLayersUpdates = debugLayersUpdates; |
| 122 | bool prevDebugOverdraw = debugOverdraw; |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 123 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 124 | debugOverdraw = false; |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 125 | std::string debugOverdrawProperty = base::GetProperty(PROPERTY_DEBUG_OVERDRAW, ""); |
| 126 | if (debugOverdrawProperty != "") { |
tangcheng | 70ee564 | 2023-03-17 11:27:59 +0800 | [diff] [blame] | 127 | INIT_LOGD(" Overdraw debug enabled: %s", debugOverdrawProperty.c_str()); |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 128 | if (debugOverdrawProperty == "show") { |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 129 | debugOverdraw = true; |
| 130 | overdrawColorSet = OverdrawColorSet::Default; |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 131 | } else if (debugOverdrawProperty == "show_deuteranomaly") { |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 132 | debugOverdraw = true; |
| 133 | overdrawColorSet = OverdrawColorSet::Deuteranomaly; |
| 134 | } |
| 135 | } |
| 136 | |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 137 | sProfileType = ProfileType::None; |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 138 | std::string profileProperty = base::GetProperty(PROPERTY_PROFILE, ""); |
| 139 | if (profileProperty != "") { |
| 140 | if (profileProperty == PROPERTY_PROFILE_VISUALIZE_BARS) { |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 141 | sProfileType = ProfileType::Bars; |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 142 | } else if (profileProperty == "true") { |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 143 | sProfileType = ProfileType::Console; |
| 144 | } |
| 145 | } |
| 146 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 147 | debugLayersUpdates = base::GetBoolProperty(PROPERTY_DEBUG_LAYERS_UPDATES, false); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 148 | INIT_LOGD(" Layers updates debug enabled: %d", debugLayersUpdates); |
| 149 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 150 | showDirtyRegions = base::GetBoolProperty(PROPERTY_DEBUG_SHOW_DIRTY_REGIONS, false); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 151 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 152 | debugLevel = (DebugLevel)base::GetIntProperty(PROPERTY_DEBUG, (int)kDebugDisabled); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 153 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 154 | skipEmptyFrames = base::GetBoolProperty(PROPERTY_SKIP_EMPTY_DAMAGE, true); |
| 155 | useBufferAge = base::GetBoolProperty(PROPERTY_USE_BUFFER_AGE, true); |
| 156 | enablePartialUpdates = base::GetBoolProperty(PROPERTY_ENABLE_PARTIAL_UPDATES, true); |
John Reck | d04794a | 2015-05-08 10:04:36 -0700 | [diff] [blame] | 157 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 158 | filterOutTestOverhead = base::GetBoolProperty(PROPERTY_FILTER_TEST_OVERHEAD, false); |
John Reck | c7cd9cf | 2016-03-28 10:38:19 -0700 | [diff] [blame] | 159 | |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 160 | skpCaptureEnabled = debuggingEnabled && base::GetBoolProperty(PROPERTY_CAPTURE_SKP_ENABLED, false); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 161 | |
Nolan Scobie | 1083707b | 2024-01-11 16:45:36 -0500 | [diff] [blame] | 162 | bool skiaBroadTracing = base::GetBoolProperty(PROPERTY_SKIA_TRACING_ENABLED, false); |
| 163 | SkAndroidFrameworkTraceUtil::setEnableTracing(skiaBroadTracing); |
Nolan Scobie | 799b574 | 2022-12-05 21:12:16 -0500 | [diff] [blame] | 164 | SkAndroidFrameworkTraceUtil::setUsePerfettoTrackEvents( |
| 165 | base::GetBoolProperty(PROPERTY_SKIA_USE_PERFETTO_TRACK_EVENTS, false)); |
Nolan Scobie | 1083707b | 2024-01-11 16:45:36 -0500 | [diff] [blame] | 166 | debugTraceGpuResourceCategories = |
| 167 | base::GetBoolProperty(PROPERTY_TRACE_GPU_RESOURCES, skiaBroadTracing); |
Stan Iliev | 02daab6 | 2018-06-29 15:16:11 -0400 | [diff] [blame] | 168 | |
Roman Kiryanov | d6a9f425 | 2021-03-10 16:57:41 -0800 | [diff] [blame] | 169 | runningInEmulator = base::GetBoolProperty(PROPERTY_IS_EMULATOR, false); |
Lingfeng Yang | 3a9f223 | 2018-01-24 10:40:18 -0800 | [diff] [blame] | 170 | |
Matt Buckley | 49602f5 | 2022-12-06 22:03:30 +0000 | [diff] [blame] | 171 | useHintManager = base::GetBoolProperty(PROPERTY_USE_HINT_MANAGER, false); |
Bo Liu | 027b218 | 2021-03-18 16:50:38 -0400 | [diff] [blame] | 172 | targetCpuTimePercentage = base::GetIntProperty(PROPERTY_TARGET_CPU_TIME_PERCENTAGE, 70); |
| 173 | if (targetCpuTimePercentage <= 0 || targetCpuTimePercentage > 100) targetCpuTimePercentage = 70; |
| 174 | |
Huihong Luo | 35b1dde | 2021-08-13 10:28:10 -0700 | [diff] [blame] | 175 | enableWebViewOverlays = base::GetBoolProperty(PROPERTY_WEBVIEW_OVERLAYS_ENABLED, true); |
Huihong Luo | eb93107 | 2021-06-30 10:12:17 -0700 | [diff] [blame] | 176 | |
John Reck | 342f621 | 2023-03-14 21:58:26 -0400 | [diff] [blame] | 177 | auto hdrHeadroom = (float)atof(base::GetProperty(PROPERTY_8BIT_HDR_HEADROOM, "").c_str()); |
| 178 | if (hdrHeadroom >= 1.f) { |
| 179 | maxHdrHeadroomOn8bit = std::min(hdrHeadroom, 100.f); |
| 180 | } |
| 181 | |
Brett Chabot | 074ba59 | 2021-07-16 14:38:11 -0700 | [diff] [blame] | 182 | // call isDrawingEnabled to force loading of the property |
| 183 | isDrawingEnabled(); |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 184 | |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 185 | clipSurfaceViews = |
| 186 | base::GetBoolProperty("debug.hwui.clip_surfaceviews", hwui_flags::clip_surfaceviews()); |
Alec Mouri | 22ab7f3 | 2023-09-06 02:11:56 +0000 | [diff] [blame] | 187 | hdr10bitPlus = hwui_flags::hdr_10bit_plus(); |
Alec Mouri | 7dcb7d2 | 2024-07-26 13:41:04 +0000 | [diff] [blame] | 188 | resampleGainmapRegions = base::GetBoolProperty("debug.hwui.resample_gainmap_regions", |
| 189 | hwui_flags::resample_gainmap_regions()); |
John Reck | 1b152e7 | 2023-10-24 20:43:22 -0400 | [diff] [blame] | 190 | |
Jason Macnak | c355c23 | 2024-07-29 11:10:34 -0700 | [diff] [blame] | 191 | timeoutMultiplier = android::base::GetIntProperty("ro.hw_timeout_multiplier", 1); |
Tom Murphy | 102ba128 | 2024-07-25 12:50:46 +0000 | [diff] [blame] | 192 | skipTelemetry = base::GetBoolProperty(PROPERTY_SKIP_EGLMANAGER_TELEMETRY, |
| 193 | hwui_flags::skip_eglmanager_telemetry()); |
Jason Macnak | c355c23 | 2024-07-29 11:10:34 -0700 | [diff] [blame] | 194 | |
Derek Sollenberger | fd1c879 | 2018-12-04 16:22:58 -0500 | [diff] [blame] | 195 | return (prevDebugLayersUpdates != debugLayersUpdates) || (prevDebugOverdraw != debugOverdraw); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | void Properties::overrideProperty(const char* name, const char* value) { |
| 199 | if (!strcmp(name, "disableProfileBars")) { |
| 200 | sDisableProfileBars = !strcmp(value, "true"); |
| 201 | ALOGD("profile bars %s", sDisableProfileBars ? "disabled" : "enabled"); |
| 202 | return; |
| 203 | } else if (!strcmp(name, "ambientRatio")) { |
Chris Craik | e6a15ee | 2015-07-07 18:42:17 -0700 | [diff] [blame] | 204 | overrideAmbientRatio = std::min(std::max(atof(value), 0.0), 10.0); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 205 | ALOGD("ambientRatio = %.2f", overrideAmbientRatio); |
| 206 | return; |
| 207 | } else if (!strcmp(name, "lightRadius")) { |
Chris Craik | e6a15ee | 2015-07-07 18:42:17 -0700 | [diff] [blame] | 208 | overrideLightRadius = std::min(std::max(atof(value), 0.0), 3000.0); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 209 | ALOGD("lightRadius = %.2f", overrideLightRadius); |
| 210 | return; |
| 211 | } else if (!strcmp(name, "lightPosY")) { |
Chris Craik | e6a15ee | 2015-07-07 18:42:17 -0700 | [diff] [blame] | 212 | overrideLightPosY = std::min(std::max(atof(value), 0.0), 3000.0); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 213 | ALOGD("lightPos Y = %.2f", overrideLightPosY); |
| 214 | return; |
| 215 | } else if (!strcmp(name, "lightPosZ")) { |
Chris Craik | e6a15ee | 2015-07-07 18:42:17 -0700 | [diff] [blame] | 216 | overrideLightPosZ = std::min(std::max(atof(value), 0.0), 3000.0); |
Chris Craik | 2507c34 | 2015-05-04 14:36:49 -0700 | [diff] [blame] | 217 | ALOGD("lightPos Z = %.2f", overrideLightPosZ); |
| 218 | return; |
| 219 | } else if (!strcmp(name, "ambientShadowStrength")) { |
| 220 | overrideAmbientShadowStrength = atoi(value); |
| 221 | ALOGD("ambient shadow strength = 0x%x out of 0xff", overrideAmbientShadowStrength); |
| 222 | return; |
| 223 | } else if (!strcmp(name, "spotShadowStrength")) { |
| 224 | overrideSpotShadowStrength = atoi(value); |
| 225 | ALOGD("spot shadow strength = 0x%x out of 0xff", overrideSpotShadowStrength); |
| 226 | return; |
| 227 | } |
| 228 | ALOGD("failed overriding property %s to %s", name, value); |
| 229 | } |
| 230 | |
| 231 | ProfileType Properties::getProfileType() { |
| 232 | if (CC_UNLIKELY(sDisableProfileBars && sProfileType == ProfileType::Bars)) |
| 233 | return ProfileType::None; |
| 234 | return sProfileType; |
| 235 | } |
| 236 | |
Yiwei Zhang | 4bf3d9e | 2019-04-15 16:24:32 -0700 | [diff] [blame] | 237 | RenderPipelineType Properties::peekRenderPipelineType() { |
| 238 | // If sRenderPipelineType has been locked, just return the locked type immediately. |
John Reck | 113ddd9 | 2017-11-09 16:21:21 -0800 | [diff] [blame] | 239 | if (sRenderPipelineType != RenderPipelineType::NotInitialized) { |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 240 | return sRenderPipelineType; |
| 241 | } |
Stan Iliev | b8811aa5 | 2018-11-08 16:25:54 -0500 | [diff] [blame] | 242 | bool useVulkan = use_vulkan().value_or(false); |
Jerome Gaillard | a02a12d | 2019-05-28 18:07:56 +0100 | [diff] [blame] | 243 | std::string rendererProperty = base::GetProperty(PROPERTY_RENDERER, useVulkan ? "skiavk" : "skiagl"); |
| 244 | if (rendererProperty == "skiavk") { |
Yiwei Zhang | 4bf3d9e | 2019-04-15 16:24:32 -0700 | [diff] [blame] | 245 | return RenderPipelineType::SkiaVulkan; |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 246 | } |
Yiwei Zhang | 4bf3d9e | 2019-04-15 16:24:32 -0700 | [diff] [blame] | 247 | return RenderPipelineType::SkiaGL; |
| 248 | } |
| 249 | |
| 250 | RenderPipelineType Properties::getRenderPipelineType() { |
| 251 | sRenderPipelineType = peekRenderPipelineType(); |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 252 | return sRenderPipelineType; |
| 253 | } |
| 254 | |
Alec Mouri | 219997a | 2023-05-23 17:25:19 +0000 | [diff] [blame] | 255 | void Properties::overrideRenderPipelineType(RenderPipelineType type) { |
John Reck | 113ddd9 | 2017-11-09 16:21:21 -0800 | [diff] [blame] | 256 | // If we're doing actual rendering then we can't change the renderer after it's been set. |
Alec Mouri | 219997a | 2023-05-23 17:25:19 +0000 | [diff] [blame] | 257 | // Unit tests can freely change this as often as it wants, though, as there's no actual |
| 258 | // GL rendering happening |
| 259 | if (sRenderPipelineType != RenderPipelineType::NotInitialized) { |
| 260 | LOG_ALWAYS_FATAL_IF(sRenderPipelineType != type, |
| 261 | "Trying to change pipeline but it's already set"); |
| 262 | return; |
| 263 | } |
Greg Daniel | 98c78dad | 2017-01-04 14:45:56 -0500 | [diff] [blame] | 264 | sRenderPipelineType = type; |
| 265 | } |
Greg Daniel | 98c78dad | 2017-01-04 14:45:56 -0500 | [diff] [blame] | 266 | |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 267 | void Properties::setDrawingEnabled(bool newDrawingEnabled) { |
Brett Chabot | 074ba59 | 2021-07-16 14:38:11 -0700 | [diff] [blame] | 268 | drawingEnabled = newDrawingEnabled ? DrawingEnabled::On : DrawingEnabled::Off; |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 269 | enableRTAnimations = newDrawingEnabled; |
| 270 | } |
| 271 | |
| 272 | bool Properties::isDrawingEnabled() { |
Brett Chabot | 074ba59 | 2021-07-16 14:38:11 -0700 | [diff] [blame] | 273 | if (drawingEnabled == DrawingEnabled::NotInitialized) { |
| 274 | bool drawingEnabledProp = base::GetBoolProperty(PROPERTY_DRAWING_ENABLED, true); |
| 275 | drawingEnabled = drawingEnabledProp ? DrawingEnabled::On : DrawingEnabled::Off; |
| 276 | enableRTAnimations = drawingEnabledProp; |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 277 | } |
Brett Chabot | 074ba59 | 2021-07-16 14:38:11 -0700 | [diff] [blame] | 278 | return drawingEnabled == DrawingEnabled::On; |
Brett Chabot | 856db9e | 2021-05-21 08:41:58 -0700 | [diff] [blame] | 279 | } |
| 280 | |
Leon Scroggins III | bac8706 | 2024-05-31 16:40:17 -0400 | [diff] [blame] | 281 | bool Properties::initializeGlAlways() { |
| 282 | return base::GetBoolProperty(PROPERTY_INITIALIZE_GL_ALWAYS, hwui_flags::initialize_gl_always()); |
| 283 | } |
| 284 | |
Chris Blume | 7b8a808 | 2018-11-30 15:51:58 -0800 | [diff] [blame] | 285 | } // namespace uirenderer |
| 286 | } // namespace android |