O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Compose

Defina a IU de maneira programática com funções que podem ser compostas e que descrevem a forma e as dependências de dados dela.
Atualização mais recente Versão estável atual Próximo candidato a lançamento Versão Beta Versão Alfa
16 de setembro de 2020 - - - 1.0.0-alpha04

Estrutura

O Compose é uma combinação de sete IDs de grupos do Maven em androidx. Cada grupo contém um subconjunto direcionado de funcionalidades, cada um com um conjunto próprio de notas da versão.

Esta tabela explica os grupos e contém links para cada conjunto de notas da versão.

GrupoDescrição
compose.animationCrie animações nos aplicativos Jetpack Compose para enriquecer a experiência do usuário.
compose.compilerTransforme funções @Composable e ative otimizações com um plug-in do compilador Kotlin.
compose.foundationCrie aplicativos do Jetpack Compose com blocos de versão prontos e amplie a base para criar suas próprias peças de sistema de design.
compose.materialCrie IUs do Jetpack Compose com componentes do Material Design prontos para uso. Este é o ponto de entrada de nível mais alto do Compose, projetado para fornecer componentes que correspondam aos descritos em www.material.io.
compose.runtimeElementos fundamentais do modelo de programação e do gerenciamento de estado do Compose e do ambiente de execução principal do plug-in Compose Compiler.
compose.uiComponentes fundamentais da IU do Compose necessários para interagir com o dispositivo, incluindo layout, desenho e entrada.
iuFunciona com a biblioteca Jetpack Compose.

Declarar dependências

Para adicionar uma dependência ao Compose, adicione o repositório Maven do Google ao seu projeto. Leia Repositório Maven do Google para ver mais informações.

Adicione as dependências dos artefatos necessários no arquivo build.gradle para seu app ou módulo:

