|
| 1 | +/* |
| 2 | + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0. |
| 3 | + * This product includes software developed at Datadog (https://www.datadoghq.com/). |
| 4 | + * Copyright CHECKBOX_SIZE16-Present Datadog, Inc. |
| 5 | + */ |
| 6 | + |
| 7 | +package com.datadog.android.sessionreplay.compose.internal.mappers.semantics |
| 8 | + |
| 9 | +import androidx.compose.ui.semantics.SemanticsNode |
| 10 | +import androidx.compose.ui.semantics.SemanticsProperties |
| 11 | +import androidx.compose.ui.semantics.getOrNull |
| 12 | +import androidx.compose.ui.state.ToggleableState |
| 13 | +import com.datadog.android.api.InternalLogger |
| 14 | +import com.datadog.android.sessionreplay.ImagePrivacy |
| 15 | +import com.datadog.android.sessionreplay.TextAndInputPrivacy |
| 16 | +import com.datadog.android.sessionreplay.compose.internal.data.SemanticsWireframe |
| 17 | +import com.datadog.android.sessionreplay.compose.internal.data.UiContext |
| 18 | +import com.datadog.android.sessionreplay.compose.internal.utils.ColorUtils |
| 19 | +import com.datadog.android.sessionreplay.compose.internal.utils.PathUtils |
| 20 | +import com.datadog.android.sessionreplay.compose.internal.utils.SemanticsUtils |
| 21 | +import com.datadog.android.sessionreplay.model.MobileSegment |
| 22 | +import com.datadog.android.sessionreplay.utils.AsyncJobStatusCallback |
| 23 | +import com.datadog.android.sessionreplay.utils.ColorStringFormatter |
| 24 | +import com.datadog.android.sessionreplay.utils.GlobalBounds |
| 25 | + |
| 26 | +internal class CheckboxSemanticsNodeMapper( |
| 27 | + colorStringFormatter: ColorStringFormatter, |
| 28 | + private val semanticsUtils: SemanticsUtils = SemanticsUtils(), |
| 29 | + private val colorUtils: ColorUtils = ColorUtils(), |
| 30 | + private val logger: InternalLogger = InternalLogger.UNBOUND, |
| 31 | + private val pathUtils: PathUtils = PathUtils(logger) |
| 32 | +) : AbstractSemanticsNodeMapper(colorStringFormatter, semanticsUtils) { |
| 33 | + |
| 34 | + override fun map( |
| 35 | + semanticsNode: SemanticsNode, |
| 36 | + parentContext: UiContext, |
| 37 | + asyncJobStatusCallback: AsyncJobStatusCallback |
| 38 | + ): SemanticsWireframe { |
| 39 | + val globalBounds = resolveBounds(semanticsNode) |
| 40 | + |
| 41 | + val checkableWireframes = if (isCheckboxMasked(parentContext)) { |
| 42 | + listOf( |
| 43 | + resolveMaskedCheckable( |
| 44 | + semanticsNode = semanticsNode, |
| 45 | + globalBounds = globalBounds |
| 46 | + ) |
| 47 | + ) |
| 48 | + } else { |
| 49 | + createCheckboxWireframes( |
| 50 | + parentContext = parentContext, |
| 51 | + asyncJobStatusCallback = asyncJobStatusCallback, |
| 52 | + semanticsNode = semanticsNode, |
| 53 | + globalBounds = globalBounds, |
| 54 | + currentIndex = 0 |
| 55 | + ) |
| 56 | + } |
| 57 | + |
| 58 | + return SemanticsWireframe( |
| 59 | + uiContext = null, |
| 60 | + wireframes = checkableWireframes |
| 61 | + ) |
| 62 | + } |
| 63 | + |
| 64 | + private fun isCheckboxMasked(parentContext: UiContext): Boolean = |
| 65 | + parentContext.textAndInputPrivacy != TextAndInputPrivacy.MASK_SENSITIVE_INPUTS |
| 66 | + |
| 67 | + private fun resolveMaskedCheckable( |
| 68 | + semanticsNode: SemanticsNode, |
| 69 | + globalBounds: GlobalBounds |
| 70 | + ): MobileSegment.Wireframe { |
| 71 | + // TODO RUM-5118: Decide how to display masked checkbox, Currently use old unchecked shape wireframe, |
| 72 | + return createUncheckedState( |
| 73 | + semanticsNode = semanticsNode, |
| 74 | + globalBounds = globalBounds, |
| 75 | + backgroundColor = DEFAULT_COLOR_WHITE, |
| 76 | + borderColor = DEFAULT_COLOR_BLACK, |
| 77 | + currentIndex = 0 |
| 78 | + ) |
| 79 | + } |
| 80 | + |
| 81 | + private fun createCheckboxWireframes( |
| 82 | + parentContext: UiContext, |
| 83 | + asyncJobStatusCallback: AsyncJobStatusCallback, |
| 84 | + semanticsNode: SemanticsNode, |
| 85 | + globalBounds: GlobalBounds, |
| 86 | + currentIndex: Int |
| 87 | + ): List<MobileSegment.Wireframe> { |
| 88 | + val borderColor = resolveBorderColor(semanticsNode) |
| 89 | + val rawFillColor = semanticsUtils.resolveCheckboxFillColor(semanticsNode) |
| 90 | + val rawCheckmarkColor = semanticsUtils.resolveCheckmarkColor(semanticsNode) |
| 91 | + val fillColorRgba = rawFillColor?.let { convertColor(it) } ?: DEFAULT_COLOR_WHITE |
| 92 | + val checkmarkColorRgba = rawCheckmarkColor?.let { convertColor(it) } |
| 93 | + ?: getFallbackCheckmarkColor(DEFAULT_COLOR_WHITE) |
| 94 | + val parsedFillColor = colorUtils.parseColorSafe(fillColorRgba) |
| 95 | + val isChecked = isCheckboxChecked(semanticsNode) |
| 96 | + val checkmarkColor = resolveCheckmarkColor(isChecked, checkmarkColorRgba, parsedFillColor) |
| 97 | + |
| 98 | + val wireframes = mutableListOf<MobileSegment.Wireframe>() |
| 99 | + |
| 100 | + if (parsedFillColor != null && checkmarkColor != null) { |
| 101 | + val composePath = semanticsUtils |
| 102 | + .resolveCheckPath(semanticsNode) |
| 103 | + |
| 104 | + val androidPath = composePath?.let { checkPath -> |
| 105 | + pathUtils.asAndroidPathSafe(checkPath) |
| 106 | + } |
| 107 | + |
| 108 | + if (androidPath != null) { |
| 109 | + parentContext.imageWireframeHelper.createImageWireframeByPath( |
| 110 | + id = resolveId(semanticsNode, currentIndex), |
| 111 | + globalBounds = globalBounds, |
| 112 | + path = androidPath, |
| 113 | + strokeColor = checkmarkColor, |
| 114 | + strokeWidth = STROKE_WIDTH_DP.toInt(), |
| 115 | + targetWidth = CHECKBOX_SIZE_DP, |
| 116 | + targetHeight = CHECKBOX_SIZE_DP, |
| 117 | + density = parentContext.density, |
| 118 | + isContextualImage = false, |
| 119 | + imagePrivacy = ImagePrivacy.MASK_NONE, |
| 120 | + asyncJobStatusCallback = asyncJobStatusCallback, |
| 121 | + clipping = null, |
| 122 | + shapeStyle = MobileSegment.ShapeStyle( |
| 123 | + backgroundColor = fillColorRgba, |
| 124 | + opacity = 1f, |
| 125 | + cornerRadius = CHECKBOX_CORNER_RADIUS |
| 126 | + ), |
| 127 | + border = MobileSegment.ShapeBorder( |
| 128 | + color = borderColor, |
| 129 | + width = BOX_BORDER_WIDTH_DP |
| 130 | + ), |
| 131 | + customResourceIdCacheKey = null |
| 132 | + )?.let { imageWireframe -> |
| 133 | + wireframes.add(imageWireframe) |
| 134 | + } |
| 135 | + } |
| 136 | + } |
| 137 | + |
| 138 | + if (wireframes.isNotEmpty()) { |
| 139 | + return wireframes |
| 140 | + } |
| 141 | + |
| 142 | + // if we failed to create a wireframe from the path |
| 143 | + return createManualCheckedWireframes( |
| 144 | + semanticsNode = semanticsNode, |
| 145 | + globalBounds = globalBounds, |
| 146 | + backgroundColor = fillColorRgba, |
| 147 | + borderColor = borderColor |
| 148 | + ) |
| 149 | + } |
| 150 | + |
| 151 | + private fun resolveCheckmarkColor(isChecked: Boolean, checkmarkColorRgba: String, fillColor: Int?): Int? = |
| 152 | + if (isChecked) { |
| 153 | + colorUtils.parseColorSafe(checkmarkColorRgba) |
| 154 | + } else { |
| 155 | + fillColor |
| 156 | + } |
| 157 | + |
| 158 | + private fun resolveBorderColor(semanticsNode: SemanticsNode): String { |
| 159 | + return semanticsUtils.resolveBorderColor(semanticsNode) |
| 160 | + ?.let { rawColor -> |
| 161 | + convertColor(rawColor) |
| 162 | + } ?: DEFAULT_COLOR_BLACK |
| 163 | + } |
| 164 | + |
| 165 | + private fun createManualCheckedWireframes( |
| 166 | + semanticsNode: SemanticsNode, |
| 167 | + globalBounds: GlobalBounds, |
| 168 | + backgroundColor: String, |
| 169 | + borderColor: String |
| 170 | + ): List<MobileSegment.Wireframe> { |
| 171 | + val strokeColor = getFallbackCheckmarkColor(backgroundColor) |
| 172 | + |
| 173 | + val wireframes = mutableListOf<MobileSegment.Wireframe>() |
| 174 | + |
| 175 | + val background = createUncheckedState( |
| 176 | + semanticsNode = semanticsNode, |
| 177 | + globalBounds = globalBounds, |
| 178 | + backgroundColor = backgroundColor, |
| 179 | + borderColor = borderColor, |
| 180 | + currentIndex = 0 |
| 181 | + ) |
| 182 | + |
| 183 | + wireframes.add(background) |
| 184 | + |
| 185 | + val checkmarkWidth = globalBounds.width * CHECKMARK_SIZE_FACTOR |
| 186 | + val checkmarkHeight = globalBounds.height * CHECKMARK_SIZE_FACTOR |
| 187 | + val xPos = globalBounds.x + ((globalBounds.width / 2) - (checkmarkWidth / 2)) |
| 188 | + val yPos = globalBounds.y + ((globalBounds.height / 2) - (checkmarkHeight / 2)) |
| 189 | + val foreground = MobileSegment.Wireframe.ShapeWireframe( |
| 190 | + id = resolveId(semanticsNode, 1), |
| 191 | + x = xPos.toLong(), |
| 192 | + y = yPos.toLong(), |
| 193 | + width = checkmarkWidth.toLong(), |
| 194 | + height = checkmarkHeight.toLong(), |
| 195 | + shapeStyle = MobileSegment.ShapeStyle( |
| 196 | + backgroundColor = strokeColor, |
| 197 | + opacity = 1f, |
| 198 | + cornerRadius = CHECKBOX_CORNER_RADIUS |
| 199 | + ), |
| 200 | + border = MobileSegment.ShapeBorder( |
| 201 | + color = DEFAULT_COLOR_BLACK, |
| 202 | + width = BOX_BORDER_WIDTH_DP |
| 203 | + ) |
| 204 | + ) |
| 205 | + |
| 206 | + wireframes.add(foreground) |
| 207 | + return wireframes |
| 208 | + } |
| 209 | + |
| 210 | + private fun createUncheckedState( |
| 211 | + semanticsNode: SemanticsNode, |
| 212 | + globalBounds: GlobalBounds, |
| 213 | + backgroundColor: String, |
| 214 | + borderColor: String, |
| 215 | + currentIndex: Int |
| 216 | + ) = MobileSegment.Wireframe.ShapeWireframe( |
| 217 | + id = resolveId(semanticsNode, currentIndex), |
| 218 | + x = globalBounds.x, |
| 219 | + y = globalBounds.y, |
| 220 | + width = CHECKBOX_SIZE_DP.toLong(), |
| 221 | + height = CHECKBOX_SIZE_DP.toLong(), |
| 222 | + shapeStyle = MobileSegment.ShapeStyle( |
| 223 | + backgroundColor = backgroundColor, |
| 224 | + opacity = 1f, |
| 225 | + cornerRadius = CHECKBOX_CORNER_RADIUS |
| 226 | + ), |
| 227 | + border = MobileSegment.ShapeBorder( |
| 228 | + color = borderColor, |
| 229 | + width = BOX_BORDER_WIDTH_DP |
| 230 | + ) |
| 231 | + ) |
| 232 | + |
| 233 | + private fun isCheckboxChecked(semanticsNode: SemanticsNode): Boolean = |
| 234 | + semanticsNode.config.getOrNull(SemanticsProperties.ToggleableState) == ToggleableState.On |
| 235 | + |
| 236 | + private fun getFallbackCheckmarkColor(backgroundColor: String?) = |
| 237 | + if (backgroundColor == DEFAULT_COLOR_WHITE) { |
| 238 | + DEFAULT_COLOR_BLACK |
| 239 | + } else { |
| 240 | + DEFAULT_COLOR_WHITE |
| 241 | + } |
| 242 | + |
| 243 | + internal companion object { |
| 244 | + internal const val DEFAULT_COLOR_BLACK = "#000000FF" |
| 245 | + internal const val DEFAULT_COLOR_WHITE = "#FFFFFFFF" |
| 246 | + |
| 247 | + // when we create the checkmark manually, what % of the checkbox size should it be |
| 248 | + internal const val CHECKMARK_SIZE_FACTOR = 0.5 |
| 249 | + |
| 250 | + // values from Compose Checkbox sourcecode |
| 251 | + internal const val BOX_BORDER_WIDTH_DP = 2L |
| 252 | + internal const val STROKE_WIDTH_DP = 2f |
| 253 | + internal const val CHECKBOX_SIZE_DP = 20 |
| 254 | + internal const val CHECKBOX_CORNER_RADIUS = 2f |
| 255 | + } |
| 256 | +} |
0 commit comments