Почему моя переменная размера не обновляется правильно в Jetpack Compose?

Попробуйте либо:

val size by remember { derivedStateOf { Size(width, height) } }

или:

val size = remember(width, height) { Size(width, height) } // don't use this in the lambda
val currentSize by rememberUpdatedState(size) // use this in the lambda

Документация pointerInput объясняет это:

Когда модификатор pointerInput создается композицией, если block захватывает любой локальный переменных, с которыми нужно работать, для работы с изменениями этих переменных обычно используются два шаблона. в зависимости от желаемого поведения.

Указание захваченного значения в качестве параметра key приведет к отмене block и перезапуску с самого начала, если значение изменится: keyedPointerInputModifier

If block не должен перезапускаться при изменении захваченного значения, но значение все равно должно обновиться для следующего использования, используйте RememberUpdatedState для обновления держателя значения, к которому обращается block: RememberUpdatedParameterPointerInputModifier

Для вашего варианта использования я бы порекомендовал rememberUpdatedState:

val size = rememberUpdatedState(Size(width, height))

В первом примере вы создаете новый экземпляр Size в каждой композиции, но блок pointerInput не создается заново и все еще ссылается на старый экземпляр. Аналогично, в третьем примере вы создаете новый экземпляр State, потому что вы не обертываете его remember. rememberUpdatedState эффективно делает это:

remember {
    mutableStateOf(newValue)
}.apply { value = newValue }

Таким образом, вы сохраняете тот же экземпляр State, и когда вы вызываете State.value внутри лямбды, вы получаете новое значение.

Это немного сложно. В дополнение к остальным ответам я постараюсь более подробно объяснить, что именно происходит в ваших трех примерах.

В первом примере вы передаете лямбду в pointerInput (часть в фигурных скобках). Это означает, что вы передаете только функцию: код в лямбде на самом деле не выполняется сразу, вы просто предоставляете функцию, которая может быть выполнена позже. Поскольку вы получаете доступ к переменным в вашей лямбде, которые находятся за пределами лямбды, Котлин фиксирует значения переменных в замыкании . Это просто означает, что значения где-то хранятся, поэтому к ним можно будет получить доступ позже, когда лямбда-выражение действительно будет выполнено.

Двумя переменными, к которым обращается лямбда, являются pointerInput и size. В момент первого вызова widthpointerInput является size, так что объект захватывается и для Size(0f, 0f) (по крайней мере, так кажется, читайте дальше, чтобы узнать больше) width захватывается. Поэтому всякий раз, когда выполняется лямбда, осуществляется доступ к этим двум значениям. Поэтому вы видите только 0f.

Теперь более интересный вопрос: почему вы видите все изменения в Size(0f, 0f), поскольку он фиксируется так же, как width. Разница в том, что size на самом деле является делегированным значением , потому что вы объявили его с помощью width. Это всего лишь синтаксический сахар в Котлине, поэтому в вашем коде вы можете получить доступ к by как к width, где фактический объект — это Float. Во время компиляции Kotlin заменяет вашу переменную MutableState<Float>Float на width и везде, где вы обращаетесь к переменной, он фактически вызывает MutableState<Float>.

Это означает, что в вашей лямбде width.value вы фактически получаете доступ к объекту типа pointerInput (а затем вызываете MutableState<Float>) при доступе к value. И в этом разница с width: лямбда фиксирует этот size объект, но любые изменения в MutableState<Float> на самом деле только обновляют внутреннее свойство width этого самого объекта, но никогда не создают новый объект. В отличие от value, где каждый раз создается новый size объект. Вот почему Size(...) работает, а width нет, так что то, что size вообще работает, скорее совпадение.

Когда width изменяется, запускается рекомпозиция, которая фактически выполняется width снова, поэтому можно подумать, что все вышеперечисленное не имеет значения, потому что каждый раз, когда новая лямбда передается pointerInput с текущими на тот момент объектами, но pointerInput только обновляет лямбду (и перезапускает его) при изменении ключей, которые вы предоставляете в качестве параметров. И поскольку вы указали pointerInput для этого ключа, pointerInput всегда сохраняет старую лямбду, созданную при первом вызове pointerInput. Более подробно это объясняется в документации pointerInput.

Вы можете просто исправить свой код, если укажете Unit в качестве ключа (вместо size), тогда при каждом изменении значений в лямбда-выражении снова фиксируются, и все работает как задумано.

Теперь перейдем ко второму примеру, который, к счастью, намного проще: поскольку вы также используете Unit с делегированием derivedStateOf, у вас под капотом фактически есть объект State, например by, который фиксируется в лямбде. Это работает по тем же причинам, по которым width работал в первом примере.

За исключением одного предостережения: поскольку вы не сделали width производное состояние, при каждой рекомпозиции создается и сохраняется новое состояние remember. Однако это не имеет значения, поскольку лямбда использует только первый объект состояния, который был создан таким образом, и который автоматически обновляется при изменении size (или width, если уж на то пошло), вот как height работает. Но вам также следует улучшить это состояние, чтобы оно не воссоздавалось без необходимости при перекомпоновке.

А в третьем примере вам даже не нужно изменяемое состояние, поскольку операторы печати не помещаются внутри ламбы:

val size = Size(width, height)

Это также просто работает так, как ожидалось.