Entorno de ejecución de Compose

Se trata de los componentes fundamentales del modelo de programación de Compose y de su administración de estados, así como del entorno de ejecución principal al cual se orienta el complemento de compilación de Compose.
Actualización más reciente Versión estable actual Próxima versión potencial Versión beta Versión alfa
14 de julio de 2021 - 1.0.0-rc02 - -

Estructura

Compose es una combinación de 6 ID de grupo de Maven en androidx. Cada grupo contiene un subconjunto de funcionalidades objetivo, cada uno con su propio conjunto de notas de la versión.

En esta tabla, se explican los grupos y vínculos correspondiente a cada conjunto de notas de la versión.

GrupoDescripción
compose.animationCrea animaciones en sus aplicaciones de Jetpack Compose para enriquecer la experiencia del usuario.
compose.compilerTransforma las funciones que admite @Composable y habilita las optimizaciones con un complemento de compilador de Kotlin.
compose.foundationEscribe aplicaciones de Jetpack Compose con componentes fundamentales listos para usar y extiende la base para compilar tus propias piezas de sistema de diseño.
compose.materialCompila las IU de Jetpack Compose con componentes de Material Design listos para usar. Este es el punto de entrada de nivel superior de Compose, diseñado para proporcionar componentes que coincidan con los descritos en www.material.io.
compose.runtimeSe trata de los componentes fundamentales del modelo de programación de Compose y de su administración de estados, así como del entorno de ejecución principal al cual se orienta el complemento de compilación de Compose.
compose.uiSon los componentes fundamentales de la IU de Compose necesarios para interactuar con el dispositivo, incluidos el diseño, el dibujo y la entrada.

Cómo declarar dependencias

Para agregar una dependencia en Compose, debes agregar el repositorio de Maven de Google a tu proyecto. Consulta el repositorio Maven de Google para obtener más información.

Agrega las dependencias de los artefactos que necesites en el archivo build.gradle de tu app o módulo:

Groovy

dependencies {
    implementation "androidx.compose.runtime:runtime:1.0.0-rc02"
    implementation "androidx.compose.runtime:runtime-livedata:1.0.0-rc02"
    implementation "androidx.compose.runtime:runtime-rxjava2:1.0.0-rc02"
}

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerVersion "1.5.10"
        kotlinCompilerExtensionVersion "1.0.0-rc02"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

dependencies {
    implementation("androidx.compose.runtime:runtime:1.0.0-rc02")
    implementation("androidx.compose.runtime:runtime-livedata:1.0.0-rc02")
    implementation("androidx.compose.runtime:runtime-rxjava2:1.0.0-rc02")
}

