Re-sync with internal repository
This commit is contained in:
Facebook Community Bot
@@ -0,0 +1,5 @@
|
||||
This is a check-in of https://android.googlesource.com/platform/frameworks/support/+/refs/heads/androidx-main/compose/ui/ui-inspection/src/main/java/androidx/compose/ui/inspection
|
||||
|
||||
The classes are currently not exported but we rely on them for debug information.
|
||||
|
||||
Tree: 59746be8ea17d5753471bd285b3fbc9cf8ea7c31
|
||||
@@ -0,0 +1,60 @@
|
||||
/*
|
||||
* Copyright 2020 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
/**
|
||||
* Converter for casting a parameter represented by its primitive value to its inline class type.
|
||||
*
|
||||
* For example: an androidx.compose.ui.graphics.Color instance is often represented by a long
|
||||
*/
|
||||
internal class InlineClassConverter {
|
||||
// Map from inline type name to inline class and conversion lambda
|
||||
private val typeMap = mutableMapOf<String, (Any) -> Any>()
|
||||
// Return value used in functions
|
||||
private val notInlineType: (Any) -> Any = { it }
|
||||
|
||||
/** Clear any cached data. */
|
||||
fun clear() {
|
||||
typeMap.clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* Cast the specified [value] to a value of type [inlineClassName] if possible.
|
||||
*
|
||||
* @param inlineClassName the fully qualified name of the inline class.
|
||||
* @param value the value to convert to an instance of [inlineClassName].
|
||||
*/
|
||||
fun castParameterValue(inlineClassName: String?, value: Any?): Any? =
|
||||
if (value != null && inlineClassName != null) typeMapperFor(inlineClassName)(value) else value
|
||||
|
||||
private fun typeMapperFor(typeName: String): (Any) -> (Any) =
|
||||
typeMap.getOrPut(typeName) { loadTypeMapper(typeName.replace('.', '/')) }
|
||||
|
||||
private fun loadTypeMapper(className: String): (Any) -> Any {
|
||||
val javaClass = loadClassOrNull(className) ?: return notInlineType
|
||||
val create = javaClass.declaredConstructors.singleOrNull() ?: return notInlineType
|
||||
create.isAccessible = true
|
||||
return { value -> create.newInstance(value) }
|
||||
}
|
||||
|
||||
private fun loadClassOrNull(className: String): Class<*>? =
|
||||
try {
|
||||
javaClass.classLoader!!.loadClass(className)
|
||||
} catch (ex: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
/*
|
||||
* Copyright 2020 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
import androidx.compose.ui.layout.LayoutInfo
|
||||
import androidx.compose.ui.unit.IntRect
|
||||
|
||||
internal const val UNDEFINED_ID = 0L
|
||||
|
||||
internal val emptyBox = IntRect(0, 0, 0, 0)
|
||||
internal val outsideBox = IntRect(Int.MAX_VALUE, Int.MIN_VALUE, Int.MAX_VALUE, Int.MIN_VALUE)
|
||||
|
||||
/** Node representing a Composable for the Layout Inspector. */
|
||||
class InspectorNode
|
||||
internal constructor(
|
||||
/** The associated render node id or 0. */
|
||||
val id: Long,
|
||||
|
||||
/** The associated key for tracking recomposition counts. */
|
||||
val key: Int,
|
||||
|
||||
/**
|
||||
* The id of the associated anchor for tracking recomposition counts.
|
||||
*
|
||||
* An Anchor is a mechanism in the compose runtime that can identify a Group in the SlotTable
|
||||
* that is invariant to SlotTable updates. See [androidx.compose.runtime.Anchor] for more
|
||||
* information.
|
||||
*/
|
||||
val anchorId: Int,
|
||||
|
||||
/** The name of the Composable. */
|
||||
val name: String,
|
||||
|
||||
/** The fileName where the Composable was called. */
|
||||
val fileName: String,
|
||||
|
||||
/**
|
||||
* A hash of the package name to help disambiguate duplicate [fileName] values.
|
||||
*
|
||||
* This hash is calculated by,
|
||||
*
|
||||
* `packageName.fold(0) { hash, current -> hash * 31 + current.toInt() }?.absoluteValue`
|
||||
*
|
||||
* where the package name is the dotted name of the package. This can be used to disambiguate
|
||||
* which file is referenced by [fileName]. This number is -1 if there was no package hash
|
||||
* information generated such as when the file does not contain a package declaration.
|
||||
*/
|
||||
val packageHash: Int,
|
||||
|
||||
/** The line number where the Composable was called. */
|
||||
val lineNumber: Int,
|
||||
|
||||
/** The UTF-16 offset in the file where the Composable was called */
|
||||
val offset: Int,
|
||||
|
||||
/** The number of UTF-16 code point comprise the Composable call */
|
||||
val length: Int,
|
||||
|
||||
/** The bounding box of the Composable. */
|
||||
internal val box: IntRect,
|
||||
|
||||
/** The 4 corners of the polygon after transformations of the original rectangle. */
|
||||
val bounds: QuadBounds? = null,
|
||||
|
||||
/** True if the code for the Composable was inlined */
|
||||
val inlined: Boolean = false,
|
||||
|
||||
/** The parameters of this Composable. */
|
||||
val parameters: List<RawParameter>,
|
||||
|
||||
/** The id of a android View embedded under this node. */
|
||||
val viewId: Long,
|
||||
|
||||
/** The merged semantics information of this Composable. */
|
||||
val mergedSemantics: List<RawParameter>,
|
||||
|
||||
/** The un-merged semantics information of this Composable. */
|
||||
val unmergedSemantics: List<RawParameter>,
|
||||
|
||||
/** The children nodes of this Composable. */
|
||||
val children: List<InspectorNode>
|
||||
) {
|
||||
/** Left side of the Composable in pixels. */
|
||||
val left: Int
|
||||
get() = box.left
|
||||
|
||||
/** Top of the Composable in pixels. */
|
||||
val top: Int
|
||||
get() = box.top
|
||||
|
||||
/** Width of the Composable in pixels. */
|
||||
val width: Int
|
||||
get() = box.width
|
||||
|
||||
/** Width of the Composable in pixels. */
|
||||
val height: Int
|
||||
get() = box.height
|
||||
|
||||
fun parametersByKind(kind: ParameterKind): List<RawParameter> =
|
||||
when (kind) {
|
||||
ParameterKind.Normal -> parameters
|
||||
ParameterKind.MergedSemantics -> mergedSemantics
|
||||
ParameterKind.UnmergedSemantics -> unmergedSemantics
|
||||
}
|
||||
}
|
||||
|
||||
data class QuadBounds(
|
||||
val x0: Int,
|
||||
val y0: Int,
|
||||
val x1: Int,
|
||||
val y1: Int,
|
||||
val x2: Int,
|
||||
val y2: Int,
|
||||
val x3: Int,
|
||||
val y3: Int,
|
||||
) {
|
||||
val xMin: Int
|
||||
get() = sequenceOf(x0, x1, x2, x3).minOrNull()!!
|
||||
|
||||
val xMax: Int
|
||||
get() = sequenceOf(x0, x1, x2, x3).maxOrNull()!!
|
||||
|
||||
val yMin: Int
|
||||
get() = sequenceOf(y0, y1, y2, y3).minOrNull()!!
|
||||
|
||||
val yMax: Int
|
||||
get() = sequenceOf(y0, y1, y2, y3).maxOrNull()!!
|
||||
|
||||
val outerBox: IntRect
|
||||
get() = IntRect(xMin, yMin, xMax, yMax)
|
||||
}
|
||||
|
||||
/** Parameter definition with a raw value reference. */
|
||||
class RawParameter(val name: String, val value: Any?)
|
||||
|
||||
/** Mutable version of [InspectorNode]. */
|
||||
internal class MutableInspectorNode {
|
||||
var id = UNDEFINED_ID
|
||||
var key = 0
|
||||
var anchorId = 0
|
||||
val layoutNodes = mutableListOf<LayoutInfo>()
|
||||
val mergedSemantics = mutableListOf<RawParameter>()
|
||||
val unmergedSemantics = mutableListOf<RawParameter>()
|
||||
var name = ""
|
||||
var fileName = ""
|
||||
var packageHash = -1
|
||||
var lineNumber = 0
|
||||
var offset = 0
|
||||
var length = 0
|
||||
var box: IntRect = emptyBox
|
||||
var bounds: QuadBounds? = null
|
||||
var inlined = false
|
||||
val parameters = mutableListOf<RawParameter>()
|
||||
var viewId = UNDEFINED_ID
|
||||
val children = mutableListOf<InspectorNode>()
|
||||
var outerBox: IntRect = outsideBox
|
||||
|
||||
fun reset() {
|
||||
markUnwanted()
|
||||
id = UNDEFINED_ID
|
||||
key = 0
|
||||
anchorId = 0
|
||||
viewId = UNDEFINED_ID
|
||||
layoutNodes.clear()
|
||||
mergedSemantics.clear()
|
||||
unmergedSemantics.clear()
|
||||
box = emptyBox
|
||||
bounds = null
|
||||
inlined = false
|
||||
outerBox = outsideBox
|
||||
children.clear()
|
||||
}
|
||||
|
||||
fun markUnwanted() {
|
||||
name = ""
|
||||
fileName = ""
|
||||
packageHash = -1
|
||||
lineNumber = 0
|
||||
offset = 0
|
||||
length = 0
|
||||
parameters.clear()
|
||||
}
|
||||
|
||||
fun shallowCopy(node: InspectorNode): MutableInspectorNode = apply {
|
||||
id = node.id
|
||||
key = node.key
|
||||
anchorId = node.anchorId
|
||||
mergedSemantics.addAll(node.mergedSemantics)
|
||||
unmergedSemantics.addAll(node.unmergedSemantics)
|
||||
name = node.name
|
||||
fileName = node.fileName
|
||||
packageHash = node.packageHash
|
||||
lineNumber = node.lineNumber
|
||||
offset = node.offset
|
||||
length = node.length
|
||||
box = node.box
|
||||
bounds = node.bounds
|
||||
inlined = node.inlined
|
||||
parameters.addAll(node.parameters)
|
||||
viewId = node.viewId
|
||||
children.addAll(node.children)
|
||||
}
|
||||
|
||||
fun build(withSemantics: Boolean = true): InspectorNode =
|
||||
InspectorNode(
|
||||
id,
|
||||
key,
|
||||
anchorId,
|
||||
name,
|
||||
fileName,
|
||||
packageHash,
|
||||
lineNumber,
|
||||
offset,
|
||||
length,
|
||||
box,
|
||||
bounds,
|
||||
inlined,
|
||||
parameters.toList(),
|
||||
viewId,
|
||||
if (withSemantics) mergedSemantics.toList() else emptyList(),
|
||||
if (withSemantics) unmergedSemantics.toList() else emptyList(),
|
||||
children.toList())
|
||||
}
|
||||
@@ -0,0 +1,827 @@
|
||||
/*
|
||||
* Copyright 2020 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
import android.view.View
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import androidx.compose.runtime.tooling.CompositionData
|
||||
import androidx.compose.runtime.tooling.CompositionGroup
|
||||
import androidx.compose.ui.InternalComposeUiApi
|
||||
import androidx.compose.ui.R
|
||||
import androidx.compose.ui.geometry.Offset
|
||||
import androidx.compose.ui.layout.GraphicLayerInfo
|
||||
import androidx.compose.ui.layout.LayoutInfo
|
||||
import androidx.compose.ui.node.InteroperableComposeUiNode
|
||||
import androidx.compose.ui.node.Ref
|
||||
import androidx.compose.ui.node.RootForTest
|
||||
import androidx.compose.ui.platform.ViewRootForInspector
|
||||
import androidx.compose.ui.semantics.getAllSemanticsNodes
|
||||
import androidx.compose.ui.tooling.data.ContextCache
|
||||
import androidx.compose.ui.tooling.data.ParameterInformation
|
||||
import androidx.compose.ui.tooling.data.SourceContext
|
||||
import androidx.compose.ui.tooling.data.SourceLocation
|
||||
import androidx.compose.ui.tooling.data.UiToolingDataApi
|
||||
import androidx.compose.ui.tooling.data.findParameters
|
||||
import androidx.compose.ui.tooling.data.mapTree
|
||||
import androidx.compose.ui.unit.Density
|
||||
import androidx.compose.ui.unit.IntOffset
|
||||
import androidx.compose.ui.unit.IntRect
|
||||
import androidx.compose.ui.unit.IntSize
|
||||
import androidx.compose.ui.unit.toSize
|
||||
import facebook.internal.androidx.compose.ui.inspection.util.AnchorMap
|
||||
import facebook.internal.androidx.compose.ui.inspection.util.NO_ANCHOR_ID
|
||||
import java.util.ArrayDeque
|
||||
import java.util.Collections
|
||||
import java.util.IdentityHashMap
|
||||
import kotlin.math.max
|
||||
import kotlin.math.min
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
/**
|
||||
* The [InspectorNode.id] will be populated with:
|
||||
* - the layerId from a LayoutNode if this exists
|
||||
* - an id generated from an Anchor instance from the SlotTree if this exists
|
||||
* - a generated id if none of the above ids are available
|
||||
*
|
||||
* The interval -10000..-2 is reserved for the generated ids.
|
||||
*/
|
||||
@VisibleForTesting const val RESERVED_FOR_GENERATED_IDS = -10000L
|
||||
const val PLACEHOLDER_ID = Long.MAX_VALUE
|
||||
|
||||
private val emptySize = IntSize(0, 0)
|
||||
|
||||
private val unwantedCalls =
|
||||
setOf(
|
||||
"CompositionLocalProvider",
|
||||
"Content",
|
||||
"Inspectable",
|
||||
"ProvideAndroidCompositionLocals",
|
||||
"ProvideCommonCompositionLocals",
|
||||
)
|
||||
|
||||
/** Generator of a tree for the Layout Inspector. */
|
||||
@OptIn(UiToolingDataApi::class)
|
||||
class LayoutInspectorTree {
|
||||
@Suppress("MemberVisibilityCanBePrivate") var hideSystemNodes = true
|
||||
var includeNodesOutsizeOfWindow = true
|
||||
var includeAllParameters = true
|
||||
private var foundNode: InspectorNode? = null
|
||||
private var windowSize = emptySize
|
||||
private val inlineClassConverter = InlineClassConverter()
|
||||
private val parameterFactory = ParameterFactory(inlineClassConverter)
|
||||
private val cache = ArrayDeque<MutableInspectorNode>()
|
||||
private var generatedId = -1L
|
||||
private val subCompositions = SubCompositionRoots()
|
||||
/** Map from [LayoutInfo] to the nearest [InspectorNode] that contains it */
|
||||
private val claimedNodes = IdentityHashMap<LayoutInfo, InspectorNode>()
|
||||
/** Map from parent tree to child trees that are about to be stitched together */
|
||||
private val treeMap = IdentityHashMap<MutableInspectorNode, MutableList<MutableInspectorNode>>()
|
||||
/** Map from owner node to child trees that are about to be stitched to this owner */
|
||||
private val ownerMap = IdentityHashMap<InspectorNode, MutableList<MutableInspectorNode>>()
|
||||
/** Map from semantics id to a list of merged semantics information */
|
||||
private val semanticsMap = mutableMapOf<Int, List<RawParameter>>()
|
||||
/* Map of seemantics id to a list of unmerged semantics information */
|
||||
private val unmergedSemanticsMap = mutableMapOf<Int, List<RawParameter>>()
|
||||
/** Set of tree nodes that were stitched into another tree */
|
||||
private val stitched = Collections.newSetFromMap(IdentityHashMap<MutableInspectorNode, Boolean>())
|
||||
private val contextCache = ContextCache()
|
||||
private val anchorMap = AnchorMap()
|
||||
|
||||
/** Converts the [CompositionData] set held by [view] into a list of root nodes. */
|
||||
fun convert(view: View): List<InspectorNode> {
|
||||
windowSize = IntSize(view.width, view.height)
|
||||
parameterFactory.density = Density(view.context)
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val tables =
|
||||
view.getTag(R.id.inspection_slot_table_set) as? Set<CompositionData> ?: return emptyList()
|
||||
clear()
|
||||
collectSemantics(view)
|
||||
val result = convert(tables, view)
|
||||
clear()
|
||||
return result
|
||||
}
|
||||
|
||||
fun findParameters(view: View, anchorId: Int): InspectorNode? {
|
||||
windowSize = IntSize(view.width, view.height)
|
||||
parameterFactory.density = Density(view.context)
|
||||
val identity = anchorMap[anchorId] ?: return null
|
||||
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
val tables = view.getTag(R.id.inspection_slot_table_set) as? Set<CompositionData> ?: return null
|
||||
val node = newNode().apply { this.anchorId = anchorId }
|
||||
val group = tables.firstNotNullOfOrNull { it.find(identity) } ?: return null
|
||||
group.findParameters(contextCache).forEach {
|
||||
val castedValue = castValue(it)
|
||||
node.parameters.add(RawParameter(it.name, castedValue))
|
||||
}
|
||||
return buildAndRelease(node)
|
||||
}
|
||||
|
||||
/**
|
||||
* Add the roots to sub compositions that may have been collected from a different SlotTree.
|
||||
*
|
||||
* See [SubCompositionRoots] for details.
|
||||
*/
|
||||
fun addSubCompositionRoots(view: View, nodes: List<InspectorNode>): List<InspectorNode> =
|
||||
subCompositions.addRoot(view, nodes)
|
||||
|
||||
/**
|
||||
* Extract the merged semantics for this semantics owner such that they can be added to compose
|
||||
* nodes during the conversion of Group nodes.
|
||||
*/
|
||||
private fun collectSemantics(view: View) {
|
||||
val root = view as? RootForTest ?: return
|
||||
val nodes = root.semanticsOwner.getAllSemanticsNodes(mergingEnabled = true)
|
||||
val unmergedNodes = root.semanticsOwner.getAllSemanticsNodes(mergingEnabled = false)
|
||||
nodes.forEach { node ->
|
||||
semanticsMap[node.id] = node.config.map { RawParameter(it.key.name, it.value) }
|
||||
}
|
||||
unmergedNodes.forEach { node ->
|
||||
unmergedSemanticsMap[node.id] = node.config.map { RawParameter(it.key.name, it.value) }
|
||||
}
|
||||
}
|
||||
|
||||
/** Converts the [RawParameter]s of the [node] into displayable parameters. */
|
||||
fun convertParameters(
|
||||
rootId: Long,
|
||||
node: InspectorNode,
|
||||
kind: ParameterKind,
|
||||
maxRecursions: Int,
|
||||
maxInitialIterableSize: Int
|
||||
): List<NodeParameter> {
|
||||
val parameters = node.parametersByKind(kind)
|
||||
return parameters.mapIndexed { index, parameter ->
|
||||
parameterFactory.create(
|
||||
rootId,
|
||||
node.id,
|
||||
node.anchorId,
|
||||
parameter.name,
|
||||
parameter.value,
|
||||
kind,
|
||||
index,
|
||||
maxRecursions,
|
||||
maxInitialIterableSize)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a part of the [RawParameter] identified by [reference] into a displayable parameter.
|
||||
* If the parameter is some sort of a collection then [startIndex] and [maxElements] describes the
|
||||
* scope of the data returned.
|
||||
*/
|
||||
fun expandParameter(
|
||||
rootId: Long,
|
||||
node: InspectorNode,
|
||||
reference: NodeParameterReference,
|
||||
startIndex: Int,
|
||||
maxElements: Int,
|
||||
maxRecursions: Int,
|
||||
maxInitialIterableSize: Int
|
||||
): NodeParameter? {
|
||||
val parameters = node.parametersByKind(reference.kind)
|
||||
if (reference.parameterIndex !in parameters.indices) {
|
||||
return null
|
||||
}
|
||||
val parameter = parameters[reference.parameterIndex]
|
||||
return parameterFactory.expand(
|
||||
rootId,
|
||||
node.id,
|
||||
node.anchorId,
|
||||
parameter.name,
|
||||
parameter.value,
|
||||
reference,
|
||||
startIndex,
|
||||
maxElements,
|
||||
maxRecursions,
|
||||
maxInitialIterableSize)
|
||||
}
|
||||
|
||||
/** Reset any state accumulated between windows. */
|
||||
@Suppress("unused")
|
||||
fun resetAccumulativeState() {
|
||||
subCompositions.resetAccumulativeState()
|
||||
parameterFactory.clearReferenceCache()
|
||||
// Reset the generated id. Nodes are assigned an id if there isn't a layout node id present.
|
||||
generatedId = -1L
|
||||
}
|
||||
|
||||
private fun clear() {
|
||||
cache.clear()
|
||||
inlineClassConverter.clear()
|
||||
claimedNodes.clear()
|
||||
treeMap.clear()
|
||||
ownerMap.clear()
|
||||
semanticsMap.clear()
|
||||
unmergedSemanticsMap.clear()
|
||||
stitched.clear()
|
||||
subCompositions.clear()
|
||||
foundNode = null
|
||||
}
|
||||
|
||||
private fun convert(tables: Set<CompositionData>, view: View): List<InspectorNode> {
|
||||
val trees = tables.mapNotNull { convert(view, it) }
|
||||
return when (trees.size) {
|
||||
0 -> listOf()
|
||||
1 -> addTree(mutableListOf(), trees.single())
|
||||
else -> stitchTreesByLayoutInfo(trees)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stitch separate trees together using the [LayoutInfo]s found in the [CompositionData]s.
|
||||
*
|
||||
* Some constructs in Compose (e.g. ModalDrawer) will result is multiple [CompositionData]s. This
|
||||
* code will attempt to stitch the resulting [InspectorNode] trees together by looking at the
|
||||
* parent of each [LayoutInfo].
|
||||
*
|
||||
* If this algorithm is successful the result of this function will be a list with a single tree.
|
||||
*/
|
||||
private fun stitchTreesByLayoutInfo(trees: List<MutableInspectorNode>): List<InspectorNode> {
|
||||
val layoutToTreeMap = IdentityHashMap<LayoutInfo, MutableInspectorNode>()
|
||||
trees.forEach { tree -> tree.layoutNodes.forEach { layoutToTreeMap[it] = tree } }
|
||||
trees.forEach { tree ->
|
||||
val layout = tree.layoutNodes.lastOrNull()
|
||||
val parentLayout =
|
||||
generateSequence(layout) { it.parentInfo }
|
||||
.firstOrNull {
|
||||
val otherTree = layoutToTreeMap[it]
|
||||
otherTree != null && otherTree != tree
|
||||
}
|
||||
if (parentLayout != null) {
|
||||
val ownerNode = claimedNodes[parentLayout]
|
||||
val ownerTree = layoutToTreeMap[parentLayout]
|
||||
if (ownerNode != null && ownerTree != null) {
|
||||
ownerMap.getOrPut(ownerNode) { mutableListOf() }.add(tree)
|
||||
treeMap.getOrPut(ownerTree) { mutableListOf() }.add(tree)
|
||||
}
|
||||
}
|
||||
}
|
||||
var parentTree = findDeepParentTree()
|
||||
while (parentTree != null) {
|
||||
addSubTrees(parentTree)
|
||||
treeMap.remove(parentTree)
|
||||
parentTree = findDeepParentTree()
|
||||
}
|
||||
val result = mutableListOf<InspectorNode>()
|
||||
trees.asSequence().filter { !stitched.contains(it) }.forEach { addTree(result, it) }
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a parent tree where the children trees (to be stitched under the parent) are not a
|
||||
* parent themselves. Do this to avoid rebuilding the same tree more than once.
|
||||
*/
|
||||
private fun findDeepParentTree(): MutableInspectorNode? =
|
||||
treeMap.entries
|
||||
.asSequence()
|
||||
.filter { (_, children) -> children.none { treeMap.containsKey(it) } }
|
||||
.firstOrNull()
|
||||
?.key
|
||||
|
||||
private fun addSubTrees(tree: MutableInspectorNode) {
|
||||
for ((index, child) in tree.children.withIndex()) {
|
||||
tree.children[index] = addSubTrees(child) ?: child
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebuild [node] with any possible sub trees added (stitched in). Return the rebuild node, or
|
||||
* null if no changes were found in this node or its children. Lazily allocate the new node to
|
||||
* avoid unnecessary allocations.
|
||||
*/
|
||||
private fun addSubTrees(node: InspectorNode): InspectorNode? {
|
||||
var newNode: MutableInspectorNode? = null
|
||||
for ((index, child) in node.children.withIndex()) {
|
||||
val newChild = addSubTrees(child)
|
||||
if (newChild != null) {
|
||||
val newCopy = newNode ?: newNode(node)
|
||||
newCopy.children[index] = newChild
|
||||
newNode = newCopy
|
||||
}
|
||||
}
|
||||
val trees = ownerMap[node]
|
||||
if (trees == null && newNode == null) {
|
||||
return null
|
||||
}
|
||||
val newCopy = newNode ?: newNode(node)
|
||||
if (trees != null) {
|
||||
trees.forEach { addTree(newCopy.children, it) }
|
||||
stitched.addAll(trees)
|
||||
}
|
||||
return buildAndRelease(newCopy)
|
||||
}
|
||||
|
||||
/**
|
||||
* Add [tree] to the end of the [out] list. The root nodes of [tree] may be a fake node that hold
|
||||
* a list of [LayoutInfo].
|
||||
*/
|
||||
private fun addTree(
|
||||
out: MutableList<InspectorNode>,
|
||||
tree: MutableInspectorNode
|
||||
): List<InspectorNode> {
|
||||
tree.children.forEach {
|
||||
if (it.name.isNotEmpty()) {
|
||||
out.add(it)
|
||||
} else {
|
||||
out.addAll(it.children)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
private fun convert(view: View, table: CompositionData): MutableInspectorNode? {
|
||||
val fakeParent = newNode()
|
||||
val group = table.mapTree(::convert, contextCache) ?: return null
|
||||
addToParent(fakeParent, listOf(group), buildFakeChildNodes = true)
|
||||
return if (belongsToView(fakeParent.layoutNodes, view)) fakeParent else null
|
||||
}
|
||||
|
||||
private fun convert(
|
||||
group: CompositionGroup,
|
||||
context: SourceContext,
|
||||
children: List<MutableInspectorNode>
|
||||
): MutableInspectorNode {
|
||||
val parent = parse(group, context, children)
|
||||
subCompositions.captureNode(parent, context)
|
||||
addToParent(parent, children)
|
||||
return parent
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the nodes in [input] to the children of [parentNode]. Nodes without a reference to a
|
||||
* wanted Composable are skipped unless [buildFakeChildNodes]. A single skipped render id and
|
||||
* layoutNode will be added to [parentNode].
|
||||
*/
|
||||
private fun addToParent(
|
||||
parentNode: MutableInspectorNode,
|
||||
input: List<MutableInspectorNode>,
|
||||
buildFakeChildNodes: Boolean = false
|
||||
) {
|
||||
// If we're adding an unwanted node from the `input` to the parent node and it has a
|
||||
// View ID, then assign it to the parent view so that we don't lose the context that we
|
||||
// found a View as a descendant of the parent node. Most likely, there were one or more
|
||||
// unwanted intermediate nodes between the node that actually owns the Android View
|
||||
// and the desired node that the View should be associated with in the inspector. If
|
||||
// there's more than one input node with a View ID, we skip this step since it's
|
||||
// unclear how these views would be related.
|
||||
input
|
||||
.singleOrNull { it.viewId != UNDEFINED_ID }
|
||||
?.takeIf { node ->
|
||||
// Take if the node has been marked as unwanted
|
||||
node.id == UNDEFINED_ID
|
||||
}
|
||||
?.let { nodeWithView -> parentNode.viewId = nodeWithView.viewId }
|
||||
|
||||
var id: Long? = null
|
||||
input.forEach { node ->
|
||||
if (node.name.isEmpty() && !(buildFakeChildNodes && node.layoutNodes.isNotEmpty())) {
|
||||
parentNode.children.addAll(node.children)
|
||||
if (node.id > UNDEFINED_ID) {
|
||||
// If multiple siblings with a render ids are dropped:
|
||||
// Ignore them all. And delegate the drawing to a parent in the inspector.
|
||||
id = if (id == null) node.id else UNDEFINED_ID
|
||||
}
|
||||
} else {
|
||||
node.id = if (node.id != UNDEFINED_ID) node.id else --generatedId
|
||||
val withSemantics = node.packageHash !in systemPackages
|
||||
val resultNode = node.build(withSemantics)
|
||||
// TODO: replace getOrPut with putIfAbsent which requires API level 24
|
||||
node.layoutNodes.forEach { claimedNodes.getOrPut(it) { resultNode } }
|
||||
parentNode.children.add(resultNode)
|
||||
if (withSemantics) {
|
||||
node.mergedSemantics.clear()
|
||||
node.unmergedSemantics.clear()
|
||||
}
|
||||
}
|
||||
if (node.bounds != null && parentNode.box == node.box) {
|
||||
parentNode.bounds = node.bounds
|
||||
}
|
||||
parentNode.layoutNodes.addAll(node.layoutNodes)
|
||||
parentNode.mergedSemantics.addAll(node.mergedSemantics)
|
||||
parentNode.unmergedSemantics.addAll(node.unmergedSemantics)
|
||||
release(node)
|
||||
}
|
||||
val nodeId = id
|
||||
parentNode.id = if (parentNode.id <= UNDEFINED_ID && nodeId != null) nodeId else parentNode.id
|
||||
}
|
||||
|
||||
@OptIn(InternalComposeUiApi::class)
|
||||
private fun parse(
|
||||
group: CompositionGroup,
|
||||
context: SourceContext,
|
||||
children: List<MutableInspectorNode>
|
||||
): MutableInspectorNode {
|
||||
val node = newNode()
|
||||
node.name = context.name ?: ""
|
||||
node.key = group.key as? Int ?: 0
|
||||
node.inlined = context.isInline
|
||||
|
||||
// If this node is associated with an android View, set the node's viewId to point to
|
||||
// the hosted view. We use the parent's uniqueDrawingId since the interopView returned here
|
||||
// will be the view itself, but we want to use the `AndroidViewHolder` that hosts the view
|
||||
// instead of the view directly.
|
||||
(group.node as? InteroperableComposeUiNode?)?.getInteropView()?.let { interopView ->
|
||||
(interopView.parent as? View)?.uniqueDrawingId?.let { viewId -> node.viewId = viewId }
|
||||
}
|
||||
|
||||
val layoutInfo = group.node as? LayoutInfo
|
||||
if (layoutInfo != null) {
|
||||
return parseLayoutInfo(layoutInfo, context, node)
|
||||
}
|
||||
if (unwantedOutsideWindow(node, children)) {
|
||||
return markUnwanted(group, context, node)
|
||||
}
|
||||
node.box = context.bounds.emptyCheck()
|
||||
if (unwantedName(node.name) || (node.box == emptyBox && !subCompositions.capturing)) {
|
||||
return markUnwanted(group, context, node)
|
||||
}
|
||||
parseCallLocation(node, context.location)
|
||||
if (isHiddenSystemNode(node)) {
|
||||
return markUnwanted(group, context, node)
|
||||
}
|
||||
node.anchorId = anchorMap[group.identity]
|
||||
node.id = syntheticId(node.anchorId)
|
||||
if (includeAllParameters) {
|
||||
addParameters(context, node)
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
private fun IntRect.emptyCheck(): IntRect = if (left >= right && top >= bottom) emptyBox else this
|
||||
|
||||
private fun IntRect.inWindow(): Boolean =
|
||||
!(left > windowSize.width || right < 0 || top > windowSize.height || bottom < 0)
|
||||
|
||||
private fun IntRect.union(other: IntRect): IntRect {
|
||||
if (this == outsideBox) return other else if (other == outsideBox) return this
|
||||
|
||||
return IntRect(
|
||||
left = min(left, other.left),
|
||||
top = min(top, other.top),
|
||||
bottom = max(bottom, other.bottom),
|
||||
right = max(right, other.right))
|
||||
}
|
||||
|
||||
private fun parseLayoutInfo(
|
||||
layoutInfo: LayoutInfo,
|
||||
context: SourceContext,
|
||||
node: MutableInspectorNode
|
||||
): MutableInspectorNode {
|
||||
val box = context.bounds
|
||||
val size = box.size.toSize()
|
||||
val coordinates = layoutInfo.coordinates
|
||||
val topLeft = toIntOffset(coordinates.localToWindow(Offset.Zero))
|
||||
val topRight = toIntOffset(coordinates.localToWindow(Offset(size.width, 0f)))
|
||||
val bottomRight = toIntOffset(coordinates.localToWindow(Offset(size.width, size.height)))
|
||||
val bottomLeft = toIntOffset(coordinates.localToWindow(Offset(0f, size.height)))
|
||||
var bounds: QuadBounds? = null
|
||||
|
||||
if (topLeft.x != box.left ||
|
||||
topLeft.y != box.top ||
|
||||
topRight.x != box.right ||
|
||||
topRight.y != box.top ||
|
||||
bottomRight.x != box.right ||
|
||||
bottomRight.y != box.bottom ||
|
||||
bottomLeft.x != box.left ||
|
||||
bottomLeft.y != box.bottom) {
|
||||
bounds =
|
||||
QuadBounds(
|
||||
topLeft.x,
|
||||
topLeft.y,
|
||||
topRight.x,
|
||||
topRight.y,
|
||||
bottomRight.x,
|
||||
bottomRight.y,
|
||||
bottomLeft.x,
|
||||
bottomLeft.y,
|
||||
)
|
||||
}
|
||||
if (!includeNodesOutsizeOfWindow) {
|
||||
// Ignore this node if the bounds are completely outside the window
|
||||
node.outerBox = bounds?.outerBox ?: box
|
||||
if (!node.outerBox.inWindow()) {
|
||||
return node
|
||||
}
|
||||
}
|
||||
|
||||
node.box = box.emptyCheck()
|
||||
node.bounds = bounds
|
||||
node.layoutNodes.add(layoutInfo)
|
||||
val modifierInfo = layoutInfo.getModifierInfo()
|
||||
|
||||
val unmergedSemantics = unmergedSemanticsMap[layoutInfo.semanticsId]
|
||||
if (unmergedSemantics != null) {
|
||||
node.unmergedSemantics.addAll(unmergedSemantics)
|
||||
}
|
||||
|
||||
val mergedSemantics = semanticsMap[layoutInfo.semanticsId]
|
||||
if (mergedSemantics != null) {
|
||||
node.mergedSemantics.addAll(mergedSemantics)
|
||||
}
|
||||
|
||||
node.id =
|
||||
modifierInfo
|
||||
.asSequence()
|
||||
.map { it.extra }
|
||||
.filterIsInstance<GraphicLayerInfo>()
|
||||
.map { it.layerId }
|
||||
.firstOrNull()
|
||||
?: UNDEFINED_ID
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
private fun syntheticId(anchorId: Int): Long {
|
||||
if (anchorId == NO_ANCHOR_ID) {
|
||||
return UNDEFINED_ID
|
||||
}
|
||||
// The anchorId is an Int
|
||||
return anchorId.toLong() - Int.MAX_VALUE.toLong() + RESERVED_FOR_GENERATED_IDS
|
||||
}
|
||||
|
||||
private fun belongsToView(layoutNodes: List<LayoutInfo>, view: View): Boolean =
|
||||
layoutNodes
|
||||
.asSequence()
|
||||
.flatMap { node ->
|
||||
node
|
||||
.getModifierInfo()
|
||||
.asSequence()
|
||||
.map { it.extra }
|
||||
.filterIsInstance<GraphicLayerInfo>()
|
||||
.map { it.ownerViewId }
|
||||
}
|
||||
.contains(view.uniqueDrawingId)
|
||||
|
||||
private fun addParameters(context: SourceContext, node: MutableInspectorNode) {
|
||||
context.parameters.forEach {
|
||||
val castedValue = castValue(it)
|
||||
node.parameters.add(RawParameter(it.name, castedValue))
|
||||
}
|
||||
}
|
||||
|
||||
private fun castValue(parameter: ParameterInformation): Any? {
|
||||
val value = parameter.value ?: return null
|
||||
if (parameter.inlineClass == null || !isPrimitive(value.javaClass)) return value
|
||||
return inlineClassConverter.castParameterValue(parameter.inlineClass, value)
|
||||
}
|
||||
|
||||
private fun isPrimitive(cls: Class<*>): Boolean = cls.kotlin.javaPrimitiveType != null
|
||||
|
||||
private fun toIntOffset(offset: Offset): IntOffset =
|
||||
IntOffset(offset.x.roundToInt(), offset.y.roundToInt())
|
||||
|
||||
private fun markUnwanted(
|
||||
group: CompositionGroup,
|
||||
context: SourceContext,
|
||||
node: MutableInspectorNode
|
||||
): MutableInspectorNode =
|
||||
when (node.name) {
|
||||
"rememberCompositionContext" -> subCompositions.rememberCompositionContext(node, context)
|
||||
"remember" -> subCompositions.remember(node, group)
|
||||
else -> node.apply { markUnwanted() }
|
||||
}
|
||||
|
||||
private fun parseCallLocation(node: MutableInspectorNode, location: SourceLocation?) {
|
||||
val fileName = location?.sourceFile ?: return
|
||||
node.fileName = fileName
|
||||
node.packageHash = location.packageHash
|
||||
node.lineNumber = location.lineNumber
|
||||
node.offset = location.offset
|
||||
node.length = location.length
|
||||
}
|
||||
|
||||
private fun isHiddenSystemNode(node: MutableInspectorNode): Boolean =
|
||||
node.packageHash in systemPackages && hideSystemNodes
|
||||
|
||||
private fun unwantedName(name: String): Boolean =
|
||||
name.isEmpty() || name.startsWith("remember") || name in unwantedCalls
|
||||
|
||||
private fun unwantedOutsideWindow(
|
||||
node: MutableInspectorNode,
|
||||
children: List<MutableInspectorNode>
|
||||
): Boolean {
|
||||
if (includeNodesOutsizeOfWindow) {
|
||||
return false
|
||||
}
|
||||
node.outerBox =
|
||||
if (children.isEmpty()) outsideBox
|
||||
else children.map { g -> g.outerBox }.reduce { acc, box -> box.union(acc) }
|
||||
return !node.outerBox.inWindow()
|
||||
}
|
||||
|
||||
private fun newNode(): MutableInspectorNode =
|
||||
if (cache.isNotEmpty()) cache.pop() else MutableInspectorNode()
|
||||
|
||||
private fun newNode(copyFrom: InspectorNode): MutableInspectorNode =
|
||||
newNode().shallowCopy(copyFrom)
|
||||
|
||||
private fun release(node: MutableInspectorNode) {
|
||||
node.reset()
|
||||
cache.add(node)
|
||||
}
|
||||
|
||||
private fun buildAndRelease(node: MutableInspectorNode): InspectorNode {
|
||||
val result = node.build()
|
||||
release(node)
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Keep track of sub-composition roots.
|
||||
*
|
||||
* Examples:
|
||||
* - Popup, Dialog: When one of these is open an extra Android Window is created with its own
|
||||
* AndroidComposeView. The contents of the Composable is a sub-composition that will be computed
|
||||
* by calling convert.
|
||||
*
|
||||
* The Popup/Dialog composable itself, and a few helping composables (the root) will not be
|
||||
* included in the SlotTree with the contents, instead these composables will be found in the
|
||||
* SlotTree for the main app and they all have empty sizes. The aim is to collect these
|
||||
* sub-composition roots such that they can be added to the [InspectorNode]s of the contents.
|
||||
* - AndroidView: When this is used in a compose app we will see a similar pattern in the SlotTree
|
||||
* except there isn't a sub-composition to stitch in. But we need to collect the view id
|
||||
* separately from the "AndroidView" node itself.
|
||||
*/
|
||||
private inner class SubCompositionRoots {
|
||||
/** Set to true when the nodes found should be added to a sub-composition root */
|
||||
var capturing = false
|
||||
private set
|
||||
|
||||
/** The `uniqueDrawingId` of the `AndroidComposeView` that owns the root being captured */
|
||||
private var ownerView = UNDEFINED_ID
|
||||
|
||||
/** The node that represent the root of the sub-composition */
|
||||
private var rootNode: MutableInspectorNode? = null
|
||||
|
||||
/** The depth of the parse tree the [rootNode] was found at */
|
||||
private var rootNodeDepth = 0
|
||||
|
||||
/** Last captured view that is believed to be an embbed View under an AndroidView node */
|
||||
private var androidView = UNDEFINED_ID
|
||||
|
||||
/**
|
||||
* The sub-composition roots found.
|
||||
*
|
||||
* Map from View owner to a pair of [InspectorNode] indicating the actual root, and the node
|
||||
* where the content should be stitched in.
|
||||
*/
|
||||
private val found = mutableMapOf<Long, InspectorNode>()
|
||||
|
||||
/** Call this before converting a SlotTree for an AndroidComposeView */
|
||||
fun clear() {
|
||||
capturing = false
|
||||
ownerView = UNDEFINED_ID
|
||||
rootNode?.markUnwanted()
|
||||
rootNode?.id = UNDEFINED_ID
|
||||
rootNode = null
|
||||
rootNodeDepth = 0
|
||||
}
|
||||
|
||||
/** Call this when starting converting a new set of windows */
|
||||
fun resetAccumulativeState() {
|
||||
found.clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* When a "rememberCompositionContext" is found in the slot tree, it indicates that a
|
||||
* sub-composition was started. We should capture all parent nodes with an empty size as the
|
||||
* "root" of the sub-composition.
|
||||
*/
|
||||
fun rememberCompositionContext(
|
||||
node: MutableInspectorNode,
|
||||
context: SourceContext
|
||||
): MutableInspectorNode {
|
||||
if (capturing) {
|
||||
save()
|
||||
}
|
||||
capturing = true
|
||||
rootNode = node
|
||||
rootNodeDepth = context.depth
|
||||
node.id = PLACEHOLDER_ID
|
||||
return node
|
||||
}
|
||||
|
||||
/**
|
||||
* When "remember" is found in the slot tree and we are currently capturing, the data of the
|
||||
* [group] may contain the owner of the sub-composition.
|
||||
*/
|
||||
fun remember(node: MutableInspectorNode, group: CompositionGroup): MutableInspectorNode {
|
||||
node.markUnwanted()
|
||||
if (!capturing) {
|
||||
return node
|
||||
}
|
||||
val root = findSingleRootInGroupData(group) ?: return node
|
||||
|
||||
val view = root.subCompositionView
|
||||
if (view != null) {
|
||||
val composeOwner = if (view.childCount == 1) view.getChildAt(0) else return node
|
||||
ownerView = composeOwner.uniqueDrawingId
|
||||
} else {
|
||||
androidView = root.viewRoot?.uniqueDrawingId ?: UNDEFINED_ID
|
||||
// Store the viewRoot such that we can move the View under the compose node
|
||||
// in Studio. We do not need to capture the Groups found for this case, so
|
||||
// we call "reset" here to stop capturing.
|
||||
clear()
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
private fun findSingleRootInGroupData(group: CompositionGroup): ViewRootForInspector? {
|
||||
group.data.filterIsInstance<ViewRootForInspector>().singleOrNull()?.let {
|
||||
return it
|
||||
}
|
||||
val refs = group.data.filterIsInstance<Ref<*>>().map { it.value }
|
||||
return refs.filterIsInstance<ViewRootForInspector>().singleOrNull()
|
||||
}
|
||||
|
||||
/** Capture the top node of the sub-composition root until a non empty node is found. */
|
||||
fun captureNode(node: MutableInspectorNode, context: SourceContext) {
|
||||
if (!capturing) {
|
||||
return
|
||||
}
|
||||
if (node.box != emptyBox) {
|
||||
save()
|
||||
return
|
||||
}
|
||||
val depth = context.depth
|
||||
if (depth < rootNodeDepth) {
|
||||
rootNode = node
|
||||
rootNodeDepth = depth
|
||||
}
|
||||
}
|
||||
|
||||
fun latestViewId(): Long {
|
||||
val id = androidView
|
||||
androidView = UNDEFINED_ID
|
||||
return id
|
||||
}
|
||||
|
||||
/** If a sub-composition root has been captured, save it now. */
|
||||
private fun save() {
|
||||
val node = rootNode
|
||||
if (node != null && ownerView != UNDEFINED_ID) {
|
||||
found[ownerView] = node.build()
|
||||
}
|
||||
node?.markUnwanted()
|
||||
node?.id = UNDEFINED_ID
|
||||
node?.children?.clear()
|
||||
clear()
|
||||
}
|
||||
|
||||
/**
|
||||
* Add the root of the sub-composition to the found tree.
|
||||
*
|
||||
* If a root is not found for this [owner] or if the stitching fails just return [nodes].
|
||||
*/
|
||||
fun addRoot(owner: View, nodes: List<InspectorNode>): List<InspectorNode> {
|
||||
val root = found[owner.uniqueDrawingId] ?: return nodes
|
||||
val box = IntRect(0, 0, owner.width, owner.height)
|
||||
val info = StitchInfo(nodes, box)
|
||||
val result = listOf(stitch(root, info))
|
||||
return if (info.added) result else nodes
|
||||
}
|
||||
|
||||
private fun stitch(node: InspectorNode, info: StitchInfo): InspectorNode {
|
||||
val children = node.children.map { stitch(it, info) }
|
||||
val index = children.indexOfFirst { it.id == PLACEHOLDER_ID }
|
||||
val newNode = newNode()
|
||||
newNode.shallowCopy(node)
|
||||
newNode.children.clear()
|
||||
if (index < 0) {
|
||||
newNode.children.addAll(children)
|
||||
} else {
|
||||
newNode.children.addAll(children.subList(0, index))
|
||||
newNode.children.addAll(info.nodes)
|
||||
newNode.children.addAll(children.subList(index + 1, children.size))
|
||||
info.added = true
|
||||
}
|
||||
newNode.box = info.bounds
|
||||
return buildAndRelease(newNode)
|
||||
}
|
||||
}
|
||||
|
||||
private class StitchInfo(
|
||||
/** The nodes found that should be stitched into a sub-composition root. */
|
||||
val nodes: List<InspectorNode>,
|
||||
|
||||
/** The bounds of the View containing the sub-composition */
|
||||
val bounds: IntRect
|
||||
) {
|
||||
/** Set this to true when the [nodes] have been added to a sub-composition root */
|
||||
var added: Boolean = false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
* Copyright 2020 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
/** Holds data representing a Composable parameter for the Layout Inspector. */
|
||||
class NodeParameter
|
||||
internal constructor(
|
||||
/** The name of the parameter. */
|
||||
val name: String,
|
||||
|
||||
/** The type of the parameter. */
|
||||
val type: ParameterType,
|
||||
|
||||
/** The value of the parameter. */
|
||||
val value: Any?
|
||||
) {
|
||||
/** Sub elements of the parameter. */
|
||||
val elements = mutableListOf<NodeParameter>()
|
||||
|
||||
/** Reference to value parameter. */
|
||||
var reference: NodeParameterReference? = null
|
||||
|
||||
/** The index into the composite parent parameter value. */
|
||||
var index = 0
|
||||
}
|
||||
|
||||
/** The type of a parameter. */
|
||||
enum class ParameterType {
|
||||
String,
|
||||
Boolean,
|
||||
Double,
|
||||
Float,
|
||||
Int32,
|
||||
Int64,
|
||||
Color,
|
||||
Resource,
|
||||
DimensionDp,
|
||||
DimensionSp,
|
||||
DimensionEm,
|
||||
Lambda,
|
||||
FunctionReference,
|
||||
Iterable,
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* Copyright 2021 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
import facebook.internal.androidx.compose.ui.inspection.util.asIntArray
|
||||
|
||||
/**
|
||||
* A reference to a parameter to a [NodeParameter]
|
||||
*
|
||||
* @param nodeId is the id of the node the parameter belongs to
|
||||
* @param anchorId is the anchor hash of the node the parameter belongs to
|
||||
* @param kind is this a reference to a normal, merged, or unmerged semantic parameter.
|
||||
* @param parameterIndex index into [InspectorNode.parameters], [InspectorNode.mergedSemantics], or
|
||||
* [InspectorNode.unMergedSemantics]
|
||||
* @param indices are indices into the composite parameter
|
||||
*/
|
||||
class NodeParameterReference(
|
||||
val nodeId: Long,
|
||||
val anchorId: Int,
|
||||
val kind: ParameterKind,
|
||||
val parameterIndex: Int,
|
||||
val indices: IntArray
|
||||
) {
|
||||
constructor(
|
||||
nodeId: Long,
|
||||
anchorId: Int,
|
||||
kind: ParameterKind,
|
||||
parameterIndex: Int,
|
||||
indices: List<Int>
|
||||
) : this(nodeId, anchorId, kind, parameterIndex, indices.asIntArray())
|
||||
|
||||
// For testing:
|
||||
override fun toString(): String {
|
||||
val suffix = if (indices.isNotEmpty()) ", ${indices.joinToString()}" else ""
|
||||
return "[$nodeId, $anchorId, $kind, $parameterIndex$suffix]"
|
||||
}
|
||||
}
|
||||
|
||||
/** Identifies which kind of parameter the [NodeParameterReference] is a reference to. */
|
||||
enum class ParameterKind {
|
||||
Normal,
|
||||
MergedSemantics,
|
||||
UnmergedSemantics
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
// WARNING: DO NOT EDIT THIS FILE MANUALLY. It's automatically generated by running:
|
||||
// frameworks/support/compose/ui/ui-inspection/generate-packages/generate_compose_packages.py -r
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import kotlin.math.absoluteValue
|
||||
|
||||
@VisibleForTesting
|
||||
fun packageNameHash(packageName: String) =
|
||||
packageName.fold(0) { hash, char -> hash * 31 + char.code }.absoluteValue
|
||||
|
||||
val systemPackages =
|
||||
setOf(
|
||||
-1,
|
||||
packageNameHash("androidx.compose.animation"),
|
||||
packageNameHash("androidx.compose.animation.core"),
|
||||
packageNameHash("androidx.compose.animation.graphics.vector"),
|
||||
packageNameHash("androidx.compose.desktop"),
|
||||
packageNameHash("androidx.compose.foundation"),
|
||||
packageNameHash("androidx.compose.foundation.gestures"),
|
||||
packageNameHash("androidx.compose.foundation.gestures.snapping"),
|
||||
packageNameHash("androidx.compose.foundation.interaction"),
|
||||
packageNameHash("androidx.compose.foundation.layout"),
|
||||
packageNameHash("androidx.compose.foundation.lazy"),
|
||||
packageNameHash("androidx.compose.foundation.lazy.grid"),
|
||||
packageNameHash("androidx.compose.foundation.lazy.layout"),
|
||||
packageNameHash("androidx.compose.foundation.lazy.staggeredgrid"),
|
||||
packageNameHash("androidx.compose.foundation.newtext.text"),
|
||||
packageNameHash("androidx.compose.foundation.newtext.text.copypasta"),
|
||||
packageNameHash("androidx.compose.foundation.newtext.text.copypasta.selection"),
|
||||
packageNameHash("androidx.compose.foundation.pager"),
|
||||
packageNameHash("androidx.compose.foundation.relocation"),
|
||||
packageNameHash("androidx.compose.foundation.text"),
|
||||
packageNameHash("androidx.compose.foundation.text.selection"),
|
||||
packageNameHash("androidx.compose.foundation.window"),
|
||||
packageNameHash("androidx.compose.material"),
|
||||
packageNameHash("androidx.compose.material.internal"),
|
||||
packageNameHash("androidx.compose.material.pullrefresh"),
|
||||
packageNameHash("androidx.compose.material.ripple"),
|
||||
packageNameHash("androidx.compose.material3"),
|
||||
packageNameHash("androidx.compose.material3.internal"),
|
||||
packageNameHash("androidx.compose.material3.windowsizeclass"),
|
||||
packageNameHash("androidx.compose.runtime"),
|
||||
packageNameHash("androidx.compose.runtime.livedata"),
|
||||
packageNameHash("androidx.compose.runtime.mock"),
|
||||
packageNameHash("androidx.compose.runtime.reflect"),
|
||||
packageNameHash("androidx.compose.runtime.rxjava2"),
|
||||
packageNameHash("androidx.compose.runtime.rxjava3"),
|
||||
packageNameHash("androidx.compose.runtime.saveable"),
|
||||
packageNameHash("androidx.compose.ui"),
|
||||
packageNameHash("androidx.compose.ui.awt"),
|
||||
packageNameHash("androidx.compose.ui.graphics.benchmark"),
|
||||
packageNameHash("androidx.compose.ui.graphics.vector"),
|
||||
packageNameHash("androidx.compose.ui.layout"),
|
||||
packageNameHash("androidx.compose.ui.platform"),
|
||||
packageNameHash("androidx.compose.ui.text"),
|
||||
packageNameHash("androidx.compose.ui.util"),
|
||||
packageNameHash("androidx.compose.ui.viewinterop"),
|
||||
packageNameHash("androidx.compose.ui.window"),
|
||||
)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,215 @@
|
||||
/*
|
||||
* Copyright 2021 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.inspector
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import java.lang.reflect.Field
|
||||
import java.lang.reflect.Modifier
|
||||
import kotlin.jvm.internal.FunctionBase
|
||||
import kotlin.jvm.internal.FunctionReference
|
||||
import kotlin.jvm.internal.Lambda
|
||||
import kotlin.jvm.internal.MutablePropertyReference0
|
||||
import kotlin.jvm.internal.MutablePropertyReference1
|
||||
import kotlin.jvm.internal.MutablePropertyReference2
|
||||
import kotlin.jvm.internal.PropertyReference0
|
||||
import kotlin.jvm.internal.PropertyReference1
|
||||
import kotlin.jvm.internal.PropertyReference2
|
||||
import kotlin.jvm.internal.Reflection
|
||||
import kotlin.jvm.internal.ReflectionFactory
|
||||
import kotlin.reflect.KClass
|
||||
import kotlin.reflect.KClassifier
|
||||
import kotlin.reflect.KDeclarationContainer
|
||||
import kotlin.reflect.KFunction
|
||||
import kotlin.reflect.KMutableProperty0
|
||||
import kotlin.reflect.KMutableProperty1
|
||||
import kotlin.reflect.KMutableProperty2
|
||||
import kotlin.reflect.KProperty0
|
||||
import kotlin.reflect.KProperty1
|
||||
import kotlin.reflect.KProperty2
|
||||
import kotlin.reflect.KType
|
||||
import kotlin.reflect.KTypeParameter
|
||||
import kotlin.reflect.KTypeProjection
|
||||
import kotlin.reflect.KVariance
|
||||
import kotlin.reflect.jvm.internal.ReflectionFactoryImpl
|
||||
|
||||
/**
|
||||
* Scope that allows to use jarjar-ed kotlin-reflect artifact that is shipped with inspector itself.
|
||||
*
|
||||
* Issue with kotlin-reflect. Many of reflective calls such as "foo::class" rely on static functions
|
||||
* defined in kotlin-stdlib's Reflection.java that delegate to ReflectionFactory. In order to
|
||||
* initialize that factory kotlin-stdlib statically detects presence or absence of kotlin-reflect in
|
||||
* classloader and chooses a factory accordingly. If there is no kotlin-reflect, very limited
|
||||
* version of ReflectionFactory is used.
|
||||
*
|
||||
* It is an issue for inspectors because they could be loaded after that factory is initialised, and
|
||||
* even if they are loaded before, they live in a separate child classloader, thus kotlin-reflect in
|
||||
* inspector wouldn't exist for kotlin-stdlib in app.
|
||||
*
|
||||
* First step to avoid the issue is using ReflectionFactoryImpl that is bundled with inspector. Code
|
||||
* for that would be fairly simple, for example instead of directly calling
|
||||
* `kClass.declaredMemberProperties`, correct instance of kClass should be obtained from factory:
|
||||
* `factory.getOrCreateKotlinClass(kClass.java).declaredMemberProperties`.
|
||||
*
|
||||
* That would work if code that works with correct KClass full implementation would never try to
|
||||
* access a default factory installed in Reflection.java. Unfortunately it is not true, it
|
||||
* eventually calls `CallableReference.getOwner()` in stdlib that uses default factory.
|
||||
*
|
||||
* As a result we have to replace the factory in Reflection.java. To avoid issues with user's code
|
||||
* factory that we setup is smart, by default it simply delegates to a factory that was previously
|
||||
* installed. Only within `reflectionScope.withReflectiveAccess{ }` factory from kotlin-reflect is
|
||||
* used.
|
||||
*/
|
||||
@SuppressLint("BanUncheckedReflection")
|
||||
class ReflectionScope {
|
||||
|
||||
companion object {
|
||||
init {
|
||||
allowHiddenApi()
|
||||
}
|
||||
}
|
||||
|
||||
private val scopedReflectionFactory = installScopedReflectionFactory()
|
||||
|
||||
/** Runs `block` with access to kotlin-reflect. */
|
||||
fun <T> withReflectiveAccess(block: () -> T): T {
|
||||
return scopedReflectionFactory.withMainFactory(block)
|
||||
}
|
||||
|
||||
private fun installScopedReflectionFactory(): ScopedReflectionFactory {
|
||||
val factoryField = Reflection::class.java.getDeclaredField("factory")
|
||||
factoryField.isAccessible = true
|
||||
val original: ReflectionFactory = factoryField.get(null) as ReflectionFactory
|
||||
val modifiersField: Field = Field::class.java.getDeclaredField("accessFlags")
|
||||
modifiersField.isAccessible = true
|
||||
// make field non-final 😅 b/179685774 https://youtrack.jetbrains.com/issue/KT-44795
|
||||
modifiersField.setInt(factoryField, factoryField.modifiers and Modifier.FINAL.inv())
|
||||
val scopedReflectionFactory = ScopedReflectionFactory(original)
|
||||
factoryField.set(null, scopedReflectionFactory)
|
||||
return scopedReflectionFactory
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressLint("BanUncheckedReflection")
|
||||
private fun allowHiddenApi() {
|
||||
try {
|
||||
val vmDebug = Class.forName("dalvik.system.VMDebug")
|
||||
val allowHiddenApiReflectionFrom =
|
||||
vmDebug.getDeclaredMethod("allowHiddenApiReflectionFrom", Class::class.java)
|
||||
allowHiddenApiReflectionFrom.invoke(null, ReflectionScope::class.java)
|
||||
} catch (e: Throwable) {
|
||||
// ignore failure, let's try to proceed without it
|
||||
}
|
||||
}
|
||||
|
||||
private class ScopedReflectionFactory(
|
||||
private val original: ReflectionFactory,
|
||||
) : ReflectionFactory() {
|
||||
private val mainFactory = ReflectionFactoryImpl()
|
||||
private val threadLocalFactory = ThreadLocal<ReflectionFactory>()
|
||||
|
||||
fun <T> withMainFactory(block: () -> T): T {
|
||||
threadLocalFactory.set(mainFactory)
|
||||
try {
|
||||
return block()
|
||||
} finally {
|
||||
threadLocalFactory.set(null)
|
||||
}
|
||||
}
|
||||
|
||||
val factory: ReflectionFactory
|
||||
get() = threadLocalFactory.get() ?: original
|
||||
|
||||
override fun createKotlinClass(javaClass: Class<*>?): KClass<*> {
|
||||
return factory.createKotlinClass(javaClass)
|
||||
}
|
||||
|
||||
override fun createKotlinClass(javaClass: Class<*>?, internalName: String?): KClass<*> {
|
||||
return factory.createKotlinClass(javaClass, internalName)
|
||||
}
|
||||
|
||||
override fun getOrCreateKotlinPackage(
|
||||
javaClass: Class<*>?,
|
||||
moduleName: String?
|
||||
): KDeclarationContainer {
|
||||
return factory.getOrCreateKotlinPackage(javaClass, moduleName)
|
||||
}
|
||||
|
||||
override fun getOrCreateKotlinClass(javaClass: Class<*>?): KClass<*> {
|
||||
return factory.getOrCreateKotlinClass(javaClass)
|
||||
}
|
||||
|
||||
override fun getOrCreateKotlinClass(javaClass: Class<*>?, internalName: String?): KClass<*> {
|
||||
return factory.getOrCreateKotlinClass(javaClass, internalName)
|
||||
}
|
||||
|
||||
override fun renderLambdaToString(lambda: Lambda<*>?): String {
|
||||
return factory.renderLambdaToString(lambda)
|
||||
}
|
||||
|
||||
override fun renderLambdaToString(lambda: FunctionBase<*>?): String {
|
||||
return factory.renderLambdaToString(lambda)
|
||||
}
|
||||
|
||||
override fun function(f: FunctionReference?): KFunction<*> {
|
||||
return factory.function(f)
|
||||
}
|
||||
|
||||
override fun property0(p: PropertyReference0?): KProperty0<*> {
|
||||
return factory.property0(p)
|
||||
}
|
||||
|
||||
override fun mutableProperty0(p: MutablePropertyReference0?): KMutableProperty0<*> {
|
||||
return factory.mutableProperty0(p)
|
||||
}
|
||||
|
||||
override fun property1(p: PropertyReference1?): KProperty1<*, *> {
|
||||
return factory.property1(p)
|
||||
}
|
||||
|
||||
override fun mutableProperty1(p: MutablePropertyReference1?): KMutableProperty1<*, *> {
|
||||
return factory.mutableProperty1(p)
|
||||
}
|
||||
|
||||
override fun property2(p: PropertyReference2?): KProperty2<*, *, *> {
|
||||
return factory.property2(p)
|
||||
}
|
||||
|
||||
override fun mutableProperty2(p: MutablePropertyReference2?): KMutableProperty2<*, *, *> {
|
||||
return factory.mutableProperty2(p)
|
||||
}
|
||||
|
||||
override fun typeOf(
|
||||
klass: KClassifier?,
|
||||
arguments: MutableList<KTypeProjection>?,
|
||||
isMarkedNullable: Boolean
|
||||
): KType {
|
||||
return factory.typeOf(klass, arguments, isMarkedNullable)
|
||||
}
|
||||
|
||||
override fun typeParameter(
|
||||
container: Any?,
|
||||
name: String?,
|
||||
variance: KVariance?,
|
||||
isReified: Boolean
|
||||
): KTypeParameter {
|
||||
return factory.typeParameter(container, name, variance, isReified)
|
||||
}
|
||||
|
||||
override fun setUpperBounds(typeParameter: KTypeParameter?, bounds: MutableList<KType>?) {
|
||||
factory.setUpperBounds(typeParameter, bounds)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
/*
|
||||
* Copyright 2022 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.util
|
||||
|
||||
import java.util.IdentityHashMap
|
||||
|
||||
const val NO_ANCHOR_ID = 0
|
||||
|
||||
/** A map of anchors with a unique id generator. */
|
||||
class AnchorMap {
|
||||
private val anchorLookup = mutableMapOf<Int, Any>()
|
||||
private val idLookup = IdentityHashMap<Any, Int>()
|
||||
|
||||
/** Return a unique id for the specified [anchor] instance. */
|
||||
operator fun get(anchor: Any?): Int =
|
||||
anchor?.let { idLookup.getOrPut(it) { generateUniqueId(it) } } ?: NO_ANCHOR_ID
|
||||
|
||||
/** Return the anchor associated with a given unique anchor [id]. */
|
||||
operator fun get(id: Int): Any? = anchorLookup[id]
|
||||
|
||||
private fun generateUniqueId(anchor: Any): Int {
|
||||
var id = anchor.hashCode()
|
||||
while (id == NO_ANCHOR_ID || anchorLookup.containsKey(id)) {
|
||||
id++
|
||||
}
|
||||
anchorLookup[id] = anchor
|
||||
return id
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* Copyright 2021 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.util
|
||||
|
||||
private val EMPTY_INT_ARRAY = intArrayOf()
|
||||
|
||||
fun List<Int>.asIntArray() = if (isNotEmpty()) toIntArray() else EMPTY_INT_ARRAY
|
||||
@@ -0,0 +1,52 @@
|
||||
/*
|
||||
* Copyright 2021 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package facebook.internal.androidx.compose.ui.inspection.util
|
||||
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import java.util.concurrent.CompletableFuture
|
||||
import java.util.concurrent.Future
|
||||
|
||||
object ThreadUtils {
|
||||
fun assertOnMainThread() {
|
||||
if (!Looper.getMainLooper().isCurrentThread) {
|
||||
error("This work is required on the main thread")
|
||||
}
|
||||
}
|
||||
|
||||
fun assertOffMainThread() {
|
||||
if (Looper.getMainLooper().isCurrentThread) {
|
||||
error("This work is required off the main thread")
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Run some logic on the main thread, returning a future that will contain any data computed by
|
||||
* and returned from the block.
|
||||
*
|
||||
* If this method is called from the main thread, it will run immediately.
|
||||
*/
|
||||
fun <T> runOnMainThread(block: () -> T): Future<T> {
|
||||
return if (!Looper.getMainLooper().isCurrentThread) {
|
||||
val future = CompletableFuture<T>()
|
||||
Handler.createAsync(Looper.getMainLooper()).post { future.complete(block()) }
|
||||
future
|
||||
} else {
|
||||
CompletableFuture.completedFuture(block())
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user