android {
    buildFeatures {
        compose true
    }

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

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

Para ver mais informações sobre dependências, consulte Adicionar dependências de compilação.

Feedback

Seu feedback ajuda a melhorar o Jetpack. Avise se você descobrir novos problemas ou tiver ideias para melhorar esta biblioteca. Consulte os problemas existentes (link em inglês) nesta biblioteca antes de criar um novo. Adicione seu voto a um problema existente clicando no botão de estrela.

Criar novo problema (link em inglês)

Consulte a documentação do Issue Tracker para saber mais.

Versão 1.0.0

Versão 1.0.0-alpha04

1º de outubro de 2020

O androidx.compose:compose-compiler foi refatorado para androidx.compose.compiler:compiler com a versão 1.0.0-alpha04. Consulte a página Compose Compiler para versões futuras.

Versão 1.0.0-alpha03

16 de setembro de 2020

Lançamento de androidx.compose:compose-compiler:1.0.0-alpha03. A versão 1.0.0-alpha03 contém estas confirmações.

Versão 1.0.0-alpha02

2 de setembro de 2020

Lançamento de androidx.compose:compose-compiler:1.0.0-alpha02 sem mudanças desde a versão 1.0.0-alpha01. A versão 1.0.0-alpha02 contém essas confirmações.

Versão 1.0.0-alpha01

26 de agosto de 2020

Lançamento do androidx.compose:compose-compiler:1.0.0-alpha01. A versão 1.0.0-alpha01 contém essas confirmações.

Versão 0.1.0-dev

Versão 0.1.0-dev17

19 de agosto de 2020

androidx.compose:compose-compiler:0.1.0-dev17 é lançado. A versão 0.1.0-dev17 contém essas confirmações.

Versão 0.1.0-dev16

5 de agosto de 2020

androidx.compose:compose-compiler:0.1.0-dev16 é lançado. A versão 0.1.0-dev16 contém essas confirmações.

A maioria dos pacotes do Jetpack Compose foi refatorada de acordo com a tabela abaixo.

Refatoração de pacotes do Jetpack Compose

Nome do pacote antigo Nome do novo pacote
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
Ainda não refatorado (sem mudanças)
androidx.ui.test
androidx.ui.tooling

Se você estiver usando o Android Studio, poderá substituir as instruções de importação pelo snippet de código abaixo e usar o botão Optimize Imports no Android Studio. Para casos que o Android Studio não abrange, consulte a lista de pacotes acima.

  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.*

Versão 0.1.0-dev15

22 de julho de 2020

Lançamento do androidx.compose:compose-compiler:0.1.0-dev15. A versão 0.1.0-dev15 contém essas confirmações.

A maioria dos artefatos do Jetpack Compose foi refatorada, de acordo com a tabela abaixo.

Observe que, nessa versão, apenas os nomes de artefatos foram refatorados. Em versões futuras, os nomes dos pacotes serão atualizados para seguir o novo nome de artefato.

Refatoração de artefatos do Jetpack Compose

Artefato antigo Novo artefato
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
Ainda não refatorado (sem mudanças)
androidx.compose:compose-compiler
androidx.ui:ui-test
androidx.ui:ui-tooling

Atualização de dependências

  • Para usar a versão 0.1.0-dev15 do Compose, será necessário atualizar suas dependências de acordo com os novos snippets de código mostrados acima em Como declarar dependências.

Versão 0.1.0-dev14

24 de junho de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev14 e androidx.compose:compose-runtime:0.1.0-dev14. A versão 0.1.0-dev14 contém estas confirmações (link em inglês).

Mudanças na API

  • O composto Recompose não é mais uma abstração útil. A maioria das recomposições precisa acontecer como resultado de atribuições MutableState. Para qualquer coisa além disso, é recomendável usar a função invalidate para acionar uma recomposição do escopo atual (Ifc992, link em inglês).
  • Observe não é mais uma abstração útil. Se você precisar replicá-la, a implementação dela poderá ser replicada apenas com a criação de uma função que pode ser composta que execute um parâmetro lambda de composição. Por exemplo, @Composable fun Observe(body: @Composable () -> Unit) = body() (I40d37, link em inglês).
  • @Direct teve o uso suspenso em favor de @ComposableContract(restartable=false) (If4708, link em inglês).

Correções de bugs

  • androidx.ui.foundation.TextFieldValue e androidx.ui.input.EditorValue estão obsoletos. Os compostos TextField, FilledTextField e CoreTextField que usam esse tipo também estão obsoletos. Use androidx.ui.input.TextFieldValue (I4066d, b/155211005, links em inglês).

Contribuição externa

  • Suspensão do uso de Flow<T>.collectAsState() sem valor inicial. Use StateFlow<T> ou transmita um valor inicial explícito (I63f98, b/157674865, links em inglês).
    • Agradecemos a Zach Klippenstein do Square por contribuir com a mudança a seguir.

Versão 0.1.0-dev13

10 de junho de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev13 e androidx.compose:compose-runtime:0.1.0-dev13. A versão 0.1.0-dev13 contém estas confirmações (link em inglês).

Problemas conhecidos

  • Quando o aplicativo depende de androidx.core:core-ktx:1.2.0 e uma FontFamily com várias fontes / pesos de fonte é usada, a seleção de fontes é renderizada no peso normal da fonte. Trabalharemos nesse problema e, no momento, a solução alternativa é usar androidx.core:core-ktx:1.2.0-alpha01 ou androidx.core:core-ktx:1.1.0.

Versão 0.1.0-dev12

27 de maio de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev12 e androidx.compose:compose-runtime:0.1.0-dev12. A versão 0.1.0-dev12 contém estas confirmações (link em inglês).

Mudanças na API

  • Muda a estratégia de geração de código do compilador do Compose. Antes da mudança, ele transformava chamadas em funções compostas. Com essa mudança, agora transformamos o corpo de uma função composta e deixamos o local de chamadas praticamente inalterado.

    Isso significa que a maior parte da lógica que se comunica com o ambiente de execução do Compose acontece no início do corpo da função e não no local de chamadas.

    Essa deve ser uma mudança compatível com a fonte para todo o uso do Compose. A maioria dos usuários do Compose não precisa atualizar nenhum código como resultado dessa mudança.

    Para oferecer suporte a esse trabalho, a assinatura JVM de todas as funções compostas foi mudada. Uma função composta que aceita um único parâmetro é transformada em uma função que aceita três parâmetros. Os parâmetros adicionais são o Composer, um número inteiro "chave", um inteiro de bitmask usado para propagar metadados por meio de chamadas.

    O Compose agora também transforma argumentos padrão em uma função composta. Ele faz isso sem introduzir uma sobrecarga padrão sintética adicional da própria função. Portanto, essa mudança resultará na definição de menos funções.

    Mudanças comportamentais intencionais conhecidas resultantes disso:

    1. Algumas chamadas serão ignoradas.
    2. As expressões compostas em expressões de argumento padrão agora são corretamente inscritas e processadas.

    Esse trabalho incluiu algumas otimizações:

    1. O resultado das comparações de parâmetros é propagado por meio do gráfico de chamadas para outras funções compostas. Isso resultará em menos comparações em tempo de execução, reduzirá o tamanho da tabela de slots, bem como mais pulos de funções compostas que não foram ignoradas anteriormente.
    2. Os parâmetros que são determinados como "estáticos" no momento da compilação não são mais comparados ou armazenados no ambiente de execução. Isso reduz o número de comparações e o tamanho da tabela de slots.
    3. A estrutura do controle de fluxo do corpo das funções é usada para minimizar o número de grupos gerados. Isso reduz o tamanho da tabela de slots e resulta em menos trabalho para o ambiente de execução.
    4. Os parâmetros de envio e destinatário não utilizados para funções não são incluídos para determinar a possibilidade de pular a função se eles não forem usados dentro do corpo da função.

    A maioria das mudanças interruptivas foi feita para APIs que o compilador segmenta diretamente e o uso típico do Compose não será afetado:

    1. Composer::startExpr foi removido.
    2. Composer::endExpr foi removido.
    3. Composer::call foi suspenso.
    4. As sobrecargas que não são varargs de key foram removidas. Use a versão vararg daqui em diante.
    5. A anotação Pivotal foi suspensa. Use key como substituto.
    6. ScopeUpdateScope::updateScope foi mudado para esperar uma Function3 em vez de Function1.
    7. restartableFunction e restartableFunctionN foram atualizadas para incluir parâmetros de tempo de compilação adicionais.

    (I60756, b/143464846, links em inglês)

  • Adição de um adaptador para o StateFlow introduzido recentemente que permite preencher o valor inicial para que o estado retornado não seja anulável (I61dd8, b/156233789 link em inglês).

A anotação @Model agora está obsoleta.

  • A anotação @Model agora está obsoleta. Use state e mutableStateOf como alternativas. Essa decisão de suspensão foi tomada após uma discussão cuidadosa.

    Motivo

    O motivo inclui, mas não se limita ao seguinte:

    • Reduz a área de superfície da API e os conceitos que precisamos ensinar.
    • Alinha-se melhor a outros kits de ferramentas comparáveis (Swift UI, React, Flutter).
    • Decisão reversível. Podemos trazer @Model de volta a qualquer momento.
    • Remove o uso de caso isolado e dificulta responder a perguntas sobre como configurar o @Model como coisas que precisamos lidar.
      • Classes de dados @Model, equals, hashcode etc.
      • Como faço para que algumas propriedades sejam "observadas" e outras não?
      • Como especificar a igualdade organizacional x referencial a ser usada na observação?
    • Reduz a "mágica" no sistema. Reduziria a probabilidade de alguém supor que o sistema era mais inteligente do que é (ou seja, saber diferenciar uma lista).
    • Torna a granularidade da observação mais intuitiva.
    • Aprimora a refatoração da propriedade "variável" na classe.
    • Abre potencialmente possibilidades para fazer otimizações específicas do estado.
    • Alinha-se melhor ao restante do ecossistema e reduz ambiguidades em relação a imutáveis ou a "adotar o estado mutável".

    Notas de migração

    Quase todos os usos existentes de @Model são facilmente transformados de duas maneiras. O exemplo abaixo tem uma classe @Model com duas propriedades apenas para fins de exemplo e sendo usada em um composto.

    @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: use State<OriginalClass> e crie cópias.

    Essa abordagem é facilitada com as classes de dados do Kotlin. Basicamente, transforme todas as propriedades var anteriores em propriedades val de uma classe de dados, use state em vez de remember e atribua o valor do estado a cópias clonadas do original usando o método de conveniência copy(...) da classe de dados.

    É importante observar que essa abordagem só funciona quando as únicas mutações para essa classe foram feitas no mesmo escopo em que a instância de State foi criada. Se a classe estiver se modificando internamente fora do escopo de uso e você estiver contando com a observação disso, a próxima abordagem será a que você deve usar.

    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: use mutableStateOf e delegados de propriedade.

    Essa abordagem é facilitada com os delegados de propriedade do Kotlin e a API mutableStateOf, que permite criar instâncias do MutableState fora da composição. Basicamente, substitua todas as propriedades var da classe original por var com mutableStateOf como delegado da propriedade. A vantagem é que não haverá mudança no uso da classe, apenas na implementação interna dela. No entanto, o comportamento não é completamente idêntico ao exemplo original, já que cada propriedade agora é observada/inscrita individualmente. Portanto, as recomposições que você vê após essa refatoração podem ser mais restritas (uma coisa boa).

    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, links em inglês)