android {
    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerVersion = "1.5.10"
        kotlinCompilerExtensionVersion = "1.0.0-rc02"
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Para obtener más información sobre las dependencias, consulta Cómo agregar dependencias de compilación.

Comentarios

Tus comentarios ayudan a mejorar Jetpack. Avísanos si descubres nuevos errores o tienes ideas para mejorar esta biblioteca. Consulta los errores existentes en esta biblioteca antes de crear uno nuevo. Para agregar tu voto a un error existente, haz clic en el botón de la estrella.

Cómo crear un error nuevo

Consulta la documentación sobre la Herramienta de seguimiento de errores para obtener más información.

Versión 1.0.0

Versión 1.0.0-rc02

14 de julio de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-rc02. La versión 1.0.0-rc02 contiene estas confirmaciones.

  • Se corrigieron las condiciones de carrera en SnapshotStateObserver que causaban NullPointerExceptions esporádicas. (aosp/1763445, aosp/1758105, b/192677711)
  • Se corrigieron problemas relacionados con instantáneas de tiempo de ejecución que provocaban fallas java.lang.IllegalStateException: Reading a state that was created after the snapshot was taken or in a snapshot that has not yet been applied. (b/193006595, b/192570897)

Versión 1.0.0-rc01

1 de julio de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-rc01. La versión 1.0.0-rc01 contiene estas confirmaciones.

Versión 1.0.0-beta09

16 de junio de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta09. La versión 1.0.0-beta09 contiene estas confirmaciones.

Se agregaron reglas de perfiles

En esta versión, se agregaron reglas de perfiles a los siguientes módulos de Compose (I14ed6):

  • androidx.compose.animation
  • androidx.compose.animation-core
  • androidx.compose.foundation
  • androidx.compose.foundation-layout
  • androidx.compose.material
  • androidx.compose.material-ripple
  • androidx.compose.runtime
  • androidx.compose.ui
  • androidx.compose.ui.geometry
  • androidx.compose.ui.graphics
  • androidx.compose.ui.text
  • androidx.compose.ui.text
  • androidx.compose.ui.unit
  • androidx.compose.ui.util

¿Qué son las reglas de perfiles?

  • Las reglas de perfiles de una biblioteca se especifican en un archivo de texto baseline-prof.txt, ubicado en src/main o el directorio equivalente. El archivo especifica una regla por línea, donde una regla en este caso es un patrón para la coincidencia con métodos o clases de la biblioteca. La sintaxis de estas reglas es un superconjunto del formato de perfil ART legible que se usa cuando se implementa adb shell profman --dump-classes-and-methods .... Estas reglas adoptan una de dos formas para segmentar métodos o clases.

  • Una regla de métodos tendrá el siguiente patrón:

    <FLAGS><CLASS_DESCRIPTOR>-><METHOD_SIGNATURE>
    
  • Una regla de clases tendrá el siguiente patrón:

    <CLASS_DESCRIPTOR>
    
  • Aquí, <FLAGS> es uno o más caracteres H, S y P, los cuales indican si este método debe marcarse como "Hot" (caliente), "Startup" (inicio) o "Post Startup" (posterior al inicio).

  • El <CLASS_DESCRIPTOR> es el descriptor de la clase a la que pertenece el método segmentado. Por ejemplo, la clase androidx.compose.runtime.SlotTable tendría un descriptor de Landroidx/compose/runtime/SlotTable;.

  • El <METHOD_SIGNATURE> es la firma del método y, además, incluye el nombre, los tipos de parámetros y los tipos de datos que muestra. Por ejemplo, el método fun isPlaced(): Boolean en LayoutNode tiene la firma isPlaced()Z.

  • Estos patrones pueden tener comodines (**, * y ?) para tener una sola regla que abarque varios métodos o clases.

¿Para qué sirven las reglas?

  • Un método con la marca H indica que es "hot" y debe compilarse con anticipación.

  • Un método con la marca S indica que se llama durante el inicio y debe compilarse con anticipación para evitar el costo de interpretarlo y compilarlo en el momento del inicio.

  • Un método que tiene la marca P indica que es un método que se llama después del inicio.

  • Una clase presente en este archivo indica que se usa durante el inicio y debe asignarse previamente en el montón para evitar el costo de cargarla.

¿Cómo funciona?

  • Las bibliotecas pueden definir estas reglas que se empaquetarán en artefactos de AAR. Luego, cuando se compila un APK que incluye esos artefactos, esas reglas se combinan y se usan para compilar un perfil de ART binario compacto específico para el APK. De esta manera, ART puede tomar este perfil cuando se instala el APK en dispositivos para compilar con anticipación un subconjunto específico de la aplicación a fin de mejorar su rendimiento, especialmente en la primera ejecución. Ten en cuenta que esta acción no tendrá efecto en las aplicaciones depurables.

Versión 1.0.0-beta08

2 de junio de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta08. La versión 1.0.0-beta08 contiene estas confirmaciones.

Cambios en la API

  • State<T> ahora es State<out T>. (I69049)
  • Cambio en la API de ControlledComposition para habilitar la recomposición de cambios en un solo pase de recomposición. (Iaafd1, b/184173932)

Versión 1.0.0-beta07

18 de mayo de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta07. La versión 1.0.0-beta07 contiene estas confirmaciones.

Cambios en la API

  • Se agregaron nuevas API de compilación de Compose que permiten que se quite la información de origen generada por el compilador durante la reducción de la fuente. (Ia34e6)
  • Se introdujo ReusableContent, que intentará volver a usar los nodos en su contenido, en lugar de reemplazarlos cuando se cambia la clave. Cuando se cambia la clave, los valores anteriores en la tabla de ranuras para el contenido se ignoran, excepto los nodos que se generaron y los valores usados para actualizarlos.

    Se introdujo ReusableComposeNode, que reutilizará el nodo emitido, en lugar de reemplazarlo, como es el caso de ComposeNode. (I1dd86)

  • @ComposeCompilerApi ya no admite @RequiresOptIn. (Iab690)

Correcciones de errores

  • LazyColumn/Row ahora mantendrá activos hasta 2 elementos previamente visibles (no se desechan), incluso cuando ya se desplazaron. Esto permite que el componente vuelva a usar las subcomposiciones activas cuando necesitemos componer un elemento nuevo que mejore el rendimiento del desplazamiento. (Ie5555)

Versión 1.0.0-beta06

5 de mayo de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta06. La versión 1.0.0-beta06 contiene estas confirmaciones.

Cambios en la API

  • @ComposeCompilerApi ya no admite @RequiresOptIn. (Iab690)

Versión 1.0.0-beta05

21 de abril de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta05. La versión 1.0.0-beta05 contiene estas confirmaciones.

Cambios en la API

  • Se quitó @InternalComposeApi de la grabación de lecturas y escrituras de instantáneas. (Id134d)

Correcciones de errores

  • Los archivos AndroidManifest de ui-test-manifest y ui-tooling-data ahora son compatibles con Android 12. (I6f9de, b/184718994)

Versión 1.0.0-beta04

7 de abril de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta04. La versión 1.0.0-beta04 contiene estas confirmaciones.

Correcciones de errores

  • Antes del cambio, se podían omitir las funciones que admiten composición local según sus parámetros. Después del cambio, no se omitirán las funciones que admitan composiciones locales. Se realiza este cambio porque es común y esperado que las funciones locales capturen los parámetros superiores, y omitirlos es una fuente común de errores.

    En resumen, ten en cuenta el siguiente ejemplo:

    @Composable fun Counter(count: Int, onCountChange: (Int) -> Unit) {
      @Composable fun ShowCount() { Text("Count: $count") }
      ShowCount()
      Button(onClick={ onCountChange(count + 1) }) {
        Text("Increment")
      }
    }
    

    Antes del cambio, se omitía siempre la función que admite composición ShowCount, incluso después actualizar el parámetro count. Sin embargo, ya no es así. (I5648a)

  • Se corrigió el problema cuando rememberSaveable() estaba restableciendo el valor anterior que se usaba con parámetros de entrada (I1b110, b/182403380)

Versión 1.0.0-beta03

24 de marzo de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta03. La versión 1.0.0-beta03 contiene estas confirmaciones.

Cambios en la API

  • DefaultMonotonicFrameClock ya no está disponible. Cuando se llama a withFrameNanos o Recomposer.runRecomposeAndApplyChanges sin MonotonicFrameClock, ahora arrojará una excepción IllegalStateException. (I4eb0d)

Versión 1.0.0-beta02

10 de marzo de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta02. La versión 1.0.0-beta02 contiene estas confirmaciones.

Correcciones de errores

  • Se aplicaron restricciones sobre el uso público de las API experimentales. (I6aa29, b/174531520)
  • Se corrigió la falla de rememberSaveable { mutableStateOf(0) } cuando se usaba dentro de un destino de navigation-compose. (I1312b, b/180042685, b/180701630)

Versión 1.0.0-beta01

24 de febrero de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-beta01. La versión 1.0.0-beta01 contiene estas confirmaciones.

Esta es la primera versión de Compose 1.0.0 Beta.

Cambios en la API

  • Se agregó la API experimental Recomposer.runRecomposeConcurrentlyAndApplyChanges para volver a expresar las composiciones no válidas del bucle principal del marco. (I342d0)
  • Ahora, se puede validar el tiempo de compilación de cualquier elemento que admite composición con el objeto para garantizar que solo realicen llamadas a otro objeto @ReadOnlyComposables. (I58961)
  • Ahora es obligatorio el uso de defaultFactory para compositionLocalOf y staticCompositionLocalOf en lugar de ser opcional.

    Este cambio quita un error de escritura potencial del tipo no anulable en los que no se proporcionó el valor predeterminado de fábrica. Anteriormente, esto hubiera proporcionado una referencia nula del tipo no anulable.

    En el caso de los tipos nulos, puedes proporcionar { null } como el valor predeterminado de fábrica.

    No recomendamos usar configuraciones locales con tipos no anulables, a menos que se pueda proporcionar un valor predeterminado razonable. Si no existe un valor predeterminado razonable, la expresión lambda defaultFactory debe arrojar una excepción. Sin embargo, usar una excepción significa que los usuarios de la configuración local tendrán una dependencia implícita de ella siempre que el sistema de tipos no la aplique de manera forzada. (Ifbd2a)

  • Se quitaron los símbolos obsoletos del entorno de ejecución de Compose (I3252c).

  • Se quitó emptyContent() obsoleto. Usa {} en su lugar. (Idb33f, b/179432510)

  • Se cambió el nombre de Providers a CompositionLocalProvider.

    • El constructor Composition ya no acepta ningún parámetro clave y es obsoleto.
    • Se convirtió currentCompositeKeyHash en una propiedad de nivel superior que admite composición en lugar de una función de nivel superior que admite composición.
    • Se migraron CompositionData y CompositionGroup al espacio de nombres androidx.compose.runtime.tooling
    • Se convirtió ComposableLambda en una interfaz, en lugar de una clase concreta, y ya no cuenta con parámetros de tipo.
    • Se convirtió ComposableLambdaN en una interfaz, en lugar de una clase concreta, y ya no cuenta con parámetros de tipo.
    • Se migró la función snapshotFlow al espacio de nombres androidx.compose.runtime
    • Ya no es experimental el método de combinación de SnapshotMutationPolicy.
    • Se quitó la función clearRoots de nivel superior de @TestOnly. Ya no es necesaria.
    • Se quitaron las funciones keySourceInfoOf y resetSourceInfo. Ya no son necesarias.
    • Se quitó el elemento Composer.collectKeySourceInformation. Ya no es necesario.
    • Se quitaron los métodos joinedKeyRight, isJoinedKey y joinedKeyLeft. Ya no son necesarios.
    • Se migraron y reorganizaron varias API de nivel superior en archivos diferentes. Debido a la semántica de la clase de archivos de Kotlin, se romperá la compatibilidad binaria, pero no la compatibilidad de origen, por lo que no debería ser un problema para la mayoría de los usuarios.
    • (I99b7d, b/177245490)
  • SnapshotStateObserver dejó de ser experimental. (Id2e6a)

  • Se borraron algunas API que ya eran obsoletas. (Ice5da, b/178633932)

  • Se realizaron los siguientes cambios en la API de Material:

    • Se agregó el parámetro contentPadding a Top/BottomAppBar para permitir personalizar el relleno predeterminado.
    • Se reorganizaron los parámetros en BackdropScaffold a fin de cumplir con los lineamientos de las API para los parámetros obligatorios antes de los parámetros opcionales.
    • Se migró el parámetro icon en BottomNavigationItem para que sea posterior a selected y onClick.
    • Se cambió el nombre del parámetro alwaysShowLabels en BottomNavigationItem a alwaysShowLabel.
    • Se cambiaron los nombres de los parámetros bodyContent en algunos componentes a solo content.
    • Se reorganizaron los parámetros en ButtonDefaults.buttonColors(). Ten en cuenta que, debido a que no cambió el tipo de parámetros, no se producirá un error en tu código. Asegúrate de estar usando parámetros con nombre o actualiza el orden de manera manual; de lo contrario, tu código no funcionará como antes.
    • Se agregó el parámetro secondaryVariant a darkColors(). Por lo general, este color es el mismo que el de secondary en el tema oscuro, pero agrega coherencia y mayor personalización.
    • Se quitó ElevationDefaults y animateElevation() de la superficie de la API pública, ya que no se usaban con frecuencia ni eran útiles.
    • Se cambió el nombre de onValueChangeEnd en Slider a onValueChangeFinished y se hizo nulo.
    • Se cambió el nombre del parámetro text en Snackbar a content para brindar coherencia.
    • Se agregó el parámetro contentPadding a DropdownMenuItem para permitir la personalización del relleno predeterminado y se convirtió content en una extensión en RowScope.
    • Se cambió el nombre de ModalDrawerLayout a ModalDrawer.
    • Se cambió el nombre de BottomDrawerLayout a BottomDrawer.
    • (I1cc66)

Versión 1.0.0-alpha12

10 de febrero de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha12. La versión 1.0.0-alpha12 contiene estas confirmaciones.

Cambios en la API

  • Se quitó la compatibilidad con ViewGroups de UiApplier. Se quitaron los elementos emitView obsoletos que admiten composición. (Ifb214)
  • El nombre de CompositionReference cambió a CompositionContext. (I53fcb)
  • Se movió ComponentActivity.setContent a androidx.activity.compose.setContent en el módulo androidx.activity:activity-compose. (Icf416)
  • Se actualizó la API de Snapshot para que sea más consistente con los lineamientos de API y a fin de ocultar las clases de implementación interna en la API pública. (Id9e32)
  • Se cambió el nombre de Ambients para que coincida con Ambient -> CompositionLocal. Los elementos Ambients se solían llamar AmbientFoo; ahora los elementos CompositionLocals se llaman LocalFoo. (I2d55d)
  • El nombre de Ambient cambió a CompositionLocal, y los de ambientOf y staticAmbientOf a compositionLocalOf y staticCompositionLocalOf, respectivamente. Gracias a este cambio, el propósito de CompositionLocal es más claro: es un mecanismo para proporcionar o recuperar valores locales de una composición. Las instancias de CompositionLocal deben tener el prefijo Local, como el valor LocalFoo = compositionLocalOf { Foo() }. (Ia55b6)
  • Se movieron takeMutableSnapshot y takeSnapshot para que sean métodos complementarios de Snapshot. (I91f19)
  • @ComposableContract dejó de estar disponible y se reemplazó por tres anotaciones más específicas.

    @ComposableContract(restartable = false) se convirtió en @NonRestartableComposable, @ComposableContract(readonly = true) se convirtió en @ReadOnlyComposable, @ComposableContract(preventCapture = true) se convirtió en @DisallowComposableCalls y se quitó @ComposableContract(tracked = true). (I60a9d)

  • Dejaron de estar disponibles las utilidades emptyContent() y (@Composable () -> Unit).orEmpty(), dado que ya no tienen un valor ni impacto de rendimiento positivos. (I0484d)

  • snapshotFlow y withMutableSnapshot dejaron de ser experimentales. (I6a45f)

  • Ahora se pueden cerrar los elementos Recomposer. Si se cierran, continuarán componiendo hasta que se completen las corrutinas de elementos secundarios de composición. Se cambió el nombre de Recomposer.shutDown a cancel para que haya una diferencia con la acción de cerrar. (Ib6d76)

  • El artefacto compose:runtime-dispatch dejó de estar disponible. Ahora se puede encontrar MonotonicFrameClock en compose:runtime y AndroidUiDispatcher en compose:ui. (Ib5c36)

  • Se refactorizó la API a la que se orienta el complemento de compilador de Compose para usar una interfaz en lugar de una clase concreta. La interfaz ya dejó de usar un parámetro de tipo.

    Este es un cambio interno que no debería afectar la compatibilidad del código fuente, pero es un cambio rotundo del objeto binario. (I3b922, b/169406779)

  • Se introdujo SnapshotMutableState. (Icfd03)

  • Se cambió el nombre de DisposableEffectDisposable a DisposaleEffectResult. (Ica7c6)

  • Se quitó Recomposer.current(). Ahora [Abstract]ComposeView es la opción predeterminada para los elementos Recomposer aplicados a ventanas y creados de forma diferida que controla ViewTreeLifecycleOwner para la ventana. La recomposición y las marcas de animación basadas en withFrameNanos-based se pausan cuando se detiene el ciclo de vida del host. (I38e11)

  • Recomposer.runningRecomposers ahora ofrece un StateFlow global de RecomposerInfo de solo lectura para observar el estado de la composición en proceso. Se prefiere esta API en lugar de Recomposer.current(), que dejó de estar disponible. (If8ebe)

  • Se cambió el nombre de DisposableEffectDisposable a DisposaleEffectResult. (I3ea68)

Versión 1.0.0-alpha11

28 de enero de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha11. La versión 1.0.0-alpha11 contiene estas confirmaciones.

Cambios en la API

  • onCommit, onDispose y onActive dejaron de estar disponibles y se los reemplazó con las API de SideEffect y DisposableEffect. (If760e)
  • La API de emit() y todas las sobrecargas dejaron de estar disponibles y cambiaron de nombre a ComposeNode. Las API son idénticas; solo tienen un nombre diferente para seguir las convenciones de nomenclatura de Compose. (I4137b)
  • invalidate y compositionReference() dejaron de estar disponibles y se reemplazaron con currentRecomposeScope y rememberCompositionReference, respectivamente. (I583a8)
  • ComposiciónLifecycleObserver dejó de estar disponible y se reemplazó con RememberObserver.

    RememberObserver es un reemplazo de CompositionLifecycleObserver con una semántica modificada y métodos con nombres cambiados. El cambio a la API nueva se puede realizar de manera mecánica para objetos que solo se recuerdan una vez y sigue siendo la práctica recomendada. Sin embargo, si se olvidó una referencia más de una vez en una composición, se llama a onRemembered para cada referencia en la que onEnter solo se llama una vez. Antes, se llamaba a onEnter varias veces si el objeto se usaba en subcomposiciones, como WithConstraints y Scaffold, por lo que la garantía de la única llamada a onEnter no era confiable. Por lo tanto, se quitó de RememberObserver.

    RememberObserver agrega onAbandoned, que se llama si la devolución de llamada pasada a remembermuestra la instancia RememberObserver, pero como esta no se recuerda en el estado de composición, nunca se llamará a onRemembered. Esto puede ocurrir si una excepción termina la composición antes de completarla, o bien si la descarta, ya que el estado que estaba produciendo una composición ya no está vigente o no se necesita. Si la instancia de RememberObserver que sigue a la recomendación de referencia única anterior realiza el seguimiento de un recurso externo, tanto onForgotten como onAbandoned indicarán que el recurso ya no es necesario. Si el objeto realiza un seguimiento del trabajo que se inició o los recursos asignados en onRemembered, se puede ignorar a onAbandoned, ya que no se llamará si se llama a onRemembered. (I02c36)

  • No marques las funciones collectAsState() como intercaladas. (Ia73e4)

Correcciones de errores

  • WithConstraints se rediseñó y nombró BoxWithConstraints, y se movió a foundation.layout. (I9420b, b/173387208)
  • Se implementó TestCoroutineDispatcher en pruebas. (I532b6)

Versión 1.0.0-alpha10

13 de enero de 2021

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha10. La versión 1.0.0-alpha10 contiene estas confirmaciones.

Cambio rotundo

  • La reestructuración del compilador interno de la API permite realizar cambios por lote en los nodos que se generan a partir de la composición a la fase "aplicar cambios", después de que se completan todas las funciones @Composable.

    Este es un cambio rotundo de comportamiento que podría afectar el código de la aplicación, dado que los nodos ya no estarán disponibles en las API internas ni en las experimentales hasta que se hayan aplicado los cambios. Por lo general, se puede evitar si se envuelve el código con esas dependencias en un elemento componible SideEffect para diferir la ejecución del código hasta que se hayan creado e inicializado los nodos. (I018da)

Cambios en la API

  • Se agregó una forma de rastrear los cambios que el compositor haya realizado, de haber alguno. (I1b3e2)
  • Se expandieron las API de [Abstract]ComposeView para permitir el reciclado de las vistas basadas en Compose, ya que se dispone la composición para volver a recrearla más adelante. Se agregaron API para instalar y descubrir elementos Recomposer y CompositionReferences aplicados a ventanas, con el objetivo de crear composiciones secundarias.

    Se agregó ViewCompositionStrategy para configurar la estrategia de descarte de composición de [Abstract]ComposeViews; el comportamiento predeterminado es que se descarta cuando se desconecta la ventana. (I860ab)

Correcciones de errores

  • Recomposer ahora muestra un flujo de estado actual, lo que permite supervisar su actividad y la actividad de los efectos asociados. (Ifb2b9)
  • Ahora se puede acceder al keyEvent nativo a través de keyEvent.nativeKeyEvent. (I87c57 o b/173086397)

Versión 1.0.0-alpha09

16 de diciembre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha09. La versión 1.0.0-alpha09 contiene estas confirmaciones.

Cambios en la API

  • Se quitó SlotTable, SlotReader y SlotWriter de la API pública. Anteriormente, se marcaban como InternalComposeAPI. Ahora, son elementos internos del módulo de Compose.

    Se agregaron ComposiciónData y ComposiciónGroup como reemplazo de la API de ui-tooling para que se usen con el fin de extraer información de composición. Son públicos, pero no están destinados para su uso fuera de la API de ui-tooling, ya que proporcionan la información sin procesar que interpreta la API de ui-tooling. (I31a9c)

  • Se considera que la clase Applier ya no es (Id85b0).

  • Se modificó la interfaz Applier para simplificar la creación de árboles de abajo hacia arriba en lugar de arriba hacia abajo.

    Se cambió el nombre del método insert() por insertTopDown().

    Se agregó un método nuevo: insertBottomUp().

    Un aplicador inserta cualquiera de los nodos en el árbol que edita con insertTopDown() o insertBottomUp() según el que tenga mejor rendimiento.

    Algunos árboles, como LayoutNode y View, son mucho más eficientes para compilar hacia arriba que hacia abajo. Antes de este cambio, se necesitaba una pila de inserciones para implementar la compilación de abajo hacia arriba, que debía copiarse en cada aplicador que necesitaba una construcción de abajo hacia arriba para funcionar. Con este cambio, un elemento Applier anula insertBottomUp() para compilar un árbol de abajo hacia arriba y insertTopDown() para compilar el árbol de arriba hacia abajo. (Icbdc2)

  • Compose admite captadores de propiedad que pueden realizar invocaciones que se pueden componer. La compatibilidad con lo anterior no desaparecerá, pero cambiará la sintaxis para declarar un captador de propiedad, dado que @Composable cambiará.

    La sintaxis, ahora obsoleta, consistía en anotar la propiedad en sí:

        @Composable val someProperty: Int get() = ...
    

    Ahora, la sintaxis correcta consiste en anotar el captador de la propiedad:

       val someProperty: Int @Composable get() = ...
    

    Ambas sintaxis funcionarán por un tiempo, pero, al final, la sintaxis obsoleta anterior se convertirá en un error de compilación. (Id9197)

Correcciones de errores

Versión 1.0.0-alpha08

2 de diciembre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha08. La versión 1.0.0-alpha08 contiene estas confirmaciones.

Cambios en la API

  • Se agregó la comprobación de lint para el nombre y la posición del parámetro lambda que se pueden componer a fin de verificar la coherencia con los lineamientos de Compose. También se migraron algunas API que usaban children como nombre de su lambda al final a content, según la comprobación y orientación de lint. (Iec48e)
  • Recomposer ya no acepta EmbeddingContext. Las dependencias de programación requeridas se obtienen de effectCoroutineContext. FrameManager dejó de estar disponible. Las integraciones de plataforma deben inicializar su propio manejo global de instantáneas. (I02369)
  • El nombre de RestorableStateHolder.withRestorableState cambió a RestorableStateProvider. (I66640)

Correcciones de errores

  • Los entornos Ambient con el nombre Ambient como sufijo dejaron de estar disponibles, y se los reemplazó por nuevas propiedades con el prefijo Ambient, en función de otros lineamientos de la API de Compose y Ambients. (I33440)
  • Se quitó el módulo ui-tests y sus stubs. (I3a7cb)

Versión 1.0.0-alpha07

11 de noviembre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha07. La versión 1.0.0-alpha07 contiene estas confirmaciones.

Nuevas funciones

Cambios en la API

  • La anotación @UnionType dejó de estar disponible. (I57cde)
  • Se agregó provideDefault como alternativa para proporcionar ambientes y se puede usar a fin de especificar valores ambientales que solo se establecerán cuando no se haya proporcionado ningún valor ambiental. (Id6635, b/171024925)
  • Se cambió el nombre de LaunchedTask a LaunchedEffect para conservar la coherencia con las API de SideEffect y DisposableEffect. No se permite el uso de LaunchedEffect sin parámetros de asunto para fomentar las prácticas recomendadas. (Ifd3d4)
  • Applier ahora tiene devoluciones de llamada onBeginChanges/onEndChanges que se invocan cuando un Composer comienza a aplicar los cambios al árbol o termina de hacerlo. Estas se pueden usar para agrupar en lotes la administración de recursos si fuera necesario. (Icf476)
  • Recomposer ahora requiere CoroutineContext en la construcción. (Ic4610)
  • Se realizaron cambios en la implementación interna de SlotTable que no deberían afectar a la API pública. (If9828)
  • Se quitaron los adaptadores rxjava2 obsoletos que no toman el valor inicial. (Idb72f)

Correcciones de errores

  • foundation.Text dejó de estar disponible y se reemplazó por material.Text. Para ver una API de texto básica y sin tendencias que no consuma valores de un tema, consulta androidx.compose.foundation.BasicText. (If64cb)
  • BaseTextField dejó de estar disponible. En su lugar, usa BasicTextField. (I896eb)
  • Varios símbolos relacionados con el diseño se movieron de androidx.compose.ui a androidx.compose.layout.ui. (I0fa98, b/170475424)

Contribución externa

  • Se agregó el módulo runtime-rxjava3 para la composición. Es similar a runtime-rxjava2. (I02cbf)

Versión 1.0.0-alpha06

28 de octubre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha06. La versión 1.0.0-alpha06 contiene estas confirmaciones.

Cambios en la API

  • Recomposer ahora es CompositionReference y es un elemento superior de composición válido. El Recomposer explícito ahora es obligatorio en menos lugares. (I4036f)
  • Se agregó la API equivalente de DisposableEffect a SideEffect, con lo que se completó la función de onCommit-with-params, pero con un valor onDispose obligatorio.
    • Se agregó la API de rememberUpdatedState para publicar datos desde la recomposición hasta los procesos en curso o de larga duración, como DisposableEffects o LaunchedTasks.
    • (Id50b9)
  • MutableVector ahora implementa RandomAccess. (I85d73, b/170461551)
  • Se agregó el elemento SideEffect que admite composición a fin de aplicar efectos secundarios de la composición a los objetos que esta administra. El objetivo de SideEffect es reemplazar al elemento onCommit que admite composición. (Ia77c2)
  • Se incluye la nueva API experimental RestorableStateHolder. Permite guardar el estado definido mediante [savedInstanceState] y [rememberSavedInstanceState] del subárbol antes de desecharlo a fin de que pueda volver a componerse la próxima vez con el estado restablecido. (I66884, b/166586419)

Correcciones de errores

  • Se habilitaron transiciones en ComposeTestRule y se quitó la opción que permitía habilitar el cursor intermitente desde ComposeTestRule. (If0de3)

Versión 1.0.0-alpha05

14 de octubre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha05. La versión 1.0.0-alpha05 contiene estas confirmaciones.

Cambios en la API

  • El objeto experimental Modifier.pointerInput suspende la entrada del modificador. (Ia77d2)
  • Se mejoró el rendimiento de desplazamiento de LazyColumn/Row al hacer menos trabajo de subcomposición en cada desplazamiento. Se agregó el nuevo método haInvalidations() para la clase Composición. Se cambió el nombre del método hasPendingChanges() de Recomposer por hasInvalidations(). (Ib2f32, b/168293643, b/167972292, b/165028371))
  • Se agregó la API produceState para lanzar corrutinas a partir de composiciones que actualizan un valor State<T> único a lo largo del tiempo. (Id4a57)
  • Se cambió el nombre de launchInComposition por LaunchedTask para que coincida con los lineamientos de la API de Compose. (I99a8e)
  • El orden de las llamadas a place() en los diseños personalizados ahora define el orden de dibujo para los elementos secundarios. (Ibc9f6)

