Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Redactar

Define tu IU de manera programática con funciones que admiten composición que describan su forma y sus dependencias de datos.
Actualización más reciente Versión estable actual Próxima versión potencial Versión beta Versión Alfa
2 de septiembre de 2020 - - - 1.0.0-alpha02

Estructura

Compose es una combinación de 7 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
composeDefine tu IU de manera programática con funciones que admiten composición que describan su forma y sus dependencias de datos.
compose.animationCrea animaciones en sus aplicaciones de Jetpack Compose para enriquecer la experiencia del usuario.
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.runtimeSon los componentes básicos del modelo de programación de Compose y la administración de estados, y el entorno de ejecución principal para el 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.
uiFunciona con la biblioteca de Jetpack Compose.

Cómo declarar dependencias

Para agregar una dependencia en Compose, debes agregar el repositorio 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:

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerVersion "1.4.0"
        kotlinCompilerExtensionVersion "1.0.0-alpha02"
    }
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    kotlinOptions {
        jvmTarget = "1.8"
        freeCompilerArgs += ["-Xallow-jvm-ir-dependencies", "-Xskip-prerelease-check"]
    }
}

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.

Crea 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-alpha02

2 de septiembre de 2020

Lanzamiento de androidx.compose:compose-compiler:1.0.0-alpha02 sin cambios desde 1.0.0-alpha01. La versión 1.0.0-alpha02 contiene estas confirmaciones.

Versión 1.0.0-alpha01

26 de agosto de 2020

Lanzamiento de androidx.compose:compose-compiler: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:compose-compiler:0.1.0-dev17. La versión 0.1.0-dev17 contiene estas confirmaciones.

Versión 0.1.0-dev16

5 de agosto de 2020

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

La mayoría de los paquetes de Jetpack Compose se refactorizaron de acuerdo con la tabla siguiente.

Refactorización de paquetes de Jetpack Compose

Nombre anterior del paquete Nombre nuevo del paquete
androidx.animation androidx.compose.animation.core
androidx.ui.autofill androidx.compose.ui.autofill
androidx.compose androidx.compose.runtime
androidx.compose.dispatch androidx.compose.runtime.dispatch
androidx.ui.animation androidx.compose.animation
androidx.ui.core androidx.compose.ui
androidx.compose.ui.unit
androidx.compose.ui.graphics
androidx.ui.foundation androidx.compose.foundation
androidx.ui.geometry androidx.compose.ui.geometry
androidx.ui.graphics androidx.compose.ui.graphics
androidx.ui.input androidx.compose.ui.text.input
androidx.ui.intl androidx.compose.ui.text.intl
androidx.ui.layout androidx.compose.foundation.layout
androidx.ui.livedata androidx.compose.runtime.livedata
androidx.ui.material androidx.compose.material
androidx.ui.material.icons androidx.compose.material.icons
androidx.ui.rxjava2 androidx.compose.runtime.rxjava2
androidx.ui.savedinstancestate androidx.compose.runtime.savedinstancestate
androidx.ui.node androidx.compose.ui.node
androidx.compose.ui.input.pointer
androidx.ui.platform androidx.compose.ui.platform
androidx.ui.res androidx.compose.ui.res
androidx.ui.semantics androidx.compose.ui.semantics
androidx.ui.testutils androidx.compose.ui.input.pointer
androidx.ui.text androidx.compose.foundation.text
androidx.compose.ui.text
androidx.ui.text.platform androidx.compose.ui.text.android
androidx.compose.ui.platform
androidx.ui.unit androidx.compose.ui.unit
androidx.ui.util androidx.compose.ui.util
androidx.ui.viewinterop androidx.compose.ui.viewinterop
androidx.ui.viewmodel androidx.compose.ui.viewinterop
Aún no se refactorizó (sin cambios)
androidx.ui.test
androidx.ui.tooling

Si usas Android Studio, puedes reemplazar tus declaraciones de importación por el siguiente fragmento de código y usar el botón Optimize Imports en Android Studio. Para los casos que Android Studio no cubre, consulta la lista de paquetes indicada más arriba.

  import androidx.compose.runtime.*
  import androidx.compose.animation.*
  import androidx.compose.animation.core.*
  import androidx.compose.foundation.*
  import androidx.compose.foundation.gestures.*
  import androidx.compose.foundation.layout.*
  import androidx.compose.foundation.lazy.*
  import androidx.compose.foundation.shape.*
  import androidx.compose.material.*
  import androidx.compose.material.icons.*
  import androidx.compose.material.icons.filled.*
  import androidx.compose.ui.*
  import androidx.compose.ui.geometry.*
  import androidx.compose.ui.draw.*
  import androidx.compose.ui.graphics.*
  import androidx.compose.ui.graphics.drawscope.*
  import androidx.compose.ui.graphics.painter.*
  import androidx.compose.ui.graphics.vector.*
  import androidx.compose.ui.layout.*
  import androidx.compose.ui.platform.*
  import androidx.compose.ui.res.*
  import androidx.compose.ui.text.*
  import androidx.compose.ui.text.font.*
  import androidx.compose.ui.text.style.*
  import androidx.compose.ui.unit.*
  import androidx.compose.ui.util.*
  import androidx.compose.ui.viewinterop.*
  import androidx.ui.tooling.preview.*

