1 /*
<lambda>null2 * Copyright (C) 2024 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 package com.android.server.display.config
18
19 import android.util.Spline
20 import android.util.Xml
21 import com.android.server.display.config.HighBrightnessModeData.HDR_PERCENT_OF_SCREEN_REQUIRED_DEFAULT
22 import java.io.ByteArrayInputStream
23 import java.io.ByteArrayOutputStream
24 import java.io.OutputStreamWriter
25 import org.xmlpull.v1.XmlSerializer
26
27 @JvmOverloads
28 fun createSensorData(
29 type: String? = null,
30 name: String? = null,
31 minRefreshRate: Float = 0f,
32 maxRefreshRate: Float = Float.POSITIVE_INFINITY,
33 supportedModes: List<SupportedModeData> = emptyList()
34 ): SensorData {
35 return SensorData(type, name, minRefreshRate, maxRefreshRate, supportedModes)
36 }
37
createRefreshRateDatanull38 fun createRefreshRateData(
39 defaultRefreshRate: Int = 60,
40 defaultPeakRefreshRate: Int = 60,
41 defaultRefreshRateInHbmHdr: Int = 60,
42 defaultRefreshRateInHbmSunlight: Int = 60,
43 lowPowerSupportedModes: List<SupportedModeData> = emptyList(),
44 lowLightBlockingZoneSupportedModes: List<SupportedModeData> = emptyList()
45 ): RefreshRateData {
46 return RefreshRateData(
47 defaultRefreshRate, defaultPeakRefreshRate,
48 defaultRefreshRateInHbmHdr, defaultRefreshRateInHbmSunlight,
49 lowPowerSupportedModes, lowLightBlockingZoneSupportedModes
50 )
51 }
52
53 @JvmOverloads
createHdrBrightnessDatanull54 fun createHdrBrightnessData(
55 maxBrightnessLimits: Map<Float, Float> = mapOf(Pair(500f, 0.6f)),
56 brightnessIncreaseDebounceMillis: Long = 1000,
57 screenBrightnessRampIncrease: Float = 0.02f,
58 brightnessDecreaseDebounceMillis: Long = 3000,
59 screenBrightnessRampDecrease: Float = 0.04f,
60 transitionPoint: Float = 0.65f,
61 minimumHdrPercentOfScreenForNbm: Float = HDR_PERCENT_OF_SCREEN_REQUIRED_DEFAULT,
62 minimumHdrPercentOfScreenForHbm: Float = HDR_PERCENT_OF_SCREEN_REQUIRED_DEFAULT,
63 allowInLowPowerMode: Boolean = false,
64 sdrToHdrRatioSpline: Spline? = null,
65 highestHdrSdrRatio: Float = 1f
66 ): HdrBrightnessData {
67 return HdrBrightnessData(
68 maxBrightnessLimits,
69 brightnessIncreaseDebounceMillis,
70 screenBrightnessRampIncrease,
71 brightnessDecreaseDebounceMillis,
72 screenBrightnessRampDecrease,
73 transitionPoint,
74 minimumHdrPercentOfScreenForNbm,
75 minimumHdrPercentOfScreenForHbm,
76 allowInLowPowerMode,
77 sdrToHdrRatioSpline,
78 highestHdrSdrRatio
79 )
80 }
81
highBrightnessModenull82 fun XmlSerializer.highBrightnessMode(
83 enabled: String = "true",
84 transitionPoint: String = "0.67",
85 minimumLux: String = "2500",
86 timeWindowSecs: String = "200",
87 timeMaxSecs: String = "30",
88 timeMinSecs: String = "3",
89 refreshRateRange: Pair<String, String>? = null,
90 allowInLowPowerMode: String? = null,
91 minimumHdrPercentOfScreen: String? = null,
92 sdrHdrRatioMap: List<Pair<String, String>>? = null,
93 ) {
94 element("highBrightnessMode") {
95 attribute("", "enabled", enabled)
96 element("transitionPoint", transitionPoint)
97 element("minimumLux", minimumLux)
98 element("timing") {
99 element("timeWindowSecs", timeWindowSecs)
100 element("timeMaxSecs", timeMaxSecs)
101 element("timeMinSecs", timeMinSecs)
102 }
103 pair("refreshRate", "minimum", "maximum", refreshRateRange)
104 element("allowInLowPowerMode", allowInLowPowerMode)
105 element("minimumHdrPercentOfScreen", minimumHdrPercentOfScreen)
106 map("sdrHdrRatioMap", "point", "sdrNits", "hdrRatio", sdrHdrRatioMap)
107 }
108 }
109
hdrBrightnessConfignull110 fun XmlSerializer.hdrBrightnessConfig(
111 brightnessMap: List<Pair<String, String>> = listOf(Pair("500", "0.6")),
112 brightnessIncreaseDebounceMillis: String = "1000",
113 screenBrightnessRampIncrease: String = "0.02",
114 brightnessDecreaseDebounceMillis: String = "3000",
115 screenBrightnessRampDecrease: String = "0.04",
116 minimumHdrPercentOfScreenForNbm: String? = null,
117 minimumHdrPercentOfScreenForHbm: String? = null,
118 allowInLowPowerMode: String? = null,
119 sdrHdrRatioMap: List<Pair<String, String>>? = null,
120 ) {
121 element("hdrBrightnessConfig") {
122 map("brightnessMap", "point", "first", "second", brightnessMap)
123 element("brightnessIncreaseDebounceMillis", brightnessIncreaseDebounceMillis)
124 element("screenBrightnessRampIncrease", screenBrightnessRampIncrease)
125 element("brightnessDecreaseDebounceMillis", brightnessDecreaseDebounceMillis)
126 element("screenBrightnessRampDecrease", screenBrightnessRampDecrease)
127 element("minimumHdrPercentOfScreenForNbm", minimumHdrPercentOfScreenForNbm)
128 element("minimumHdrPercentOfScreenForHbm", minimumHdrPercentOfScreenForHbm)
129 element("allowInLowPowerMode", allowInLowPowerMode)
130 map("sdrHdrRatioMap", "point", "first", "second", sdrHdrRatioMap)
131 }
132 }
133
<lambda>null134 fun createDisplayConfiguration(content: XmlSerializer.() -> Unit = { }): DisplayConfiguration {
135 val byteArrayOutputStream = ByteArrayOutputStream()
136 val xmlSerializer = Xml.newSerializer()
writernull137 OutputStreamWriter(byteArrayOutputStream).use { writer ->
138 xmlSerializer.setOutput(writer)
139 xmlSerializer.startDocument("UTF-8", true)
140 xmlSerializer.startTag("", "displayConfiguration")
141 xmlSerializer.content()
142 xmlSerializer.endTag("", "displayConfiguration")
143 xmlSerializer.endDocument()
144 }
145 return XmlParser.read(ByteArrayInputStream(byteArrayOutputStream.toByteArray()))
146 }
147
mapnull148 private fun XmlSerializer.map(
149 rootName: String,
150 nodeName: String,
151 keyName: String,
152 valueName: String,
153 map: List<Pair<String, String>>?
154 ) {
155 map?.let { m ->
156 element(rootName) {
157 m.forEach { e -> pair(nodeName, keyName, valueName, e) }
158 }
159 }
160 }
161
pairnull162 private fun XmlSerializer.pair(
163 nodeName: String,
164 keyName: String,
165 valueName: String,
166 pair: Pair<String, String>?
167 ) {
168 pair?.let {
169 element(nodeName) {
170 element(keyName, pair.first)
171 element(valueName, pair.second)
172 }
173 }
174 }
175
XmlSerializernull176 private fun XmlSerializer.element(name: String, content: String?) {
177 if (content != null) {
178 startTag("", name)
179 text(content)
180 endTag("", name)
181 }
182 }
183
XmlSerializernull184 private fun XmlSerializer.element(name: String, content: XmlSerializer.() -> Unit) {
185 startTag("", name)
186 content()
187 endTag("", name)
188 }