Correções de bugs

  • Remoção da API DrawBackground obsoleta em favor das APIs de extensão drawBackground no modificador. Implementações de drawBackground de cores, pincéis e pintura refatoradas para reduzir os caminhos de código, bem como remover o requisito para que o modificador seja criado como parte da composição. (I0343a, b/155999867, links em inglês)

Versão 0.1.0-dev11

14 de maio de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev11 e androidx.compose:compose-runtime:0.1.0-dev11. A versão 0.1.0-dev11 contém estas confirmações (link em inglês).

Mudanças na API

  • Foi adicionado um adaptador para o fluxo. Exemplo do uso:

    val value by flow.collectAsState()
    

    (If2198, b/153375923, links em inglês)

Correções de bugs

  • Atualização das APIs de composição de nível superior que expõem uma tela para expor o CanvasScope. Isso elimina a necessidade dos consumidores manterem seus próprios objetos do Paint. Os consumidores que ainda precisam de acesso a uma tela podem usar o método de extensão drawCanvas, que fornece um retorno de chamada para emitir comandos de desenho. (I80afd, link em inglês)
  • A API WithConstraints lambda final foi mudada. Agora, em vez de dois parâmetros, ela tem um escopo de receptor que, além de restrições e layoutDirection, fornece as propriedades minWidth, maxWidth, minHeight e maxHeight no Dp (I91b9a , b/149979702, links em inglês).
  • Modificador de preenchimento simulado adicionado. (I39840, link em inglês)