Versión 0.1.0-dev15

22 de julio de 2020

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

La mayoría de los artefactos de Jetpack Compose se refactorizaron de acuerdo con la tabla siguiente.

Ten en cuenta que, en esta versión, solo se refactorizaron los nombres de artefactos. En futuras versiones, se actualizarán los nombres de los paquetes para que sigan su nombre de artefacto nuevo.

Refactorización de artefactos de Jetpack Compose

Artefacto anterior Nuevo artefacto
androidx.compose:compose-dispatch androidx.compose.runtime:runtime-dispatch
androidx.compose:compose-runtime androidx.compose.runtime:runtime
androidx.ui:ui-animation androidx.compose.animation:animation
androidx.ui:ui-animation-core androidx.compose.animation:animation-core
androidx.ui:ui-core androidx.compose.ui:ui
androidx.ui:ui-foundation androidx.compose.foundation:foundation
androidx.ui:ui-geometry androidx.compose.ui:ui-geometry
androidx.ui:ui-graphics androidx.compose.ui:ui-graphics
androidx.ui:ui-layout androidx.compose.foundation:foundation-layout
androidx.ui:ui-livedata androidx.compose.runtime:runtime-livedata
androidx.ui:ui-material androidx.compose.material:material
androidx.ui:ui-material-icons-core androidx.compose.material:material-icons-core
androidx.ui:ui-material-icons-extended androidx.compose.material:material-icons-extended
androidx.ui:ui-rxjava2 androidx.compose.runtime:runtime-rxjava2
androidx.ui:ui-saved-instance-state androidx.compose.runtime:runtime-saved-instance-state
androidx.ui:ui-text androidx.compose.foundation:foundation-text
androidx.ui:ui-text-android androidx.compose.ui:ui-text-android
androidx.ui:ui-text-core androidx.compose.ui:ui-text
androidx.ui:ui-unit androidx.compose.ui:ui-unit
androidx.ui:ui-util androidx.compose.ui:ui-util
Aún no se refactorizó (sin cambios)
androidx.compose:compose-compiler
androidx.ui:ui-test
androidx.ui:ui-tooling

Actualización de dependencias

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

Versión 0.1.0-dev14

24 de junio de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev14 y androidx.compose:compose-runtime:0.1.0-dev14. La versión 0.1.0-dev14 contiene estas confirmaciones.

Cambios en la API

  • 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 dejó de estar disponible y se reemplazó por @ComposableContract(restartable=false) (If4708)

Correcciones de errores

  • androidx.ui.foundation.TextFieldValue y androidx.ui.input.EditorValue dejaron de estar disponibles. Los elementos que admiten composición TextField, FilledTextField y CoreTextField que usan ese tipo también dejaron de estar disponibles. En su lugar, usa androidx.ui.input.TextFieldValue(I4066d y b/155211005)

Contribución externa

  • El objeto Flow<T>.collectAsState() dejó de estar disponible sin valor inicial. Usa StateFlow<T> o pasa un valor inicial explícito (I63f98 y b/157674865).
    • Gracias a Zach Klippenstein de Square por contribuir con el siguiente cambio.

Versión 0.1.0-dev13

10 de junio de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev13 y androidx.compose:compose-runtime:0.1.0-dev13. La versión 0.1.0-dev13 contiene estas confirmaciones.

Errores conocidos

  • Cuando la aplicación dependa de androidx.core:core-ktx:1.2.0 y se use una FontFamily con varias fuentes o tamaños de fuentes, se procesará la selección de fuentes en una fuente de tamaño normal. Trabajaremos para solucionar este problema; por el momento, la solución consiste en usar androidx.core:core-ktx:1.2.0-alpha01 o androidx.core:core-ktx:1.1.0.

Versión 0.1.0-dev12

27 de mayo de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev12 y androidx.compose:compose-runtime:0.1.0-dev12. La versión 0.1.0-dev12 contiene estas confirmaciones.

Cambios en la API

  • 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 tres 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. El objeto Composer::call dejó de estar disponible.
    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 dejó de estar disponible. 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 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)

La anotación del objeto @Model dejó de estar disponible.

  • La anotación del objeto @Model dejó de estar disponible. Usa los elementos 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 estructurada frente a la igualdad referencial para usarla en la observación?
    • Reduce la "magia" en el 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 el objeto 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)

Correcciones de errores

  • 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, b/155999867)

Versión 0.1.0-dev11

14 de mayo de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev11 y androidx.compose:compose-runtime:0.1.0-dev11. La versión 0.1.0-dev11 contiene estas confirmaciones.

Cambios en la API

  • Se agregó un adaptador para Flow. Ejemplo de uso:

    val value by flow.collectAsState()
    

    (If2198, b/153375923)