Versión 1.0.0-alpha04

1 de octubre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha04. La versión 1.0.0-alpha04 contiene estas confirmaciones.

Cambios en la API

  • Se agregó OwnerScope para permitir la recopilación de alcances de observación de diseños y dibujos cuando ya no son válidos. (Ic4cf8)
  • Se agregó la API de derivedStateOf para crear objetos State basados en un cálculo que puede leer otros objetos State (y derivar de ellos). (If758b)
  • Se agregó la API de TestOnly para SnapshotStateObserver. (I6e2a9)

Correcciones de errores

  • foundation.Box dejó de estar disponible. Usa foundation.layout.Box en su lugar. (Ie5950, b/167680279)

Versión 1.0.0-alpha03

16 de septiembre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha03. La versión 1.0.0-alpha03 contiene estas confirmaciones.

Cambios en la API

  • CompositionCoroutineScope ya no implementa MonotonicFrameClock. Los llamadores de withFrameNanos deben importar la función de nivel superior de manera explícita. (Icb642, b/166778123)

Correcciones de errores

  • Las funciones de prueba globales, como onNode o waitForIdle, dejaron de estar disponibles. Migra a sus equivalentes nuevas que se definen en ComposeTestRule. (I7f45a)
  • launchInComposition ya no inicia corrutinas sin enviar. (Ief6af, b/166486000)