Versão 0.1.0-dev10

29 de abril de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev10 e androidx.compose:compose-runtime:0.1.0-dev10. A versão 0.1.0-dev10 contém estas confirmações (link em inglês).

Novos recursos

  • Reformulada com base em uma nova versão do back-end de IR do compilador Kotlin, o que significa que muitos dos recursos que anteriormente não funcionavam com o back-end de IR (como corrotinas que não podiam ser compostas) funcionam agora. Isso significa que você encontrará menos mensagens complexas de "Erro interno de back-end" e não precisará se esforçar tanto para separar seu código em módulos de IR e não. No entanto, o back-end de IR ainda é experimental e ainda tem alguns bugs (muito menos bugs agora), então, faça testes e aproveite, mas lembre-se de que ainda é um projeto em andamento.

Versão 0.1.0-dev09

15 de abril de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev09 e androidx.compose:compose-runtime:0.1.0-dev09. A versão 0.1.0-dev9 contém estas confirmações (link em inglês).

Mudanças na API

  • [Mutable] Os operadores para delegação de propriedade de estado foram movidos para extensões compatíveis com as otimizações de delegação de propriedade do Kotlin 1.4. Os autores da chamada precisam adicionar importações para continuar usando by state { ... } ou by mutableStateOf(...) (I5312c, link em inglês).

Correções de bugs

  • wrapContentWidth e wrapContentHeight foram atualizados para esperar um Alignment vertical ou horizontal em vez de qualquer Alignment. O modificador de gravidade foi atualizado para aceitar Alignment vertical ou horizontal. Row, Column e Stack foram atualizadas para ter compatibilidade com Alignments contínuos personalizados. (Ib0728, link em inglês)
  • O módulo ui-text foi renomeado como ui-text-core (I57dec, link em inglês)
  • Aprimoramento da API DrawModifier (Ibaced, b/152919067, em inglês):
    • Definição do escopo do receptor de draw() como ContentDrawScope
    • Remoção de todos os parâmetros em draw()
    • DrawScope tem a mesma interface do antigo CanvasScope
    • ContentDrawScope tem o método drawContent()
  • ColoredRect está obsoleto. Use Box(Modifier.preferredSize(width, height).drawBackground(color)). (I499fa, b/152753731, links em inglês)

Versão 0.1.0-dev08

1º de abril de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev08 e androidx.compose:compose-runtime:0.1.0-dev08. A versão 0.1.0-dev08 contém estas confirmações (link em inglês).

Correções de bugs

  • Modificador mais operador substituídos com funções de extensão de fábrica (I225e4, link em inglês)
  • Os membros de RowScope e ColumnScope podem ser acessados fora de Row e Column. (I3a641, link em inglês)

Versão 0.1.0-dev07

