Passo a Passo Completo — Do Zero ao Deploy na Play Store
Atualizado para Android 14 TV | Leanback 3.x | Jetpack Compose TV
O Gigante Adormecido que Acordou
Se você ainda não está desenvolvendo para Android TV, está deixando dinheiro na mesa. Não é exagero. O mercado de smart TVs com Android cresceu mais de 40% ao ano nos últimos três anos, e a fragmentação que afastava desenvolvedores está ficando para trás — a Google redesenhou completamente a experiência de desenvolvimento com o Jetpack Compose for TV, tornando o processo mais familiar e eficiente do que nunca.
Android TV e Google TV (a interface mais recente, construída sobre Android TV) rodam em centenas de milhões de dispositivos: televisores da Sony, TCL, Philips, Hisense, Chromecast com Google TV, NVIDIA Shield, e uma avalanche de set-top boxes e dongles ao redor do mundo. Para o desenvolvedor brasileiro, isso representa uma oportunidade ainda mais interessante, dado o custo relativamente baixo de TVBoxes Android e a penetração massiva de aparelhos de entrada em regiões de alta densidade populacional.
Este guia foi escrito para quem quer desenvolver de verdade — não apenas entender o conceito, mas sair daqui com um app funcional e um caminho claro até a publicação. Vamos cobrir desde a configuração do ambiente até as nuances da experiência de navegação por controle remoto, passando por código real, boas práticas e armadilhas que vão te economizar horas de frustração.
🎯 O que você vai aprender neste artigo:
Configuração completa do ambiente Android Studio para TV, arquitetura recomendada para apps de TV, uso da biblioteca Leanback e do Jetpack Compose for TV, navegação por D‑pad, integração com controle remoto, design de UI para telas grandes, testes em emuladores e dispositivos físicos, publicação na Play Store for TV, e monetização de apps na plataforma.
1. Entendendo o Ecossistema Android TV
1.1 Android TV vs Google TV: qual é a diferença?
Antes de escrever uma linha de código, você precisa entender o que está desenvolvendo. Android TV é o sistema operacional base — é o Android rodando em televisores, com modificações na interface e nas APIs para adequar à experiência de sala de estar. Google TV é a camada de interface lançada em 2020 que a Google colocou por cima do Android TV em seus próprios dispositivos (Chromecast com Google TV) e que foi adotada por fabricantes como Sony e TCL.
Do ponto de vista do desenvolvedor, a diferença é pequena e boa notícia: apps desenvolvidos para Android TV rodam perfeitamente no Google TV. A Google mantém compatibilidade total. O que muda é a forma como o usuário descobre seu app (Google TV tem um sistema de recomendações mais sofisticado) e algumas APIs relacionadas a conteúdo que você pode aproveitar no Google TV.
1.2 O modelo de navegação: o D‑pad é tudo
Esqueça o toque. Na TV, o usuário navega com o controle remoto, que se comunica com o sistema através do protocolo D‑pad: cima, baixo, esquerda, direita, selecionar (OK), voltar, home, e alguns botões específicos de mídia (play, pause, retroceder, avançar).
Esse modelo de navegação muda fundamentalmente como você pensa a interface do seu app. Cada elemento interativo precisa receber e perder foco de forma clara. O fluxo de navegação precisa fazer sentido intuitivamente com os quatro direcionais. Não existe “clicar em qualquer lugar” — existe um foco que viaja pelo layout como um cursor lento e previsível.
A Google chama isso de “focus-driven navigation” e construiu o sistema de foco do Android View e do Compose especificamente para suportar isso. Quando você declara seu layout corretamente, o sistema de foco já sabe como navegar entre os elementos. Mas quando você cria layouts complexos ou customizados, vai precisar guiar o sistema — e é aí que muitos desenvolvedores tropeçam.
1.3 Resoluções, densidade e distância de visualização
A TV tem desafios de exibição únicos. O usuário está a 2–3 metros da tela, o que significa que elementos pequenos simplesmente não funcionam. A Google recomenda que qualquer texto legível tenha pelo menos 20sp e que botões e elementos focáveis tenham pelo menos 48dp de tamanho de toque — na TV, isso vira pelo menos 96dp para garantir visibilidade.
Resolução
Pixels
Densidade
Padrão
HD
1280x720
mdpi (~160dpi)
Mínimo recomendado
Full HD
1920x1080
xhdpi (~320dpi)
Mais comum
4K Ultra HD
3840x2160
xxxhdpi (~640dpi)
TVs premium
8K
7680x4320
xxxhdpi+
Emergente
A grande maioria do seu público estará em Full HD (1080p). Dimensione seus layouts primariamente para essa resolução, garanta que tudo funcione em HD, e trate 4K como bônus — o sistema de escala do Android cuida da maior parte, mas imagens e ícones precisam de versões de alta resolução.
2. Configurando o Ambiente de Desenvolvimento
2.1 Requisitos do sistema
Você vai precisar de uma máquina razoável. O emulador de Android TV é pesado — mais pesado do que o emulador de smartphone, porque está simulando uma tela grande com composição de hardware. Se possível, use um dispositivo físico para testes durante o desenvolvimento.
- Android Studio Hedgehog (2023.1.1) ou mais recente
- JDK 17 ou superior
- 8 GB de RAM mínimo (16 GB recomendado)
- 10 GB de espaço em disco para SDK e emuladores
- Placa de vídeo com suporte a OpenGL 2.0+ para o emulador
2.2 Instalando e configurando o Android Studio
Se você já tem o Android Studio instalado para desenvolvimento mobile, a maior parte do trabalho já está feita. O que você precisa adicionar é o SDK do Android TV e as imagens de sistema para o emulador.
- Abra o Android Studio e vá em SDK Manager (File > Settings > Android SDK ou atalho na tela inicial).
- Na aba ‘SDK Platforms’, marque a versão do Android que deseja suportar (recomendo Android 12 como mínimo, Android 14 como target).
- Na aba ‘SDK Tools’, garanta que estão instalados: Android Emulator, Android SDK Platform-Tools, Google USB Driver (para conexão com dispositivos físicos).
- Clique em Apply e aguarde o download.
2.3 Criando o emulador de Android TV
Vá em Tools > Device Manager (ou AVD Manager em versões antigas) e siga os passos:
- Clique em ‘Create Device’.
- Na categoria ‘TV’, selecione o perfil de hardware. Para desenvolvimento, o ‘Android TV (1080p)’ é suficiente.
- Selecione uma imagem de sistema — use ‘Google TV’ com API 34 para a experiência mais próxima da realidade atual.
- Nas configurações avançadas, ajuste a RAM para pelo menos 2048 MB e ative a aceleração de hardware (HAXM no Windows/Mac, KVM no Linux).
- Finalize e inicie o emulador para verificar que está funcionando.
💡 Dica de Produtividade
O emulador é lento para iniciar. Deixe‑o rodando durante todo o dia de desenvolvimento — ele consome RAM mas economiza tempo. Use o comando ‘adb connect 192.168.x.x’ para conectar a uma TV física na mesma rede Wi-Fi, o que torna o ciclo de desenvolvimento muito mais rápido do que o emulador.
2.4 Conectando um dispositivo físico via ADB
Desenvolver com um Chromecast com Google TV, uma Android TV Box ou uma Smart TV real é infinitamente mais agradável do que usar o emulador. O processo é simples:
- Nas configurações da TV, vá em ‘Sobre’ e toque 7 vezes em ‘Build Number’ para ativar as Opções do Desenvolvedor.
- Em Opções do Desenvolvedor, ative ‘Depuração USB’ e ‘Depuração ADB pela rede’.
- Anote o IP da TV (Configurações > Rede > IP).
- No terminal do seu computador, execute:
adb connect IP_DA_TV:5555 - Confirme a conexão na TV quando solicitado.
3. Criando seu Primeiro Projeto Android TV
3.1 Estrutura do projeto
Existem duas abordagens para criar um app Android TV em 2024: usando a biblioteca Leanback (a abordagem tradicional, baseada em Fragments) ou usando o Jetpack Compose for TV (a abordagem moderna e recomendada para novos projetos). Este guia vai cobrir ambas, mas vai focar mais no Compose for TV, que é o futuro da plataforma.
Criando o projeto no Android Studio
- Clique em ‘New Project’.
- Selecione a aba ‘TV’ na lista de templates.
- Escolha ‘Android TV Activity’ (template Leanback) ou ‘Empty Activity’ (para começar com Compose for TV).
- Configure o nome do pacote, linguagem (Kotlin, sempre) e SDK mínimo (API 21 como mínimo, API 28 como recomendado).
3.2 O arquivo AndroidManifest.xml para TV
O manifesto de um app de TV tem algumas declarações cruciais que diferenciam ele de um app mobile. Sem elas, seu app não aparece na Play Store para TV nem funciona corretamente nos launchers de TV.
<manifest xmlns:android="http://schemas.android.com/apk/res/android"> <!-- Declaração crucial: este app suporta TV -->
<uses-feature
android:name="android.software.leanback"
android:required="true" /> <!-- TV não tem touchscreen: declare como não obrigatório -->
<uses-feature
android:name="android.hardware.touchscreen"
android:required="false" /> <application
android:banner="@drawable/app_banner"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/Theme.Leanback"> <activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<!-- Intent de launcher para TV -->
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LEANBACK_LAUNCHER" />
</intent-filter>
</activity> </application>
</manifest>
Atenção ao banner: O atributo android:banner aponta para uma imagem de 320x180dp que aparece no launcher da TV. Sem essa imagem, seu app pode não aparecer ou aparecer com visual inadequado no launcher.
3.3 Dependências essenciais
No seu build.gradle (Module: app), adicione as dependências conforme a abordagem escolhida:
dependencies {
// Para Leanback (abordagem tradicional)
implementation 'androidx.leanback:leanback:1.2.0'
implementation 'com.github.bumptech.glide:glide:4.16.0' // Para Jetpack Compose for TV (abordagem moderna)
implementation 'androidx.tv:tv-foundation:1.0.0-alpha10'
implementation 'androidx.tv:tv-material:1.0.0-alpha10' // Dependências comuns
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.7.0'
implementation 'androidx.activity:activity-compose:1.8.2'
implementation 'androidx.compose.ui:ui:1.6.0'
implementation 'androidx.compose.material3:material3:1.2.0' // Navegação
implementation 'androidx.navigation:navigation-compose:2.7.6' // Media (para apps de streaming)
implementation 'androidx.media3:media3-exoplayer:1.2.1'
implementation 'androidx.media3:media3-ui:1.2.1'
}
4. Desenvolvendo a Interface com Jetpack Compose for TV
4.1 A filosofia do design para TV
Antes de escrever os Composables, internalize três princípios que devem guiar cada decisão de design no seu app de TV:
Conteúdo primeiro: Na TV, o conteúdo é rei. A interface deve desaparecer e deixar o conteúdo brilhar. Fundos escuros, elementos de UI discretos, e muito espaço em branco são padrões por razão.
Foco sempre visível: O usuário precisa saber exatamente onde está em cada momento. O estado de foco deve ser óbvio — não um sutil brilho, mas uma mudança clara de cor, tamanho ou borda.
Hierarquia clara: Com controle remoto, o usuário não pode “escanear” a tela com o olho e clicar diretamente. A hierarquia visual precisa guiar o olhar e o D‑pad de forma natural e previsível.
4.2 Componentes fundamentais do tv-material
A biblioteca androidx.tv:tv-material fornece componentes otimizados para TV que já implementam o comportamento de foco corretamente. Vamos ver os mais importantes:
NavigationDrawer — Menu lateral
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun TvApp() {
val navDrawerState = rememberDrawerState(DrawerValue.Closed) NavigationDrawer(
drawerState = navDrawerState,
drawerContent = { drawerValue ->
Column(
modifier = Modifier
.padding(16.dp)
.fillMaxHeight()
) {
// Logo do app
Text(
text = "MeuApp TV",
style = MaterialTheme.typography.headlineMedium,
modifier = Modifier.padding(bottom = 24.dp)
) // Items de navegação
navItems.forEach { item ->
NavigationDrawerItem(
selected = currentRoute == item.route,
onClick = { navController.navigate(item.route) },
leadingContent = { Icon(item.icon, item.label) },
content = { Text(item.label) }
)
}
}
}
) {
// Conteúdo principal
MainContent(navController)
}
}
TvLazyRow — Carrossel horizontal
O padrão mais comum em apps de TV é a grade de conteúdo: linhas horizontais de cards, cada linha representando uma categoria. O TvLazyRow é a implementação otimizada para isso:
@Composable
fun ContentRow(
title: String,
items: List<ContentItem>,
onItemClick: (ContentItem) -> Unit
) {
Column {
Text(
text = title,
style = MaterialTheme.typography.titleLarge,
modifier = Modifier.padding(start = 48.dp, bottom = 8.dp)
) TvLazyRow(
contentPadding = PaddingValues(horizontal = 48.dp),
horizontalArrangement = Arrangement.spacedBy(16.dp)
) {
items(items) { item ->
ContentCard(
item = item,
onClick = { onItemClick(item) }
)
}
}
}
}
Card com foco — O componente mais importante
O Card é o cavalo de batalha do UI de TV. Ele precisa ter estados de foco bem definidos. Veja como implementar um Card profissional:
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun ContentCard(
item: ContentItem,
onClick: () -> Unit,
modifier: Modifier = Modifier
) {
var isFocused by remember { mutableStateOf(false) } Card(
onClick = onClick,
modifier = modifier
.width(240.dp)
.onFocusChanged { isFocused = it.isFocused }
.animateContentSize(),
scale = CardDefaults.scale(
focusedScale = 1.08f // Amplia levemente ao receber foco
),
glow = CardDefaults.glow(
focusedGlow = Glow(
elevationColor = MaterialTheme.colorScheme.primary,
elevation = 8.dp
)
)
) {
Box {
// Imagem do conteúdo
AsyncImage(
model = item.thumbnailUrl,
contentDescription = item.title,
contentScale = ContentScale.Crop,
modifier = Modifier
.fillMaxWidth()
.aspectRatio(16f / 9f)
) // Overlay com informações (visível quando focado)
AnimatedVisibility(
visible = isFocused,
enter = fadeIn() + slideInVertically { it },
exit = fadeOut()
) {
Box(
modifier = Modifier
.fillMaxWidth()
.align(Alignment.BottomCenter)
.background(
Brush.verticalGradient(
listOf(Color.Transparent, Color.Black.copy(0.8f))
)
)
.padding(8.dp)
) {
Column {
Text(item.title, style = MaterialTheme.typography.bodyLarge)
Text(item.subtitle, style = MaterialTheme.typography.bodySmall)
}
}
}
}
}
}
5. Navegação por D‑pad e Gerenciamento de Foco
5.1 Como o sistema de foco funciona
O Android usa um sistema de foco baseado em algoritmo de busca direcional. Quando o usuário pressiona o direcional para a direita, o sistema procura o elemento focável mais próximo na direção direita a partir do elemento atual, considerando a posição e tamanho dos elementos na tela.
Na maioria dos casos, isso funciona automaticamente. Mas quando você tem layouts complexos, o sistema pode escolher o elemento errado. Nesses casos, você precisa controlar o foco manualmente.
5.2 Controlando o foco manualmente no Compose
// Definindo a ordem de foco explicitamente
val (item1, item2, item3) = FocusRequester.createRefs()Button(
onClick = { },
modifier = Modifier
.focusRequester(item1)
.focusProperties {
right = item2 // Ao pressionar direita, vai para item2
down = item3 // Ao pressionar baixo, vai para item3
}
) { Text("Botão 1") }// Solicitando foco programaticamente (ex: ao abrir uma tela)
LaunchedEffect(Unit) {
item1.requestFocus()
}
5.3 Interceptando teclas do controle remoto
Às vezes você precisa interceptar teclas específicas — como o botão de play/pause para controlar a reprodução de mídia. Isso é feito com o modificador onKeyEvent:
@Composable
fun VideoPlayer(viewModel: PlayerViewModel) {
Box(
modifier = Modifier
.fillMaxSize()
.focusable() // Necessário para receber eventos de tecla
.onKeyEvent { keyEvent ->
when {
keyEvent.key == Key.MediaPlayPause &&
keyEvent.type == KeyEventType.KeyUp -> {
viewModel.togglePlayPause()
true // Consumiu o evento
}
keyEvent.key == Key.MediaFastForward -> {
viewModel.seekForward(10_000)
true
}
keyEvent.key == Key.DirectionLeft &&
keyEvent.type == KeyEventType.KeyDown -> {
viewModel.seekBackward(10_000)
true
}
else -> false // Não consumiu, propaga para o sistema
}
}
) {
// Componentes do player aqui
}
}
6. Reprodução de Mídia com ExoPlayer
6.1 Por que ExoPlayer é o padrão
Para apps de streaming ou qualquer reprodução de vídeo, o ExoPlayer (agora Media3 ExoPlayer) é a escolha padrão no ecossistema Android TV. Ele suporta HLS, DASH, Smooth Streaming, formatos de container comuns, e tem integrações com DRM (Widevine) que são necessárias para conteúdo protegido.
6.2 Implementação básica do player
class PlayerViewModel(application: Application) : AndroidViewModel(application) { private val _player = ExoPlayer.Builder(application).build()
val player: ExoPlayer get() = _player fun play(url: String) {
val mediaItem = MediaItem.fromUri(url)
_player.apply {
setMediaItem(mediaItem)
prepare()
playWhenReady = true
}
} fun togglePlayPause() {
_player.playWhenReady = !_player.playWhenReady
} override fun onCleared() {
super.onCleared()
_player.release()
}
}@Composable
fun VideoPlayerScreen(url: String) {
val context = LocalContext.current
val viewModel: PlayerViewModel = viewModel() LaunchedEffect(url) { viewModel.play(url) } AndroidView(
factory = {
PlayerView(context).apply {
player = viewModel.player
useController = true
// Esconde controles nativos - vamos customizar
controllerAutoShow = false
}
},
modifier = Modifier.fillMaxSize()
)
}
7. Arquitetura Recomendada para Apps TV
7.1 MVVM + Repository + Clean Architecture
A arquitetura para apps TV segue o mesmo padrão do desenvolvimento Android moderno, mas com algumas considerações específicas. A separação de camadas é ainda mais importante porque apps TV frequentemente precisam integrar múltiplas fontes de dados (APIs de conteúdo, catálogos locais, cache agressivo).
Use o padrão MVVM com a seguinte estrutura de pacotes:
com.seuapp.tv/
├── data/
│ ├── remote/ # Retrofit, APIs
│ ├── local/ # Room Database, DataStore
│ ├── repository/ # Implementações do repositório
│ └── model/ # DTOs, entidades de dados
├── domain/
│ ├── model/ # Entidades de domínio
│ ├── repository/ # Interfaces do repositório
│ └── usecase/ # Casos de uso
├── presentation/
│ ├── home/
│ │ ├── HomeScreen.kt
│ │ └── HomeViewModel.kt
│ ├── player/
│ │ ├── PlayerScreen.kt
│ │ └── PlayerViewModel.kt
│ └── components/ # Composables reutilizáveis
└── di/ # Injeção de dependência (Hilt)
7.2 Gerenciamento de estado
Apps de TV têm ciclos de vida peculiares. O usuário pode pausar um vídeo, ir para outra atividade, dormir com a TV ligada, e voltar horas depois. Seu app precisa persistir e restaurar estado de forma robusta.
// Use SavedStateHandle para persistir estado crítico
class HomeViewModel(
private val getContentUseCase: GetContentUseCase,
private val savedStateHandle: SavedStateHandle
) : ViewModel() { // Restaura a posição de scroll entre recriações
private val _selectedCategory = savedStateHandle.getStateFlow(
"selectedCategory", 0
) val uiState: StateFlow<HomeUiState> = getContentUseCase()
.map { content -> HomeUiState.Success(content) }
.catch { HomeUiState.Error(it.message ?: "Erro desconhecido") }
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5_000),
initialValue = HomeUiState.Loading
)
}
8. Testando seu App de TV
8.1 Testes de UI com Compose Testing
Testar apps TV tem uma camada adicional de complexidade: você precisa testar não apenas a renderização, mas também o comportamento de foco. O Compose Testing Framework suporta simulação de eventos de D‑pad:
@Test
fun contentCard_receivesFocus_showsOverlay() {
composeTestRule.setContent {
ContentCard(
item = fakeContentItem,
onClick = {}
)
} // Simula o card recebendo foco
composeTestRule
.onNodeWithContentDescription(fakeContentItem.title)
.requestFocus() // Verifica que o overlay com título está visível
composeTestRule
.onNodeWithText(fakeContentItem.title)
.assertIsDisplayed()
}@Test
fun navigation_dpadRight_movesFocusToNextCard() {
composeTestRule.setContent { ContentRow(items = fakeItems) } composeTestRule
.onAllNodesWithTag("content_card")[0]
.requestFocus() // Simula pressionar D-pad direita
composeTestRule.onRoot().performKeyPress(
KeyEvent(KEYCODE_DPAD_RIGHT, ACTION_DOWN)
) // Verifica que o segundo card tem foco
composeTestRule
.onAllNodesWithTag("content_card")[1]
.assertIsFocused()
}
8.2 Checklist de testes manuais
Antes de publicar, execute este checklist em pelo menos um dispositivo físico e um emulador:
- Navegação completa com D‑pad sem usar toque em nenhum momento
- Foco sempre visível em todos os elementos interativos
- Comportamento correto ao pressionar o botão Voltar (Back)
- App funciona com controle remoto de terceiros (pode ter layouts de teclas diferentes)
- Reprodução de vídeo inicia, pausa, retrocede e avança corretamente
- App retorna ao estado correto após entrar em standby e voltar
- Performance: sem jank (quedas de frame) ao rolar listas longas
- Texto legível a 3 metros de distância
- Contraste adequado para uso em ambientes com iluminação variada
9. Performance e Otimizações
9.1 Carregamento de imagens
Apps de TV exibem muitas imagens simultaneamente — thumbnails de conteúdo em múltiplas linhas. O carregamento ineficiente de imagens é a causa mais comum de jank em apps de TV. Use Coil ou Glide com configuração adequada:
// No Application class: configure o ImageLoader globalmente
class MyApplication : Application(), ImageLoaderFactory {
override fun newImageLoader(): ImageLoader {
return ImageLoader.Builder(this)
.memoryCache {
MemoryCache.Builder(this)
.maxSizePercent(0.30) // 30% da RAM para cache
.build()
}
.diskCache {
DiskCache.Builder()
.directory(cacheDir.resolve("image_cache"))
.maxSizeBytes(512L * 1024 * 1024) // 512 MB
.build()
}
.crossfade(true)
.build()
}
}
9.2 Composição eficiente
No Compose for TV, evite recomposições desnecessárias usando as melhores práticas do Compose:
- Use
rememberederivedStateOfpara cálculos derivados - Prefira lambdas estáveis em callbacks (evite criar lambdas inline em Composables que recompõem frequentemente)
- Use
key()em listas para que o Compose reutilize Composables corretamente - Perfilie com Android Studio Profiler — a aba Layout Inspector mostra recomposições em tempo real
10. Publicando na Google Play Store for TV
10.1 Requisitos obrigatórios da Play Store
O processo de publicação para TV tem requisitos adicionais além dos apps mobile. O time de review da Google verifica especificamente:
- O manifest declara
android.software.leanbackcomrequired="true"(ou false se for app híbrido TV/mobile) - O manifest declara
android.hardware.touchscreencomrequired="false" - O app tem um banner de 320x180dp declarado no manifest
- A Activity principal tem a categoria
LEANBACK_LAUNCHERno intent-filter - O app funciona inteiramente sem toque — nenhuma funcionalidade essencial depende de touchscreen
- O app não usa permissões que não fazem sentido em TV (câmera, por exemplo) como obrigatórias
10.2 Assets necessários para publicação
Asset
Dimensão
Observação
Ícone do app
512x512 px
PNG, sem transparência
Banner de TV
1280x720 px
PNG, aparece na Play Store
Feature Graphic
1024x500 px
PNG ou JPG
Screenshots de TV
1920x1080 px
Mínimo 2, máximo 8
Banner do launcher
320x180 dp
PNG no projeto
Vídeo promocional
YouTube, 30–120s
Opcional mas recomendado
10.3 O processo de publicação passo a passo
- Gere o APK ou AAB assinado (Build > Generate Signed Bundle/APK).
- No Google Play Console, crie um novo app ou adicione suporte a TV em um app existente.
- Em ‘Configuração > Presença na Play Store’, adicione os assets de TV na seção ‘TV’.
- Na aba ‘Lançamento’, suba o AAB para a trilha de Testes Internos primeiro.
- Instale via Play Store no dispositivo de TV e valide a experiência completa.
- Promova para Produção quando satisfeito com os testes.
⚠️ Atenção: Review de TV é mais rigoroso
A Google costuma rejeitar apps de TV que não passam na verificação de navegação por D‑pad. O review pode levar de 3 a 7 dias. Certifique-se de que 100% do fluxo do usuário funciona sem toque antes de submeter, pois cada rejeição adiciona dias ao ciclo de publicação.
11. Monetização em Apps Android TV
11.1 Modelos de monetização que funcionam em TV
O comportamento do usuário de TV é diferente do mobile. Não existe o hábito de “checar o app por 2 minutos” — as sessões são longas, imersivas, e muitas vezes sociais (assistir com a família). Isso muda completamente o que funciona em termos de monetização.
Assinatura (Subscription) — O modelo dominante
Apps de streaming, entretenimento, fitness, e educação têm enorme sucesso com assinatura mensal ou anual. O usuário de TV está acostumado a pagar por conteúdo (Netflix, Prime, Disney+), então a barreira psicológica é menor do que no mobile. Implemente com Google Play Billing Library 6+.
Compra única (One-time purchase)
Para apps utilitários, jogos premium, ou conteúdo específico. Funciona bem quando o valor percebido é claro e imediato.
Freemium com desbloqueio
Ofereça o app gratuito com conteúdo limitado, e cobre para desbloquear a biblioteca completa. Funciona especialmente bem para apps de conteúdo.
O que NÃO funciona em TV
Anúncios banner: Banners são invasivos em tela grande e destroem a experiência. Se você vai usar publicidade, use vídeos de 15–30 segundos entre episódios, no modelo de app de TV gratuito com ads. Mesmo assim, a conversão para assinatura sem anúncios costuma ser o objetivo.
12. Casos de Uso e Inspiração
12.1 Tipos de apps que prosperam no Android TV
Não são apenas apps de streaming que fazem sentido na TV. O ecossistema está maduro para uma variedade maior de categorias:
- Streaming de vídeo e áudio: o caso óbvio, mas ainda há espaço para nicho
- Fitness e yoga: seguir uma aula na TV grande é muito superior ao celular
- Meditação e bem-estar: ambiente imersivo e tela grande criam experiência premium
- Jogos casuais: especialmente com controle Bluetooth, o mercado de jogos TV cresce
- Culinária e receitas: TV na cozinha é um hábito crescente
- Educação infantil: pais querem apps educativos de qualidade na TV
- Galeria de fotos e vídeos familiares: Google Fotos tem um ótimo app de TV — você pode fazer melhor para nichos específicos
- Dashboards e informações: monitoramento de câmeras, home automation, mercado financeiro
Conclusão: O Momento é Agora
O desenvolvimento para Android TV passou de uma especialidade obscura para uma oportunidade real e acessível. Com o Jetpack Compose for TV, você usa as mesmas habilidades do desenvolvimento Android moderno com adaptações pontuais para o contexto de TV. O mercado está crescendo, a concorrência em muitas categorias ainda é baixa, e a barreira técnica nunca foi tão pequena.
O caminho que percorremos neste guia — do ambiente de desenvolvimento até a publicação na Play Store — é todo o conhecimento de base que você precisa. A partir daqui, o diferencial é o produto: entender profundamente o usuário de TV, criar uma experiência que respeite o contexto da sala de estar, e iterar rapidamente com base em feedback real.
Três pontos para levar consigo: primeiro, nunca assuma que algo funciona sem testar com um controle remoto real — o emulador de D‑pad não captura todos os edge cases. Segundo, invista tempo no estado de foco dos seus componentes — é o que separa um app amador de um app profissional na TV. Terceiro, pense nas sessões longas: seu app precisa ser estável por horas, gerenciar memória eficientemente, e lidar graciosamente com o standby da TV.
O Android TV está esperando pelo seu próximo great app. Agora você tem o mapa.