Versión 1.0.0-alpha02

2 de septiembre de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha02. La versión 1.0.0-alpha02 contiene estas confirmaciones.

Cambios en la API

  • Agrega las API de snapshotFlow y withMutableSnapshot para consumir y producir cambios de datos de Snapshot. (I3e722)
  • La convención de llamada para funciones que admiten composición cambió. Este es un cambio rotundo del objeto binario. Se deben volver a compilar todas las bibliotecas para que funcionen con esta versión del complemento del compilador de Compose.

    Esta modificación no crea un cambio rotundo a nivel de la fuente, ya que las únicas API que cambiaron son las API del compilador que tienen una participación explícita. (I7afd2, b/158123185)

  • Se quitaron métodos de programación de EmbeddingContext. (I7b9be)

  • onPreCommit dejó de estar disponible. onCommit ahora tiene el comportamiento de onPrecommit.

    OnCommit y OnActive ahora se ejecutan en el mismo fotograma Choreographer que los cambios de composición incluidos, y no al inicio del siguiente fotograma Coreographer. (I70403)

Versión 1.0.0-alpha01

26 de agosto de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:1.0.0-alpha01. La versión 1.0.0-alpha01 contiene estas confirmaciones.

Versión 0.1.0-dev

Versión 0.1.0-dev17