18 de março de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev07 e androidx.compose:compose-runtime:0.1.0-dev07. A versão 0.1.0-dev07 contém estas confirmações (link em inglês).

Mudanças na API

  • O item androidx.compose.ViewComposer foi movido para androidx.ui.node.UiComposer. (Idef00, link em inglês)
  • O androidx.compose.Emittable foi removido. Ele ficou redundante com ComponentNode. (Idef00, link em inglês)
  • androidx.compose.ViewAdapters foram removidos. Eles não são mais um caso de uso compatível. (Idef00, link em inglês)
  • Compose.composeInto está obsoleto. Use setContent ou setViewContent. (Idef00, link em inglês)
  • Compose.disposeComposition está obsoleto. Use o método dispose no Composition retornado por setContent. (Idef00, link em inglês)
  • androidx.compose.Compose.subcomposeInto foi movido para androidx.ui.core.subcomposeInto. (Idef00, link em inglês)
  • ComponentNode#emitInsertAt foi renomeado como ComponentNode#insertAt. (Idef00, link em inglês)
  • ComponentNode#emitRemoveAt foi renomeado como ComponentNode#removeAt. (Idef00, link em inglês)
  • ComponentNode#emitMode foi renomeado como ComponentNode#move. (Idef00, link em inglês)

Correções de bugs

  • O LayoutFlexible foi renomeado como LayoutWight. O parâmetro restrito foi renomeado como preenchimento. (If4738, link em inglês)
  • WithConstraints recebeu o parâmetro LayoutDirection (I6d6f7, link em inglês)

Versão 0.1.0-dev06

4 de março de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev06 e androidx.compose:compose-runtime:0.1.0-dev06. A versão 0.1.0-dev06 contém estas confirmações (link em inglês).

Novos recursos

  • A sinalização ComposeFlags.COMPOSER_PARAM foi atualizada para true, o que mudará a estratégia de geração de código para o plug-in do Compose. Em um nível alto, isso faz com que funções @Composable sejam geradas com um parâmetro sintético extra, que é transmitido para chamadas @Composable subsequentes para que o ambiente de execução gerencie corretamente a execução. No entanto, essa é uma alteração interruptiva no binário que precisa preservar a compatibilidade no nível da fonte em todo o uso do Compose. (aosp/1226314, link em inglês)

Versão 1.0-dev05

19 de fevereiro de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev05 e androidx.compose:compose-runtime:0.1.0-dev05. A versão 0.1.0-dev05 contém estas confirmações (link em inglês).

Mudanças na API

  • Alterações interruptivas na API de ambientes. Consulte o registro e a documentação do Ambient<T> para ver detalhes (I4c7ee, b/143769776, links em inglês)

Correções de bugs

  • O ButtonStyle foi substituído por funções distintas e a sobrecarga de texto (string) foi removida. Veja amostras atualizadas para informações de uso (If63ab, b/146478620, b/146482131, links em inglês)

Versão 0.1.0-dev04

29 de janeiro de 2020

Lançamento de androidx.compose:compose-compiler:0.1.0-dev04 e androidx.compose:compose-runtime:0.1.0-dev04. As confirmações incluídas nessa versão podem ser encontradas clicando aqui (link em inglês).

Mudanças na API

  • Adição de callback areEquivalent para MutableState (Ic2ef8, todos os links da lista estão em inglês)
  • Remoção de componente e refatoração de APIs de composição de nível superior (I1f22e)
  • Transformação de chamadas que podem ser compostas com o parâmetro do Composer (I1691e)
  • Remoção de classes Composition em favor da classe básica do Composer (Ieadbf)
  • Marcação de State<T> e MutableState<T> como tipos estáveis (b/146557624)
  • Adição de currentComposerIntrinsic e testes para garantir a passagem correta de parâmetros (I133f0)
  • Transformação de ModelObserver em uma única linha de execução (Ica33d)
  • Geração correta de grupos em torno das chamadas que podem ser compostas (Ibf739)
  • Remoção da anotação EffectsDsl não usada (Ibe81d)
  • Adição de uma anotação @Stable. Marcação de Modifier como estável (Iacba7)
  • Introdução das APIs MutableState, State e mutableStateOf (I98291)
  • Refatoração de efeitos para @Composable (Ie2686)
  • Melhoria no desempenho de ObserverMap e ModelObserver (Ieb9b6)
  • Mudança de observações de leitura para permitir a observação de non-ComponentNodes (Ia4d93)