Conheça o Cahier: um novo exemplo do GitHub para Android que aumenta a produtividade e a criatividade em telas grandes
Leitura de 11 min
A API Ink agora está na versão Beta e pronta para ser integrada ao seu app. Esse marco foi possível graças ao feedback valioso dos desenvolvedores, que levou a melhorias contínuas no desempenho, na estabilidade e na qualidade visual da API.
Os apps do Google, como Documentos Google, Pixel Studio, Google Fotos, PDF do Chrome, Criador de Efeitos do YouTube e recursos exclusivos do Android, como Circule para pesquisar, usam as APIs mais recentes.
Para marcar esse marco, temos o prazer de anunciar o lançamento do Cahier, um exemplo de app de anotações abrangente otimizado para dispositivos Android de todos os tamanhos, principalmente tablets e smartphones dobráveis.
O que é o Cahier?
O Cahier ("caderno" em francês) é um app de exemplo que demonstra como criar um aplicativo que permite aos usuários capturar e organizar pensamentos combinando texto, desenhos e imagens.
O exemplo pode servir como referência para aumentar a produtividade e a criatividade do usuário em telas grandes. Ele mostra as práticas recomendadas para criar essas experiências, acelerando a compreensão e a adoção de APIs e técnicas avançadas relacionadas por parte dos desenvolvedores. Nesta postagem, vamos mostrar os recursos principais do Cahier, as APIs mais importantes e as decisões de arquitetura que fazem do exemplo uma ótima referência para seus próprios apps.
Os principais recursos demonstrados no exemplo incluem:
- Criação de notas versátil: mostra como implementar um sistema flexível de criação de conteúdo que oferece suporte a vários formatos em uma única nota, incluindo texto, desenhos livres e anexos de imagem.
- Ferramentas de escrita criativa: implementa uma experiência de desenho de alto desempenho e baixa latência usando a API Ink. O exemplo mostra como integrar vários pincéis, um seletor de cores, a funcionalidade de desfazer/refazer e uma ferramenta de borracha.
- Integração de conteúdo fluida com o recurso de arrastar e soltar: demonstra como processar conteúdo de entrada e saída usando o recurso de arrastar e soltar. Isso inclui aceitar imagens soltas de outros apps e permitir que os usuários arrastem conteúdo para fora do app para compartilhar de forma integrada.
- Organização de notas: marque notas como favoritas para acesso rápido. Filtre a visualização para manter tudo organizado.
- Arquitetura que prioriza o modo off-line: criada com uma arquitetura que prioriza o modo off-line usando o Room, garantindo que todos os dados sejam salvos localmente e que o app permaneça totalmente funcional sem uma conexão de Internet.
- Suporte avançado a várias janelas e instâncias: mostra como oferecer suporte a várias instâncias, permitindo que o app seja iniciado em várias janelas para que os usuários possam trabalhar em diferentes notas lado a lado, aumentando a produtividade e a criatividade em telas grandes.
- Interface adaptável para todas as telas: a interface do usuário se adapta perfeitamente a diferentes tamanhos e orientações de tela usando ListDetailPaneScaffold e NavigationSuiteScaffold para oferecer uma experiência do usuário otimizada em smartphones, tablets e dispositivos dobráveis.
- Integração profunda com o sistema: fornece um guia sobre como tornar seu app o padrão para anotações no Android 14 e versões mais recentes, respondendo a intents de notas em todo o sistema e permitindo a captura rápida de conteúdo de vários pontos de entrada do sistema.
Criado para produtividade e criatividade em telas grandes
Para o lançamento inicial, vamos focar o anúncio em alguns recursos principais que fazem do Cahier um recurso de aprendizado essencial para casos de uso de produtividade e criatividade.
Uma base de adaptabilidade
O Cahier foi criado para ser adaptável desde o início. O exemplo usa a biblioteca material3-adaptive, especificamente ListDetailPaneScaffold e NavigationSuiteScaffold, para adaptar o layout do app a vários tamanhos e orientações de tela. Esse é um elemento crucial para um app Android moderno, e o Cahier é um exemplo claro de como implementar isso de forma eficaz.
Interface adaptável do Cahier criada com a biblioteca adaptável do Material 3
Demonstração das principais APIs e integrações
O exemplo se concentra em mostrar APIs de produtividade avançadas que você pode usar nos seus próprios aplicativos, incluindo:
- API Ink
- Papel de anotações
- Várias instâncias, várias janelas e modo janela para computador
- Arrastar e soltar
Análise detalhada das principais APIs
Vamos nos aprofundar em duas das APIs fundamentais que o Cahier integra para oferecer uma experiência de primeira classe para fazer anotações.
Como criar experiências de escrita natural com a API Ink
A entrada de stylus transforma dispositivos de tela grande em cadernos digitais e blocos de desenho. Para ajudar você a criar experiências de escrita fluidas e naturais, fizemos da API Ink um elemento fundamental do exemplo. A API Ink facilita a criação, renderização e manipulação de traços de tinta bonitos com a melhor baixa latência da categoria.
A API Ink oferece uma arquitetura modular, para que você possa adaptá-la à pilha e às necessidades específicas do seu app. Os módulos da API incluem:
- Módulos de criação (Compose - visualizações): processam a entrada de escrita em tempo real para criar traços suaves com a menor latência que um dispositivo pode oferecer.
- Em DrawingSurface, o Cahier usa o novo elemento combinável InProgressStrokes para processar a entrada por toque ou stylus em tempo real. Esse módulo é responsável por capturar eventos de ponteiro e renderizar traços de tinta molhada com a menor latência possível.
- Módulo Strokes: representa a entrada de tinta e a representação visual dela. um usuário termina de desenhar uma linha, o callback onStrokesFinished fornece um objeto Stroke finalizado/seco ao app. Esse objeto imutável, que representa o traço de tinta concluído, é gerenciado em DrawingCanvasViewModel.
- Módulo de renderização: mostra os traços de tinta de forma eficiente, permitindo que sejam combinados com o Jetpack Compose ou as visualizações do Android.
- Para mostrar os traços atuais e os recém-secos, o Cahier usa CanvasStrokeRenderer em DrawingSurface para o desenho ativo e em DrawingDetailPanePreview para mostrar uma prévia estática da nota. Esse módulo desenha os objetos Stroke em um Canvas de forma eficiente.
- Módulos de pincel (Compose - visualizações): oferecem uma maneira declarativa de definir o estilo visual dos traços. As atualizações recentes (desde a versão alpha03) incluem um novo pincel de linha tracejada, que é útil para recursos como a seleção de laço. O DrawingCanvasViewModel mantém o estado do currentBrush. Uma caixa de ferramentas em DrawingCanvas permite que os usuários selecionem diferentes famílias de pincéis (como StockBrushes.pressurePen() ou StockBrushes.highlighter()) e mudem as cores. O ViewModel atualiza o objeto Brush, que é usado pelo elemento combinável InProgressStrokes para novos traços.
- Módulos de geometria (Compose - visualizações): permitem manipular e analisar traços para recursos como apagar e selecionar.
- A ferramenta de borracha na caixa de ferramentas e a funcionalidade em DrawingCanvasViewModel dependem do módulo de geometria. Quando a borracha está ativa, ela cria um MutableParallelogram ao redor do caminho do gesto do usuário. Em seguida, a borracha verifica as interseções entre a forma e as caixas delimitadoras dos traços atuais para determinar quais traços apagar, tornando a borracha intuitiva e precisa.
- Módulo de armazenamento: oferece recursos eficientes de serialização e desserialização para dados de tinta, o que resulta em uma economia significativa de tamanho de disco e rede. Para salvar desenhos, o Cahier mantém os objetos Stroke no banco de dados do Room. Em Converters, o exemplo usa a função encode do módulo de armazenamento para serializar o StrokeInputBatch (os dados de pontos brutos) em um ByteArray. A matriz de bytes, junto com as propriedades do pincel, é salva como uma string JSON. A função decode é usada para reconstruir os traços quando uma nota é carregada.
Além desses módulos principais, as atualizações recentes expandiram os recursos da API Ink:
- Novas APIs experimentais para objetos
BrushFamilypersonalizados permitem que os desenvolvedores criem tipos de pincel criativos e exclusivos, oferecendo possibilidades para ferramentas como os pincéis Lápis e Ponteiro laser.
Cahier usa pincéis personalizados, incluindo o pincel de música exclusivo mostrado abaixo, para ilustrar possibilidades criativas avançadas.
Laser de arco-íris criado com os pincéis personalizados da API Ink
Pincel de música criado com os pincéis personalizados da API Ink
- Os módulos de interoperabilidade nativos do Jetpack Compose simplificam a integração de funcionalidades de escrita diretamente nas suas interfaces do Compose para uma experiência de desenvolvimento mais idiomática e eficiente.
A API Ink oferece várias vantagens que a tornam a escolha ideal para apps de produtividade e criatividade em comparação com uma implementação personalizada:
- Facilidade de uso: a API Ink abstrai as complexidades de gráficos e geometria, permitindo que você se concentre nos recursos principais do Cahier.
- Desempenho: o suporte integrado de baixa latência e a renderização otimizada garantem uma experiência de escrita suave e responsiva.
- Flexibilidade: o design modular permite escolher os componentes necessários, o que possibilita a integração perfeita da API Ink à arquitetura do Cahier.
A API Ink já foi adotada em muitos apps do Google, incluindo para marcação no app Documentos e para o recurso Circule para Pesquisar, além de apps de parceiros, como Orion Notes e PDF Scanner.
"A API Ink foi nossa primeira escolha para o Circule para Pesquisar (CtS). Com a documentação abrangente, a integração da API Ink foi muito fácil, o que nos permitiu criar nosso primeiro protótipo funcional em apenas uma semana. A textura personalizada do pincel e o suporte à animação do Ink permitiram que iterássemos rapidamente no design do traço." — Jordan Komoda, engenheiro de software do Google
Como se tornar o app de notas padrão com o papel de anotações
A criação de anotações é um recurso importante que melhora a produtividade do usuário em dispositivos de tela grande. Com o recurso de função de notas, os usuários podem acessar seus apps compatíveis na tela de bloqueio ou enquanto outros apps estão em execução. Esse recurso identifica e define apps de anotações padrão em todo o sistema e concede permissão para que sejam iniciados para capturar conteúdo.
Implementação no Cahier
A implementação do papel de notas envolve algumas etapas importantes, todas demonstradas no exemplo:
- Declaração de manifesto: primeiro, o app precisa declarar a capacidade de processar intents de anotações. No AndroidManifest.xml, o Cahier inclui um
<intent-filter>para a ação android.intent.action.CREATE_NOTE. Isso indica ao sistema que o app é um possível candidato para o papel de anotações. - Verificação do status do papel: o SettingsViewModel usa o RoleManager do Android para determinar o status atual. O SettingsViewModel verifica se o papel de notas está disponível no dispositivo (isRoleAvailable) e se o Cahier tem esse papel (isRoleHeld). Esse estado é exposto à interface usando fluxos do Kotlin.
- Solicitação do papel: no arquivo Settings.kt, um Button será mostrado ao usuário se o papel estiver disponível, mas não for mantido. Quando clicado, o botão chama a função
requestNotesRoleno ViewModel. A função cria uma intent para abrir a tela de configurações padrão do app, em que o usuário pode selecionar o Cahier. O processo é gerenciado usando a API rememberLauncherForActivityResult, que processa o início da intent e o recebimento do resultado. - Atualização da interface: depois que o usuário retorna da tela de configurações, o callback ActivityResultLauncher aciona uma função no ViewModel para atualizar o status do papel, garantindo que a interface reflita com precisão se o app agora é o padrão.
Saiba como integrar a função de notas no seu app no guia para criar um app de anotações.
Cahier aberto em uma janela flutuante como o app de anotações padrão em um tablet Lenovo
Um grande passo à frente: a Lenovo ativa a função de notas
Temos o prazer de anunciar um grande avanço para a produtividade em telas grandes do Android: a Lenovo agora oferece suporte ao papel de notas em tablets com o Android 15 e versões mais recentes. Com essa atualização, você pode atualizar seus apps de anotações para que os usuários com dispositivos Lenovo compatíveis os definam como padrão, permitindo acesso direto pela tela de bloqueio e desbloqueando recursos de captura de conteúdo no sistema.
Esse compromisso de um OEM líder demonstra a importância crescente do papel das notas para oferecer uma experiência do usuário verdadeiramente integrada e produtiva no Android.
Várias instâncias, várias janelas e modo janela para computador
A produtividade em uma tela grande tem tudo a ver com o gerenciamento eficiente de informações e fluxos de trabalho. Por isso, o Cahier foi criado para aproveitar ao máximo os recursos avançados de janelas do Android, oferecendo um espaço de trabalho flexível que se adapta às necessidades do usuário. O app é compatível com:
- Várias janelas: a capacidade fundamental de ser executado com outro app no modo de tela dividida ou formato livre. Isso é essencial para tarefas como consultar uma página da Web enquanto faz anotações no Cahier.
- Várias instâncias: é aqui que a verdadeira multitarefa se destaca. O Cahier permite que os usuários abram várias janelas independentes do app ao mesmo tempo. Imagine comparar duas notas diferentes lado a lado ou consultar uma nota de texto em uma janela enquanto trabalha em um desenho em outra. Cahier demonstra como gerenciar essas instâncias separadas, cada uma com o próprio estado, transformando seu app em uma ferramenta poderosa e multifacetada.
- Modo janela para computador: quando conectado a uma tela externa, o modo área de trabalho do Android transforma um tablet ou dobrável em uma estação de trabalho. Como o Cahier foi criado com uma interface adaptável e oferece suporte a várias instâncias, o app funciona muito bem nesse ambiente. Os usuários podem abrir, redimensionar e posicionar várias janelas do Cahier, como em um computador tradicional, permitindo fluxos de trabalho complexos que antes não eram possíveis em dispositivos móveis.
Cahier em execução no modo janela para computador no Pixel Tablet
Veja como implementamos esses recursos no Cahier:
Para ativar várias instâncias, primeiro precisamos sinalizar ao sistema que o app pode ser iniciado várias vezes adicionando a propriedade PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI à declaração de MainActivity em AndroidManifest:
<activity android:name="com.example.cahier.MainActivity" android:exported="true" android:label="@string/app_name" android:theme="@style/Theme.MyApplication" android:showWhenLocked="true" android:turnScreenOn="true" android:resizeableActivity="true" android:launchMode="singleInstancePerTask"> <property android:name="android.window.PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI" android:value="true"/> ... </activity>
Em seguida, implementamos a lógica para iniciar uma nova instância do app. Em CahierHomeScreen.kt, quando um usuário opta por abrir uma nota em uma nova janela, criamos uma nova intent com flags específicas que instruem o sistema sobre como lidar com o lançamento da nova atividade. A combinação de FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_MULTIPLE_TASK e FLAG_ACTIVITY_LAUNCH_ADJACENT garante que a nota seja aberta em uma nova janela separada ao lado da atual.
fun openNewWindow(activity: Activity?, note: Note) {
val intent = Intent(activity, MainActivity::class.java)
intent.putExtra(AppArgs.NOTE_TYPE_KEY, note.type)
intent.putExtra(AppArgs.NOTE_ID_KEY, note.id)
intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK or
Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT
activity?.startActivity(intent)
}Para oferecer suporte ao modo de várias janelas, precisamos sinalizar ao sistema que o app é redimensionável definindo o elemento <activity> ou <application> do manifesto.
<activity android:name="com.example.cahier.MainActivity" android:resizeableActivity="true" ...> </activity>
A própria interface, criada com a biblioteca adaptável do Material 3, permite que ela se adapte perfeitamente a cenários de várias janelas, como o modo de tela dividida do Android.
Para melhorar a experiência do usuário, adicionamos suporte para arrastar e soltar. Veja abaixo como implementamos isso no Cahier.
Arrastar e soltar
Um app verdadeiramente produtivo ou criativo não funciona de forma isolada. Ele interage perfeitamente com o restante do ecossistema do dispositivo. O recurso de arrastar e soltar é fundamental para essa interação, especialmente em telas grandes, em que os usuários costumam trabalhar em várias janelas de apps. O Cahier aproveita isso ao máximo, implementando uma funcionalidade intuitiva de arrastar e soltar para adicionar e compartilhar conteúdo.
- Importação sem esforço: os usuários podem arrastar imagens de outros aplicativos, como um navegador da Web, uma galeria de fotos ou um gerenciador de arquivos, e soltá-las diretamente em uma nota. Para isso, o Cahier usa o modificador dragAndDropTarget para definir uma zona de soltar, verificar se há conteúdo compatível (como
image/*) e processar o URI recebido. - Compartilhamento simples: o conteúdo do Cahier é tão fácil de compartilhar quanto o de outros apps. Os usuários podem tocar e manter pressionada uma imagem em uma nota de texto ou tocar e manter pressionada toda a tela de uma nota de desenho e composição de imagem e arrastá-la para outro aplicativo.
Análise técnica detalhada: arrastar da tela de desenho
Implementar o gesto de arrastar na tela de desenho apresenta um desafio único. Na nossa DrawingSurface, os elementos combináveis que processam a entrada de desenho em tempo real (InProgressStrokes da API Ink) e o Box que detecta o gesto de tocar e manter pressionado para iniciar um arrasto são elementos combináveis irmãos.
Por padrão, o sistema de entrada de ponteiro do Jetpack Compose é projetado para que apenas um elemento combinável irmão, o primeiro na ordem de declaração que se sobrepõe ao local do toque, receba o evento. No caso do Cahier, queremos que nossa lógica de processamento de entrada de arrastar e soltar tenha a chance de ser executada e, possivelmente, consumir entradas antes que o elemento combinável InProgressStrokes use todas as entradas não consumidas para desenhar e, em seguida, consuma essa entrada. Se não organizarmos as coisas na ordem certa, nossa Box não vai detectar o gesto de tocar e manter pressionado para iniciar um arrasto, ou InProgressStrokes não vai receber a entrada para desenhar.
Para resolver isso, criamos um modificador pointerInputWithSiblingFallthrough personalizado e colocamos o Box usando esse modificador antes de InProgressStrokes no código combinável. Esse utilitário é um wrapper fino em torno do sistema padrão pointerInput, mas com uma mudança crítica: ele substitui a função sharePointerInputWithSiblings() para retornar true. Isso informa ao framework do Compose que os eventos de ponteiro podem ser transmitidos para elementos combináveis irmãos, mesmo depois de serem consumidos.
internal fun Modifier.pointerInputWithSiblingFallthrough(
pointerInputEventHandler: PointerInputEventHandler
) = this then PointerInputSiblingFallthroughElement(pointerInputEventHandler)
private class PointerInputSiblingFallthroughModifierNode(
pointerInputEventHandler: PointerInputEventHandler
) : PointerInputModifierNode, DelegatingNode() {
var pointerInputEventHandler: PointerInputEventHandler
get() = delegateNode.pointerInputEventHandler
set(value) {
delegateNode.pointerInputEventHandler = value
}
val delegateNode = delegate(
SuspendingPointerInputModifierNode(pointerInputEventHandler)
)
override fun onPointerEvent(
pointerEvent: PointerEvent,
pass: PointerEventPass,
bounds: IntSize
) {
delegateNode.onPointerEvent(pointerEvent, pass, bounds)
}
override fun onCancelPointerInput() {
delegateNode.onCancelPointerInput()
}
override fun sharePointerInputWithSiblings() = true
}
private data class PointerInputSiblingFallthroughElement(
val pointerInputEventHandler: PointerInputEventHandler
) : ModifierNodeElement<PointerInputSiblingFallthroughModifierNode>() {
override fun create() = PointerInputSiblingFallthroughModifierNode(pointerInputEventHandler)
override fun update(node: PointerInputSiblingFallthroughModifierNode) {
node.pointerInputEventHandler = pointerInputEventHandler
}
override fun InspectorInfo.inspectableProperties() {
name = "pointerInputWithSiblingFallthrough"
properties["pointerInputEventHandler"] = pointerInputEventHandler
}
}Veja como ele é usado no DrawingSurface:
Box(
modifier = Modifier
.fillMaxSize()
// Our custom modifier enables this gesture to coexist with the drawing input.
.pointerInputWithSiblingFallthrough {
detectDragGesturesAfterLongPress(
onDragStart = { onStartDrag() },
onDrag = { _, _ -> /* consume drag events */ },
onDragEnd = { /* No action needed */ }
)
}
)
// The Ink API's composable for live drawing sits here as a sibling.
InProgressStrokes(...)Com isso, o sistema detecta corretamente os traços de desenho e o gesto de tocar e manter pressionado para arrastar ao mesmo tempo. Depois que a ação de arrastar é iniciada, criamos um URI content:// compartilhável com o FileProvider e o transmitimos ao framework de arrastar e soltar do sistema usando view.startDragAndDrop(). Essa solução garante uma experiência do usuário robusta e intuitiva, mostrando como superar conflitos de gestos complexos em interfaces em camadas.
Criado com arquitetura moderna
Além de APIs específicas, o Cahier demonstra padrões de arquitetura cruciais para criar aplicativos adaptáveis de alta qualidade.
A camada de apresentação: Jetpack Compose e adaptabilidade
A camada de apresentação é criada inteiramente com o Jetpack Compose. Como mencionado, o Cahier adota a biblioteca material3-adaptive para adaptabilidade da interface. O gerenciamento de estado segue um padrão estrito de fluxo de dados unidirecional (UDF), com instâncias de ViewModel usadas como contêineres de dados que armazenam informações de notas e o estado da interface.
A camada de dados: repositórios e Room
Para a camada de dados, o Cahier usa uma interface NoteRepository para abstrair todas as operações de dados. Essa escolha de design permite que o app alterne de forma limpa entre uma fonte de dados local (Room) e um possível back-end remoto futuro. O fluxo de dados para uma ação como editar uma nota é simples:
- A interface do Jetpack Compose aciona um método no ViewModel.
- O ViewModel busca a nota no NoteRepository, processa a lógica e transmite a nota atualizada de volta ao repositório.
- O NoteRepository salva a atualização em um banco de dados do Room.
Suporte abrangente para digitação
Para ser uma verdadeira ferramenta de produtividade, um app precisa lidar com vários métodos de entrada sem problemas. O Cahier foi criado para obedecer às diretrizes de entrada em telas grandes e é compatível com:
- Stylus: integração com a API Ink, rejeição de palma, registro para o papel de notas, entrada de stylus em campos de texto e modo imersivo.
- Teclado: suporte para os atalhos e combinações de teclado mais comuns (como Ctrl+clique, Meta+clique) e indicação clara do foco do teclado.
- Mouse e trackpad: suporte para estados de clique com o botão direito do mouse e de passar o cursor.
O suporte a interações avançadas de teclado, mouse e trackpad é um foco importante para melhorias futuras.
Comece hoje mesmo
Esperamos que o Cahier sirva como ponto de partida para seu próximo grande app. Ele foi criado para ser um recurso abrangente e de código aberto que demonstra como combinar uma interface adaptável, APIs eficientes, como o Ink e a função de notas, e uma arquitetura moderna e adaptável.
Tudo pronto para mergulhar de cabeça?
- Analise o código: acesse nosso repositório do GitHub para analisar a base de código do Cahier e conferir os princípios de design em ação.
- Crie seu próprio app: use o Cahier como base para criar seu próprio app de anotações, marcação de documentos ou criatividade.
- Contribua: queremos suas contribuições! Ajude a tornar o Cahier um recurso ainda melhor para a comunidade de desenvolvedores Android.
Confira os guias oficiais para desenvolvedores e comece a criar hoje mesmo seu próximo app de produtividade e criatividade. Mal podemos esperar para saber o que você vai criar!
-
InstruçõesComo desenvolvedores de apps e bibliotecas Android, todos nós temos o mesmo objetivo: criar apps Android de alto desempenho que ofereçam uma experiência do usuário tranquila. Uma parte importante disso envolve o R8, o otimizador de apps do Android. O R8 melhora o desempenho do app removendo códigos não utilizados e otimizando e ofuscando o restante.
Breana Tate • Leitura de 6 min -
InstruçõesEste é mais um post da série "Criar apps Android inteligentes", em que você transforma um app Android básico em uma experiência personalizada, inteligente e agêntica. No post anterior, você aprendeu a se conectar ao sistema de inteligência usando as AppFunctions.
Jolanda Verhoef • Leitura de 9 min -
InstruçõesO Media3 1.11 foi lançado. Essa versão, que é usada na grande maioria dos principais apps de mídia do Android, traz novos recursos, correções de bugs e melhorias nos componentes de reprodução, edição e interface.
Toni Heidenreich • Leitura de 3 min
Receba os insights mais recentes sobre o desenvolvimento para Android na sua caixa de entrada toda semana.