19 de agosto de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:0.1.0-dev17. La versión 0.1.0-dev05 contiene estas confirmaciones.

Cambios en la API

  • Las emisiones personalizadas ahora pueden declarar que uno o más de sus métodos set pueden omitirse y reescribirse de forma independiente de la emisión. (Ibbd13)
  • Se quitaron las llamadas a FrameManager obsoletas.

    Se modificaron las API de composición interna a fin de reducir la sobrecarga para realizar el seguimiento de los objetos de estado, como mutableStateof(). (I80ba6)

  • El elemento state { ... } que admite composición dejó de estar disponible en favor de cualquier llamada explícita a remember { mutableStateOf(...) } por motivos de claridad. Con esto, se reduce la superficie general de la API, así como la cantidad de conceptos para la administración de estados, y se hace coincidir el patrón by mutableStateOf() con la delegación de propiedades de clase. (Ia5727)

  • Flow.collectAsState ahora determina el despachador predeterminado de la composición en lugar de recurrir a Dispatchers.Main de manera predeterminada. (I9c1d9)

  • Se corrigió la falla que ocurría cuando se utilizaba dentro del bucle algo que guardaba el estado. Ahora se permite tener la misma clave en savedInstanceState(), y ya se ajustó la API de UiSavedStateRegistry en virtud de este requisito nuevo. (I4ab76, (b/160042650)., b/156853976, b/159026663, b/154920561)

