Compose

Atualização mais recente Versão atual
27 de maio de 2020 0.1.0-dev12

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:compose-runtime:0.1.0-dev12"
}

android {
    buildFeatures {
        compose true
    }

    composeOptions {
        kotlinCompilerVersion "1.3.70-dev-withExperimentalGoogleExtensions-20200424"
        kotlinCompilerExtensionVersion "0.1.0-dev12"
    }
}

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

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 0.1.0-dev

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 essas 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 site 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 site 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 estreitas (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 essas 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 de pintura. Para 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 com a tela subjacente. (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, 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 essas 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 essas 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)

Version 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 essas 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)

Version 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 essas 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)

Version 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 essas 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)

Version 0.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 essas 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)