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

Compose Runtime

Elementos fundamentais do modelo de programação e do gerenciamento de estado do Compose e ambiente de execução principal do plug-in Compose Compiler.
Atualização mais recente Versão estável atual Próximo candidato a lançamento Versão Beta Versão Alfa
11 de novembro de 2020 - - - 1.0.0-alpha07

Estrutura

O Compose é uma combinação de sete IDs de grupos do Maven no 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 construçã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:

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

android {
    buildFeatures {
        compose true
    }

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

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-alpha07

11 de novembro de 2020

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

Novos recursos

Mudanças na API

  • A anotação @UnionType foi suspensa (I57cde).
  • provideDefault foi adicionado como alternativa para fornecer ambientes e pode ser usado para especificar valores de ambiente que só serão definidos quando não houver um valor de ambiente já fornecido (Id6635, b/171024925).
  • LaunchedTask foi renomeado como LaunchedEffect para fins de consistência com as APIs SideEffect e DisposableEffect. Para incentivar as práticas recomendadas, o LaunchedEffect sem parâmetros de assunto não será permitido (Ifd3d4).
  • Agora, o Applier tem callbacks BeginChanges/onEndChanges que são invocados quando um Composer começa/termina de aplicar as mudanças na árvore. Isso pode ser usado para o gerenciamento de recursos de agrupamento, se necessário (Icf476).
  • O Recomposer agora exige um CoroutineContext na construção (Ic4610).
  • Mudanças na implementação interna de SlotTable que não afetarão a API pública (If9828).
  • Adaptadores rxjava2 obsoletos que não assumem o valor inicial foram removidos (Idb72f).

Correções de bugs

  • foundation.Text está obsoleto e foi substituído por material.Text. Para uma API de texto básica e discreta que não consome valores de um tema, consulte androidx.compose.foundation.BasicText (If64cb).
  • BaseTextField foi suspenso. Use BasicTextField (I896eb).
  • Vários símbolos relacionados ao layout foram movidos de androidx.compose.ui para androidx.compose.layout.ui (I0fa98, b/170475424).

Contribuição externa

  • Adição do módulo runtime-rxjava3 para Compose. Semelhante a runtime-rxjava2 (I02cbf).

Versão 1.0.0-alpha06

28 de outubro de 2020

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

Mudanças na API

  • O Recomposer agora é um ComposeReference e um pai de composição válido. Agora, o Recomposer explícito é obrigatório em menos lugares (I4036f).
  • Adição da API de contraparte de DisposableEffect ao SideEffect, preenchendo o papel de onCommit-with-params, mas com um onDispose obrigatório.
    • Adição da API rememberUpdatedState para publicar dados de recomposição para processos contínuos ou de longa duração, como DisposableEffects ou LaunchedTasks
    • (Id50b9).
  • MutableVector agora implementa RandomAccess (I85d73, b/1704361551).
  • Adição do elemento que pode ser composto do SideEffect para aplicar efeitos colaterais de composição a objetos gerenciados pela composição. O SideEffect tem como objetivo substituir o elemento que pode ser composto do onCommit (Ia77c2).
  • Novo RestorableStateHolder da API experimental. Permite salvar o estado definido com [savedInstanceState] e [rememberSavedInstanceState] para a subárvore antes de descartá-la para possibilitar a recomposição dela na próxima vez com o estado restaurado (I66884, b/166586419).

Correções de bugs

  • Ativação de transições em ComposeTestRule. Remoção da opção para ativar o cursor piscante na ComposeTestRule (If0de3).

Versão 1.0.0-alpha05

14 de outubro de 2020

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

Mudanças na API

  • Suspensão do modificador de entrada pelo Modifier.pointerInput experimental (Ia77d2)
  • O desempenho de rolagem de LazyColumn/Row foi melhorado com menos trabalho na subcomposição em cada rolagem. O novo método hasInvalidations() foi adicionado para a classe Composition. O método hasPendingChanges() do Recomposer foi renomeado como hasInvalidations() (Ib2f32, b/168293643, b/167972292, b/165028371)
  • Adição da API productState para iniciar corrotinas da composição que atualizam um único valor State<T> ao longo do tempo (Id4a57)
  • launchInCompose foi renomeado como LaunchedTask para corresponder às diretrizes da API Compose (I99a8e)
  • Agora, a ordem das chamadas place() em Layouts personalizados define a ordem de desenho para os filhos (Ibc9f6)

Versão 1.0.0-alpha04

1º de outubro de 2020

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

Mudanças na API

  • Adição de OwnerScope para permitir a coleta de escopos de observação de desenho e layout quando eles deixam de ser válidos (Ic4cf8).
  • Adição da API deriveStateOf para criar objetos State com base em um cálculo que pode ler e derivar de outros objetos State (If758b).
  • Adição da API TestOnly para SnapshotStateObserver (I6e2a9).

Correções de bugs

Versão 1.0.0-alpha03

16 de setembro de 2020

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

Mudanças na API

  • CompositionCoroutineScope não implementa mais MonotonicFrameClock. Os autores de chamadas de withFrameNanos precisam importar a função de nível superior explicitamente (Icb642, b/166778123).

Correções de bugs

  • As funções de teste globais, como onNode ou waitForIdle, estão obsoletas. Migre para as novas contrapartes que estão definidas em ComposeTestRule (I7f45a).
  • launchInComposition não inicia mais corrotinas não despachadas (Ief6af, b/16648600).

Versão 1.0.0-alpha02

2 de setembro de 2020

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

Mudanças na API

  • Adicione as APIs snapshotFlow e withMutableSnapshot para consumir e produzir modificações de dados de snapshots. I3e722
  • A convenção de chamada para funções que podem ser compostas foi modificada. Essa é uma alteração interruptiva binária. Todas as bibliotecas precisam ser recompiladas para funcionar com essa versão do plug-in compilador do Compose.

    Essa mudança não cria uma alteração interruptiva no nível da origem, uma vez que as únicas APIs que foram modificadas são APIs do compilador que têm uma permissão explícita I7afd2, b/158123185

  • Remoção dos métodos de programação do EmbeddingContext (I7b9be)

  • O onPreCommitte foi suspenso. O onCommit agora tem o comportamento do onPreCommit.

    O onCommit e o onActive agora são executados no mesmo frame choreographer que a composição muda, em vez de no início do próximo frame choreographer. I70403

Versão 1.0.0-alpha01

26 de agosto de 2020

Lançamento do androidx.compose.runtime:runtime-*: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.runtime:runtime-*:0.1.0-dev17 é lançado. A versão 0.1.0-dev17 contém essas confirmações.

Mudanças na API

  • Agora, as emissões personalizadas podem declarar que um ou mais setters podem ser ignorados e recompostos independentemente da emissão. (Ibbd13)
  • As chamadas FrameManager obsoletas foram removidas.

    As APIs de composição interna foram mudadas para reduzir a quantidade de sobrecarga para rastrear objetos de estado, como mutableStateof() (I80ba6).

  • O uso do composto state { ... } foi substituído pelas chamadas explícitas para remember { mutableStateOf(...) } para maior clareza. Isso reduz a plataforma geral da API e o número de conceitos de gerenciamento de estado e corresponde ao padrão by mutableStateOf() para delegação de propriedade de classe (Ia5727)

  • Agora, Flow.collectAsState determina o agente padrão da composição, em vez de usar o Dispatchers.Main. (I9c1d9)

  • Correção da falha que ocorria quando algo que salvava o estado era usado dentro do loop. Agora, é permitido ter a mesma chave em savedInstanceState(), a API UiSavedStateRegistry está ajustada para esse novo requisito (I4ab76, b/160042650, b/156853976, b/159026663, b/154920561)

Correções de bugs

  • emitView foi suspenso. Use AndroidView, se possível, para emitir Views dentro do Compose. A composição direta de Views e ViewGroups não estará disponível no futuro, a menos que elas sejam folhas da árvore de composição. Nesse caso, a composição direta será possível usando o AndroidView. (I29b1e, b/163871221)

Versão 0.1.0-dev16

5 de agosto de 2020

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

Mudanças na API

  • A política de mutação padrão de mutableStateOf(), ambientOf() e savedInstanceStateOf() foi mudada para structuralEqualityPolicy() em vez de referentialEqualityPolicy().

    Agora, para decidir se um novo valor atribuído a uma instância de mutableStateOf() é considerado uma mudança, o padrão é usar == em vez de ===.

    Consulte https://kotlinlang.org/docs/reference/equality.html (link em inglês)

    ambientOf() e savedInstanceStateOf() usam mutableStateOf() nas implementações deles, então eles foram mudados para que haja consistência com mutableStateOf().

    O uso da igualdade estrutural se aproxima mais das expectativas do desenvolvedor.

    Por exemplo,

    val state = mutableStateOf(1f)
    

    seguido por

    state.value = 1f
    

    não será mais considerado como uma mudança no state, e os usos do state durante a composição não precisarão mais ser recompostos.

    Essa é uma alteração interruptiva, mas geralmente isso não tem um efeito perceptível em um aplicativo, como ao usar classes que não modificam equals().

    As classes que modificam equals(), como as classes data, podem ter uma degradação no desempenho, porque os métodos equals() agora são, por padrão, chamados quando atribuídos a um mutableStateOf().

    O comportamento anterior pode ser restaurado adicionando o parâmetro de política policy = referentialEqualityPolicy() às chamadas para mutableStateOf(), ambientOf() e savedInstanceStateOf(). (Ic21a7)

  • Row e Column agora executam funções in-line reduzindo significativamente a sobrecarga de uso (I75c10).

Correções de bugs

  • Suspensão de setViewContent. Use setContent (I7e497, b/160335130)
  • Adição de MonotonicFrameAnimationClock que permite usar um MonomonicFrameClock como um AnimationClockObservable para fazer a ponte entre os novos relógios e APIs baseados em corrotinas que ainda usam os relógios antigos baseados em callback.

    O equivalente de ManualAnimationClock do ManualAnimationClock agora é ManualFrameClock (I111c7, b/161247083)

  • O Modifier.stateDraggable foi completamente reformulado e renomeado como Modifier.swipeable. Uma nova classe SwipeableState foi introduzida, e as DrawerState e BottomDrawerState foram refatoradas para herdar dela. [Modal/Bottom]DrawerLayout não usa mais um parâmetro onStateChange. (I72332, b/148023068)

  • Suspensão do uso de Modifier.plus. Use Modifier.then. "Then" tem um sinal mais forte de ordem, mas também proíbe o tipo Modifier.padding().background() + anotherModifier, que interrompe a cadeia e é mais difícil de ler (Iedd58, b/161529964)

  • SubcomposeLayout foi adicionado. Trata-se de um primitivo de baixo nível que permite compor os filhos durante a medição se quisermos usar posteriormente alguns valores disponíveis, durante a medição para a composição da subárvore. Por exemplo, WithConstraints não é implementado usando SubcomposeLayout (I25cc8)

  • O FilledTextField do Material foi renomeado como TextField, e o TextField de base foi renomeado como BaseTextField para facilitar a descoberta e o uso da API mais simples desejada (Ia6242, b/155482676).

  • Renomeação de Modifier.drawBackground como Modifier.background (I13677).

Versão 0.1.0-dev15

22 de julho de 2020

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

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.

Mudanças na API

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

  • 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 no momento 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. O 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 modificado para esperar uma Function3 em vez de Function1 7. restartableFunction e restartableFunctionN foram atualizadas para incluir outros parâmetros de tempo de compilação (I60756, b/143464846).

  • Adição de sortWith e removeRange ao MutableVector (Icccf7).

  • Adição de implementações de método padrão para CompositionLifecycleObserver (I24289).

  • O Applier agora requer um método clear() para descartar composições (Ibe697).

  • Adição de asMutableList() ao MutableVector para permitir que ele seja transmitido para a API pública sem ter que copiar a lista inteira (I298df).

  • Adição de rememberCoroutineScope() para receber um CoroutineScope gerenciado na composição para iniciar jobs em resposta a eventos (I0e264).

  • MutableVector é uma nova coleção, que não implementa nenhuma interface padrão de Collection. Essa coleção oferece velocidade acima de outros requisitos e é destinada ao uso apenas em implementações internas (I8ebd6).

  • StableMutableList e StableMutableMap foram removidos temporariamente para evitar um problema na versão do Compose que o Kotlin exige. Essas interfaces serão usadas novamente quando o Compose for atualizado para uma versão do Kotlin que não tenha o problema.

    SnapshotStateList e SnapshotStateMap agora são públicos, mas ficarão obsoletos depois que StableMutableList e StableMutableMap forem restaurados (Ia7769).

  • Adição de função withFrameNanos de nível superior para tempo de animação (Ie34c5).

  • A anotação @Untracked foi suspensa. Substitua por @ComposableContract(tracked=false) (Id211e).

  • RestartableFunction e as APIs associadas foram renomeadas como ComposableLambda etc. Essas APIs foram segmentadas apenas pelo compilador, então isso geralmente não afetará a compatibilidade no nível da fonte. A renomeação foi feita principalmente para comunicar que essa classe é melhor quando aparece em stack traces (I7eb25).

  • A anotação @Composable não é mais válida em classes (Ia5f02).

  • Ambient<T> agora é @Stable em vez de @Immutable (I0b4bb).

  • Antes da mudança, o plug-in do compilador do Compose interceptava chamadas não solicitadas a construtores dentro de uma função @Composable se houvesse um (I5205a, b/158123804).

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

  • O @Direct foi suspenso em favor de @ComposableContract(reinicable=false) (If4708).

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

  • Foi adicionado um adaptador para o fluxo. Exemplo de uso: valor val por fluxo.collectAsState() (If2198, b/153375923).

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

  • O androidx.composte.ViewComposer foi movido para androidx.ui.node.UiComposer. androidx.compose.Emittable foi removido. Isso era redundante com o ComponentNode. O androidx.compose.ViewAdapters foi removido. Eles não são mais um caso de uso compatível. O uso de Compose.composeInto foi suspenso. Use setContent ou setViewContent. O uso de Compose.disposeComposition foi suspenso. Use o método dispose no Composition retornado pelo setContent. androidx.compose.Compose.subcomposeInto foi movido para androidx.ui.core.subcomposeInto. ComponentNode#emitInsertAt foi renomeado como ComponentNode#insertAt. ComponentNode#emitRemoveAt foi renomeado como ComponentNode#removeAt. ComponentNode#emitMode foi renomeado como ComponentNode#move (Idef00).

  • 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 (I7971c).

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

  • Adição de ui-livedata: novo artefato com um adaptador para LiveData. Exemplo de uso: valor val por liveData.observeAsState() (Ie9e8c, b/150465596).

  • Os adaptadores Rx sem valor inicial explícito estão obsoletos. Usar null nem sempre é o melhor padrão. Por exemplo, quando você tem uma lista, é melhor começar com emptyList() ou qualquer outro padrão razoável (I00025, b/161348384).

  • Adição de ui-rxjava2: novo artefato com adaptadores para RxJava2. Exemplo do uso: valor val por observable.subscribeAsState() (Ifab4b, b/153369097).

  • savedInstanceState() agora pode ser usado com tipos anuláveis (I6847f, b/153532190).

  • Novo listSaver() e mapSaver() para facilitar a gravação de objetos Saver personalizados (I8cf68, b/152331508).

  • Novas funções: savedInstanceState() e rememberSavedInstanceState(). Elas são semelhantes a state() e remember(), mas têm uma versão de estado de instância salva em (If1987, b/152025209).

Correções de bugs

  • runOnIdleCompose foi renomeado como runOnIdle (I83607).
  • Criação da API experimental LayoutNode (I4f2e9).
  • androidx.ui.foundation.TextFieldValue e androidx.ui.input.EditorValue estão obsoletos. Os compostos TextField, FilledTextField e CoreTextField que usam esse tipo também foram suspensos. Use androidx.ui.input.TextFieldValue (I4066d, b/155211005).
  • Remoção da API DrawBackground obsoleta, que foi substituída pelas APIs de extensão drawBackground em Modifier. 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).
  • 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, ele 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).
  • Modificador de preenchimento simétrico adicionado (I39840).
  • Atualização de wrapContentWidth e wrapContentHeight para esperar um alinhamento vertical ou horizontal em vez de qualquer outro. O modificador de gravidade foi atualizado para aceitar o alinhamento vertical ou horizontal. Row, Column e Stack foram atualizados para ter compatibilidade com alinhamentos contínuos personalizados (Ib0728).
  • O módulo ui-text foi renomeado como ui-text-core (I57dec).
  • Melhora da API DrawModifier:
    • Definição do escopo do receptor para draw() ContentDrawScope
    • Remoção de todos os parâmetros em draw()
    • DrawScope tem a mesma interface que o antigo CanvasScope
    • O ContentDrawScope tem o método drawContent() (Ibaced, b/152919067).
  • O ColouredRect foi suspenso. Use Box(Modifier.preferredSize(width, height).drawBackground(color)) (I499fa, b/152753731).
  • 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).
  • 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).
  • Renomeação de Background para DrawBackground. Agora, ele é memorizado por padrão (Ia0bd3).
  • 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).
  • runOnIdleCompose e runOnUiThread agora são funções globais e não métodos em ComposeTestRule (Icbe8f).

Contribuição externa

  • Remoção de APIs desnecessárias, como Looper e Handler, da camada de portabilidade do Compose Runtime (I6847d).
  • Foi suspenso o uso de Flow<T>.collectAsState() sem valor inicial. Use StateFlow<T> ou transmita um valor inicial explícito (I63f98, b/157674865).