Correcciones de errores

  • El objeto emitView dejó de estar disponible. En su lugar, si fuera posible, usa AndroidView para emitir objetos Views dentro de Compose. Ten en cuenta que la composición directa de objetos Views y ViewGroups no se admitirá en el futuro, a menos que estos sean hojas en el árbol de la composición. En ese caso, esto se logra mediante AndroidView. (I29b1e, b/163871221)

Versión 0.1.0-dev16

5 de agosto de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:0.1.0-dev16. La versión 0.1.0-dev05 contiene estas confirmaciones.

Cambios en la API

  • La política predeterminada de mutación de mutableStateOf(), ambientOf() y savedInstanceStateOf() cambió a structuralEqualityPolicy(), en lugar de referentialEqualityPolicy().

    La configuración predeterminada para decidir si un valor nuevo asignado a una instancia mutableStateOf() se considera un cambio ahora es usar == en lugar de ===.

    Consulta https://kotlinlang.org/docs/reference/equality.html

    ambientOf() y savedInstanceStateOf() usan mutableStateOf() en sus implementaciones, por lo que se modificaron para ser coherentes con mutableStateOf().

    La igualdad estructural cumple en mayor medida con las expectativas de los desarrolladores.

    Por ejemplo:

    val state = mutableStateOf(1f)
    

    seguido de

    state.value = 1f
    

    ya no se considerará un cambio en state, y ya no se deberán reescribir los usos de state durante la composición.

    Este es un cambio rotundo, pero en la mayoría de los casos (como cuando se usan clases que no anulan equals()), no tendrá un efecto evidente en una aplicación.

    Para las clases que sí anulan equals(), como las clases data, podría observarse una degradación del rendimiento, ya que sus métodos equals() ahora se llamarán, de forma predeterminada, cuando se asignen a un mutableStateOf().

    Se puede restablecer el comportamiento anterior si agregas el parámetro de política policy = referentialEqualityPolicy() a las llamadas a mutableStateOf(), ambientOf() y savedInstanceStateOf(). (Ic21a7)

  • Row y Column ahora son funciones intercaladas, lo que reduce en forma significativa la sobrecarga asociada a su uso. (I75c10)

Correcciones de errores

  • SetViewContent dejó de estar disponible. En su lugar, usa setContent. (I7e497, b/160335130)
  • Se agregó MonotonicFrameAnimationClock, que te permite usar un MonotonicFrameClock como un AnimationClockObservable para cerrar la brecha entre los nuevos relojes basados en corrutinas y las API que aún usan los relojes antiguos basados en la devolución de llamada.

    El MonotonicFrameClock equivalente de ManualAnimationClock ahora es ManualFrameClock. (I111c7, b/161247083)

  • Se rediseñó por completo Modifier.stateDraggable, y se cambió su nombre por Modifier.swipeable. Se agregó una nueva clase SwipeableState, y se refactorizaron DrawerState y BottomDrawerState para heredar de ella. [Modal/Bottom]DrawerLayout ya no toma un parámetro onStateChange. (I72332, b/148023068)

  • Modifier.plus dejó de estar disponible; en su lugar, usa Modifier.then. "Then" tiene un indicador de orden más fuerte, a la vez que prohíbe la escritura de Modifier.padding().background() + anotherModifier, lo que interrumpe la cadena y es más difícil de leer. (Iedd58, b/161529964)

  • Se agregó SubcomposeLayout. Se trata de un elemento primitivo de bajo nivel que permite componer los elementos secundarios durante la medición si queremos usar algunos valores disponibles más adelante durante la medición de la composición del subárbol. Por ejemplo, WithConstraints no se implementa mediante SubcomposeLayout. (I25cc8)

  • Se cambió el nombre de FilledTextField de Material por TextField, y el del TextField principal se cambió por BaseTextField a fin de que la API deseada resulte más fácil de encontrar y usar. (Ia6242, b/155482676)

  • Se cambió el nombre de Modifier.drawBackground por Modifier.background. (I13677)

Versión 0.1.0-dev15

22 de julio de 2020

Lanzamiento de androidx.compose.runtime:runtime-*:0.1.0-dev15. La versión 0.1.0-dev15 contiene estas confirmaciones.

Actualización de dependencias

  • Para usar la versión 0.1.0-dev15 de Compose, deberás actualizar tus dependencias de acuerdo con los nuevos fragmentos de código que se muestran más arriba en Cómo declarar dependencias.