Correcciones de errores

  • 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 del objeto 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 el objeto layoutDirection, proporciona propiedades minWidth, maxWidth, minHeight y maxHeight en Dp. (I91b9a, b/149979702)
  • Se agregó un modificador de padding simétrico. (I39840)

Versión 0.1.0-dev10

29 de abril de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev10 y androidx.compose:compose-runtime:0.1.0-dev10. La versión 0.1.0-dev10 contiene estas confirmaciones.

Nuevas funciones

  • Se basa en una versión más reciente del backend de representación intermedia (IR) del compilador de Kotlin, lo que significa que muchas de las características que antes no funcionaban con el backend de IR (como las corrutinas que no admiten composición) ya deberían funcionar. Esto supone que recibes menos mensajes "Backend internal error" y no necesitas trabajar tanto para separar tu código en módulos IR y que no sean IR. Sin embargo, el backend de IR sigue en etapa experimental, y aún tiene algunos errores (solo que muchos menos), así que prueba y disfruta, pero ten en cuenta que todavía proyecto en desarrollo.

Versión 0.1.0-dev09

15 de abril de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev09 y androidx.compose:compose-runtime:0.1.0-dev09. La versión 0.1.0-dev09 contiene estas confirmaciones.

Cambios en la API

  • 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)

Correcciones de errores

  • Se actualizaron wrapContentWidth y wrapContentHeight para incluir Alignment vertical u horizontal en lugar de Alignment. Se actualizó el modificador de gravedad para aceptar Alignment vertical u horizontal. Se actualizaron Row, Column y Stack para admitir Alignment continuas personalizadas. (Ib0728)
  • Se cambió el nombre del módulo ui-text a ui-text-core (I57dec)
  • Se mejoró la API DrawModifier (Ibaced, b/152919067):
    • El alcance del receptor incluye draw() ContentDrawScope
    • Se quitaron todos los parámetros de draw()
    • DrawScope tiene la misma interfaz que el CanvasScope anterior
    • ContentDrawScope tiene el método drawContent()
  • El elemento ColoredRect dejó de estar disponible. Usa Box(Modifier.preferredSize(width, height).drawBackground(color)) en su lugar. (I499fa, b/152753731)

Versión 0.1.0-dev08

1 de abril de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev08 y androidx.compose:compose-runtime:0.1.0-dev08. La versión 0.1.0-dev08 contiene estas confirmaciones.

Correcciones de errores

  • Se reemplazaron el modificador y el operador por funciones de extensión de fábrica (I225e4)
  • Ahora se puede acceder a los miembros RowScope y ColumnScope desde afuera de la fila y la columna. (I3a641)

Versión 0.1.0-dev07

18 de marzo de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev07 y androidx.compose:compose-runtime:0.1.0-dev07. La versión 0.1.0-dev07 contiene estas confirmaciones.

Cambios en la API

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

Correcciones de errores

  • 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)

Versión 0.1.0-dev06

4 de marzo de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev06 y androidx.compose:compose-runtime:0.1.0-dev06. La versión 0.1.0-dev06 contiene estas confirmaciones.

Nuevas funciones

  • 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 e importante del objeto binario; sin embargo, debe preservarse la compatibilidad a nivel de la fuente en todo uso sancionado de la composición. (aosp/1226314)

Versión 0.1.0-dev05

19 de febrero de 2020

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

Cambios en la API

  • 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)

Correcciones de errores

  • 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)

Versión 0.1.0-dev04

29 de enero de 2020

Lanzamiento de androidx.compose:compose-compiler:0.1.0-dev04 y androidx.compose:compose-runtime:0.1.0-dev04. Para conocer las confirmaciones incluidas en esta versión, consulta este vínculo.

Cambios en la API

  • Se agregó una devolución de llamada areEquivalent a MutableState (Ic2ef8).
  • Se quitaron las API de composición de nivel superior de los componentes y la refactorización (I1f22e)
  • Transforma las llamadas que admiten composición con el parámetro de compositor (I1691e)
  • Se quitaron las clases de composición y se reemplazaron con la clase base Composer (Ieadbf)
  • Marca State<T> y MutableState<T> como tipos estables (b/146557624)
  • Agrega currentComposerIntrinsic y pruebas para asegurarte de que el parámetro pase correctamente (I133f0)
  • ModelObserver se hizo de un solo subproceso. (Ica33d)
  • Genera grupos correctamente para las llamadas intercaladas que admiten composición (Ibf739)
  • Quita la anotación EffectsDsl sin usar (Ibe81d)
  • Se agregó una anotación @Stable. Se marcó el modificador como estable. (Iacba7)
  • Se introdujeron las API MutableState, State y mutableStateOf (I98291)
  • Se refactorizaron efectos de @Composable (Ie2686)
  • Se mejoró el rendimiento de ObserverMap y ModelObserver. (Ieb9b6)
  • Se cambiaron las observaciones de lectura para permitir la observación de no-ComponentNodes. (Ia4d93)