Cambios en la API

  • La anotación del objeto @Model quedó obsoleta. Usa state y mutableStateOf como alternativas. Se decidió darle de baja después de un debate minucioso.

    Justificación

    Los motivos, entre otros, son los siguientes:

    • Reduce la superficie de la API y los conceptos que debemos enseñar.
    • Se alinea, de manera más estrecha, con otros kits de herramientas comparables (SwiftUI, React, Flutter).
    • Se puede revertir la decisión. Siempre podemos recuperar el elemento @Model en el futuro.
    • Quita el uso de caso límite y la dificultad para responder preguntas sobre la configuración del elemento @Model como cuestiones que necesitamos controlar.
    • Clases de datos, equals, hashcode del objeto @Model, etc.
    • ¿Cómo se pueden "observar" algunas propiedades y otras no?
    • ¿Cómo especifico la igualdad estructural frente a la igualdad referencial para usarla en la observación?
    • Reduce la característica "automática" del sistema. Disminuiría la probabilidad de que alguien suponga que el sistema es más inteligente de lo que es (es decir, que sabe cómo diferenciar una lista).
    • Permite que el nivel de detalle en la observación sea más intuitivo.
    • Mejora la refactorización de la variable -> propiedad sobre clase.
    • Es posible que ofrezca posibilidades para realizar optimizaciones manuales y específicas del objeto State.
    • Se alinea, de manera más estrecha, con el resto del ecosistema y reduce la ambigüedad hacia el estado inmutable o el "estado mutable que adoptamos".

    Notas de migración

    Casi todos los usos existentes del objeto @Model se transforman, de manera bastante trivial, de una de dos maneras. A modo de ejemplo, la siguiente clase del objeto @Model cuenta con dos propiedades y se usa en un elemento que admite composición.

    @Model class Position(
     var x: Int,
     var y: Int
    )
    
    @Composable fun Example() {
     var p = remember { Position(0, 0) }
     PositionChanger(
       position=p,
       onXChange={ p.x = it }
       onYChange={ p.y = it }
     )
    }
    

    Alternativa 1: Usa el objeto State<OriginalClass>y crea copias.

    Este enfoque es más fácil con las clases de datos de Kotlin. En esencia, convierte todas las propiedades anteriores del objeto var en propiedades del elemento val de una clase de datos, luego usa el objeto state en lugar del elemento remember y asigna el valor state a las copias clonadas de la clase original mediante el método de conveniencia del elemento copy(...) de la clase datos.

    Es importante tener en cuenta que este enfoque solo funciona cuando las únicas transformaciones de esa clase se realizan en el mismo alcance que se crea la instancia State. Si la clase está mutando de manera interna fuera del alcance del uso y confías en esa observación, querrás usar el siguiente enfoque.

    data class Position(
     val x: Int,
     val y: Int
    )
    
    @Composable fun Example() {
     var p by state { Position(0, 0) }
     PositionChanger(
       position=p,
       onXChange={ p = p.copy(x=it) }
       onYChange={ p = p.copy(y=it) }
     )
    }
    

    Alternativa 2: usa mutableStateOf y los delegados de propiedad.

    Este enfoque es más fácil con los delegados de propiedad de Kotlin y la API del objeto mutableStateOf, que te permite crear instancias MutableState fuera de la composición. En esencia, reemplaza todas las propiedades del objeto var de la clase original con las propiedades del elemento var con el objeto mutableStateOf como su delegado de propiedad. Esto tiene la ventaja de que el uso de la clase no cambiará en absoluto, solo su implementación interna. Sin embargo, el comportamiento no es completamente idéntico al del ejemplo original, ya que cada propiedad se observa o se suscribe de forma individual, por lo que las recomposiciones que observas después de esta refactorización pueden ser más limitadas (lo cual es bueno).

    class Position(x: Int, y: Int) {
     var x by mutableStateOf(x)
     var y by mutableStateOf(y)
    }
    
    // source of Example is identical to original
    @Composable fun Example() {
     var p = remember { Position(0, 0) }
     PositionChanger(
       position=p,
       onXChange={ p.x = it }
       onYChange={ p.y = it }
     )
    }
    

    (I409e8, b/152050010, b/146362815, b/146342522, b/143413369, b/135715219, b/143263925, b/139653744)

  • Cambia la estrategia para la generación de código del compilador de Compose. Antes del cambio, el compilador de compose transformaba las llamadas en funciones que admiten composición. Con este cambio, ahora transformamos el cuerpo de este tipo de función sin modificar (en su mayor parte) el sitio de llamada.

    Esto significa que la mayor parte de la lógica que se comunica con el tiempo de ejecución de compose sucede al comienzo del cuerpo de la función, en lugar de ocurrir en el sitio de llamada.

    Este cambio debería ser compatible con código fuente para cualquier uso de compose. La mayoría de los usuarios de compose no deberían tener que actualizar ningún código como resultado de este cambio.

    A fin de brindar compatibilidad con este trabajo, se ha modificado la firma de JVM de todas las funciones que admiten composición. Una función que admite composición y que acepta un solo parámetro se transforma en una función que acepta 3 parámetros. Los parámetros adicionales son Composer, un objeto integer. "clave", que es un valor entero de máscara de bits que se utiliza para propagar metadatos a través de llamadas.

    Ahora, Compose también transforma los argumentos predeterminados en una función que admite composición. Lo hace sin introducir una sobrecarga sintética, adicional y predeterminada de la función. Como resultado, este cambio tendrá menos funciones que se definan.

    Como consecuencia, se realizarán los siguientes cambios de comportamiento intencionales conocidos:

    1. Algunas llamadas se omitirán en los casos en que antes no hubiese ocurrido.
    2. Ahora, se suscriben y se administran correctamente las expresiones que admiten composición en las expresiones de argumento predeterminados.

    En este trabajo, se incluyeron algunas optimizaciones: 1. El resultado de las comparaciones de parámetros se propaga a otras funciones que admiten composición mediante el gráfico de llamadas. Como resultado, se realizarán menos comparaciones en el tiempo de ejecución, se reducirá el tamaño de la tabla de ranuras y se omitirán más funciones que admiten composición que antes no se omitían. 2. Los parámetros que se determinan "estáticos" en el tiempo de compilación ya no se comparan ni se almacenan en el tiempo de ejecución. Esto reduce la cantidad de comparaciones y el tamaño de la tabla de ranuras. 3. Se utiliza la estructura para el flujo de control del cuerpo de las funciones a fin de minimizar la cantidad de grupos que se generan. Esto reduce el tamaño de la tabla de ranuras y da como resultado menos trabajo para el tiempo de ejecución. 4. Si los parámetros de envío y recepción para las funciones no se utilizan dentro del cuerpo de la función, no se los incluye para determinar si se puede omitir la función.

    La mayoría de los cambios rotundos se realizaron en las API a las que el compilador se orienta de manera directa, y el uso típico de Compose no se verá afectado: 1. Se quitó el objeto Composer::startExpr. 2. Se quitó el objeto Composer::endExpr. 3. Composer::call quedó obsoleto. 4. Se quitaron las sobrecargas del objeto key que no son varargs. Usa la versión vararg en el futuro. 5. La anotación Pivotal quedó obsoleta. Usa el objeto key como reemplazo. 6. Se cambió el objeto ScopeUpdateScope::updateScope para esperar un elemento Function3 en lugar de Function1. 7. Se actualizaron los objetos restartableFunction y restartableFunctionN para que incluyan parámetros adicionales de tiempo de compilación. (I60756, b/143464846)

  • Se agregaron sortWith y removeRange a MutableVector. (Icccf7)

  • Se agregaron implementaciones de métodos de configuración predeterminada para CompositionLifecycleObserver. (I24289)

  • El aplicador ahora requiere un método clear() para desechar las composiciones. (Ibe697)

  • Se agregó asMutableList() a MutableVector para permitir que se pase a la API pública sin tener que copiar la lista completa. (I298df)

  • Se agregó el elemento rememberCoroutineScope() para obtener un CoroutineScope administrado en la composición a fin de iniciar trabajos en respuesta a eventos. (I0e264)

  • MutableVector es una colección nueva que no implementa ninguna de las interfaces estándar de la colección. Esta colección ofrece velocidad por sobre otros requisitos y está diseñada para usarse solo en implementaciones internas. (I8ebd6)

  • Se quitó temporalmente StableMutableList y StableMutableMap para evitar un error en la versión de Kotlin que Compose requiere. Estas interfaces volverán a introducirse una vez que Compose se haya actualizado a una versión de Kotlin que no presente este error.

    SnapshotStateList y SnapshotStateMap ahora son públicos, pero dejarán de estar disponibles cuando se restablezcan StableMutableList y StableMutableMap. (Ia7769)

  • agrega la función withFrameNanos de nivel superior para la sincronización de la animación. (Ie34c5)

  • La anotación @Untracked dejó de estar disponible. Reemplázala con @ComposableContract(tracked=false). (Id211e)

  • Se cambió el nombre de RestartableFunction y de las API asociadas por ComposableLambda, etc. El compilador solo modificó esas API, por lo que en general no debería afectar la compatibilidad a nivel de la fuente. El cambio de nombre se realizó, ante todo, para comunicar de una mejor manera qué es esta clase cuando aparece en seguimientos de pila. (I7eb25)

  • La anotación @Composable ya no es válida en las clases. (Ia5f02)

  • Ambient<T> ahora es @Stable en lugar de @Immutable. (I0b4bb)

  • Antes del cambio, el complemento del compilador de Compose interceptaría llamadas no triviales a los constructores dentro de una función @Composable si hubiese una. (I5205a, b/158123804)

  • La función Recompose que admite composición ya no es una abstracción útil. La mayor parte de la recomposición debería ocurrir como resultado de las asignaciones de MutableState. Para todo lo demás, se recomienda usar la función invalidate a fin de activar una recomposición del alcance actual. (Ifc992)

  • Observe ya no es una abstracción útil. Si necesitas replicarla, su implementación se puede replicar con solo crear una función que admite composición que ejecute un parámetro lambda componible. Por ejemplo, @Composable fun Observe(body: @Composable () -> Unit) = body() (I40d37)

  • @Direct quedó obsoleto y se lo reemplazó con @ComposableContract(restartable=false). (If4708)

  • Se agregó un adaptador para StateFlow que se introdujo hace poco y que permite completar previamente el valor inicial, de manera que el objeto State que se muestra no sea nulo. (I61dd8, b/156233789)

  • Se agregó un adaptador para Flow. Ejemplo del uso: valor de flow.collectAsState(). (If2198, b/153375923)

  • Los operadores delegados de la propiedad [Mutable]State se movieron a extensiones a fin de admitir optimizaciones delegadas de propiedad de Kotlin 1.4. Los emisores deben agregar importaciones para continuar usando by state { ... } o by mutableStateOf(...). (I5312c)

  • Se trasladó el objeto androidx.compose.ViewComposer al elemento androidx.ui.node.UiComposer androidx.compose. Se quitó el parámetro Emittable. Era redundante con el objeto ComponentNode. Se quitó el elemento androidx.compose.ViewAdapters. Ya no es un caso práctico admitido. Compose.composeInto quedó obsoleto. En su lugar, usa los elementos setContent o setViewContent. El componente Compose.disposeComposition dejó de estar disponible. En su lugar, usa el método dispose en el objeto Composition que muestra setContent. Se movió androidx.compose.Compose.subcomposeInto a androidx.ui.core.subcomposeInto. Se cambió el nombre de ComponentNode#emitInsertAt a ComponentNode#insertAt, el de ComponentNode#emitRemoveAt a ComponentNode#removeAt y el de ComponentNode#emitMode a ComponentNode#move. (Idef00)

  • Se actualizó la marca ComposeFlags.COMPOSER_PARAM para que sea true, lo que cambiará la estrategia de generación de código para el complemento de composición. En un nivel alto, esto provoca que las funciones @Composable se generen con un parámetro sintético adicional, que se pasa a través de llamadas @Composable posteriores para que el entorno de ejecución administre la ejecución correctamente. Este es un cambio rotundo el objeto binario; sin embargo, debería preservar la compatibilidad a nivel de la fuente en todo uso sancionado de la composición. (I7971c)

  • Cambios rotundos en la API de ambients. Consulta el registro y la documentación de Ambient<T> para obtener más detalles. (I4c7ee, b/143769776)

  • Se agregó ui-livedata, un nuevo artefacto con un adaptador para LiveData. Ejemplo del uso: valor de liveData.observeAsState(). (Ie9e8c, b/150465596)

  • Los adaptadores Rx sin valor inicial explícito quedaron obsoletos. El uso del valor nulo no siempre es la mejor configuración predeterminada: por ejemplo, cuando tienes una Lista, es mejor comenzar con emptyList() o con cualquier otro valor predeterminado razonable. (I00025, b/161348384)

  • Se agregó ui-rxjava2, un nuevo artefacto con adaptadores para RxJava2. Ejemplo del uso: valor de observable.subscribeAsState(). (Ifab4b, b/153369097)

  • Ahora se puede usar savedInstanceState() con tipos anulables. (I6847f, b/153532190)

  • Se agregaron los nuevos elementos listSaver() y mapSaver() a fin de facilitar la escritura de objetos Saver personalizados. (I8cf68, b/152331508)

  • Nuevas funciones: savedInstanceState() y rememberSavedInstanceState(). Son similares a state() y remember(), pero tienen una compilación de compatibilidad de estado de instancias guardada. (If1987, b/152025209)

Correcciones de errores

  • Se cambió el nombre de runOnIdleCompose por runOnIdle. (I83607)
  • Se creó la API experimental LayoutNode. (I4f2e9)
  • androidx.ui.foundation.TextFieldValue y androidx.ui.input.EditorValue quedaron obsoletos. TextField, FilledTextField y CoreTextField que admiten composición y usan dicho tipo también quedaron obsoletos. En su lugar, usa androidx.ui.input.TextFieldValue. (I4066d, b/155211005)
  • Se quitó la API obsoleta del objeto DrawBackground y se reemplazó por las API de la extensión drawBackground en Modifier. Implementaciones refactorizadas de color, pincel y pintura del objeto drawBackground para reducir las rutas de código y quitar el requisito de crear Modifier como parte de la composición. (I0343a)
  • Se actualizaron las API de Compose de nivel superior que exponen un lienzo para mostrar el objeto CanvasScope en su lugar. Esto elimina la necesidad de que los consumidores mantengan sus propios objetos Paint. Para los consumidores que aún necesitan acceso a un lienzo, pueden usar el método de extensión drawCanvas que proporciona una devolución de llamada a fin de emitir comandos de dibujo con el lienzo subyacente. (I80afd)
  • Se modificó la API de WithConstraints con expresión lambda final. Ahora, en lugar de dos parámetros, tiene un alcance de receptor que, además de las restricciones y layoutDirection, brinda propiedades minWidth, maxWidth, minHeight y maxHeight en Dp. (I91b9a, b/149979702)
  • Se agregó un modificador de padding simétrico. (I39840)
  • Se actualizaron wrapContentWidth y wrapContentHeight para incluir Alignment vertical u horizontal en lugar de cualquier alineación. Se actualizó el modificador de gravedad para aceptar el elemento Alignment vertical u horizontal. Se actualizaron los objetos Row, Column y Stack para admitir el elementos Alignments continuos personalizados. (Ib0728)
  • Se cambió el nombre del módulo ui-text por ui-text-core. (I57dec)
  • Se mejoró la API de DrawModifier:
    • Se creó el alcance del receptor para draw() ContentDrawScope.
    • Se quitaron todos los parámetros de draw().
    • El objeto DrawScope tiene la misma interfaz que el elemento CanvasScope anterior.
    • ContentDrawScope tiene el método drawContent(). (Ibaced, b/152919067)
  • ColoredRect quedó obsoleto. Usa Box(Modifier.preferredSize(width, height).drawBackground(color)) en su lugar. (I499fa, b/152753731)
  • Se reemplazaron el modificador y el operador por funciones de extensión (I225e4)
  • Ahora se puede acceder a los miembros RowScope y ColumnScope desde afuera de la fila y la columna. (I3a641)
  • Se cambió el nombre de LayoutFlexible por LayoutWeight. Se cambió el nombre del parámetro estricto para completar. (If4738)
  • WithConstraints tiene el parámetro LayoutDirection (I6d6f7)
  • Se cambió el nombre de background a DrawBackground y se lo estableció para memorizar de forma predeterminada. (Ia0bd3)
  • Se reemplazó ButtonStyle con funciones distintas y se quitó la sobrecarga de texto (string). Consulta muestras actualizadas para obtener información de uso. (If63ab, b/146478620, b/146482131)
  • Los objetos runOnIdleCompose y runOnUiThread ahora son funciones globales en lugar de ser métodos en ComposeTestRule. (Icbe8f)

Contribución externa

  • Se quitaron las API innecesarias como Looper y Handler de la capa de portabilidad del entorno de ejecución de Compose. (I6847d)
  • Elimina el elemento Flow<T>.collectAsState() sin valor inicial. Usa StateFlow<T> o pasa un valor inicial explícito (I63f98, b/157674865)