Entendendo Flows no Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay

fun rocketseatFlow(): Flow<String> = flow {
    val etapas = listOf(
        "Preparando o Ambiente",
        "Fundamentos do Kotlin",
        "Primeiro Projeto com Jetpack Compose",
        "Testes Automatizados",
        "Publicação na Play Store"
    )
    for (etapa in etapas) {
        delay(6000) // Simulando o tempo de conclusão de cada etapa
        emit(etapa) // Emitindo a próxima etapa
    }
}

fun main() = runBlocking {
    rocketseatFlow().collect { etapa ->
        println("Progresso na formação: $etapa")
    }
}

StateFlow: o guardião do estado

Características principais

• Valor inicial obrigatório: sempre começa com um estado inicial definido.

• Atualizações confladas: emite apenas o valor mais recente, ignorando atualizações intermediárias.

• Imutabilidade para coletores: exponha o StateFlow como somente leitura para segurança.

Criando e usando um StateFlow

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.launch

class ActiveStudentsManager {
    private val _activeStudents = MutableStateFlow(0) // Estado inicial
    val activeStudents: StateFlow<Int> = _activeStudents.asStateFlow() // Expondo como somente leitura

    fun studentJoined() {
        _activeStudents.value += 1
    }

    fun studentLeft() {
        _activeStudents.value -= 1
    }
}

fun main() = runBlocking {
    val manager = ActiveStudentsManager()

    // Coletor de estado
    launch {
        manager.activeStudents.collect { count ->
            println("Número de alunos ativos: $count")
        }
    }

    // Alterando o estado
    manager.studentJoined()
    manager.studentLeft()
}

SharedFlow: compartilhando o fluxo

Características principais

• Sem estado inicial: não exige um valor inicial.

• Configuração de replay: pode "repetir" eventos passados para novos coletores.

• Flexibilidade no buffer: configurável para diferentes comportamentos de buffer.

Criando e usando um SharedFlow

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.launch

class MentoringChat {
    private val _messages = MutableSharedFlow<String>(replay = 3) // Repassa as últimas 3 mensagens
    val messages = _messages.asSharedFlow()

    suspend fun sendMessage(message: String) {
        _messages.emit(message)
    }
}

fun main() = runBlocking {
    val chat = MentoringChat()

    // Coletores de mensagens
    launch {
        chat.messages.collect { message ->
            println("Participante 1 recebeu: $message")
        }
    }

    launch {
        chat.messages.collect { message ->
            println("Participante 2 recebeu: $message")
        }
    }

    // Enviando mensagens
    chat.sendMessage("Bem-vindos à mentoria Rocketseat!")
    chat.sendMessage("Preparem suas perguntas!")
    chat.sendMessage("Começando em 3... 2... 1!")
}

Integração e boas práticas

Dicas valiosas para usar StateFlow e SharedFlow

1. Encapsule os fluxos com segurança
Exponha apenas versões imutáveis de seus fluxos (asStateFlow() ou asSharedFlow()). Isso protege sua lógica interna de alterações acidentais e garante que apenas as ações controladas possam modificar os dados.

private val _state = MutableStateFlow(0)
val state: StateFlow<Int> = _state.asStateFlow() // Apenas leitura externa

2. Gerencie recursos com responsabilidade
Sempre cancele corrotinas quando elas não forem mais necessárias. Isso evita vazamentos de memória e melhora significativamente o desempenho da aplicação. Um exemplo clássico é gerenciar os coletores de Flow no ciclo de vida de uma Activity no Android. Utilizando o lifecycleScope, você garante que a coleta dos dados seja encerrada automaticamente quando a Activity sair do estado ativo, como no exemplo a seguir:

// Dentro de uma Activity
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        myViewModel.myFlow.collect { value ->
            println("Recebendo valor: $value")
            // Atualize a UI com o valor recebido
        }
    }
}

Nesse código, o Flow definido no myViewModel começa a ser coletado quando a Activity atinge o estado STARTED. Assim que o ciclo de vida muda para STOPPED, a coleta é cancelada automaticamente. Isso protege os recursos e evita vazamentos de memória.
Agora, considere que estamos em um app da Rocketseat, onde queremos exibir a lista de alunos conectados em uma mentoria ao vivo. Ao usar o lifecycleScope da maneira correta, garantimos que essa lista seja atualizada em tempo real enquanto a mentoria está ativa, e que as atualizações parem assim que a tela é fechada.
Gerenciar recursos com responsabilidade não é apenas uma boa prática: é essencial para manter a performance e a estabilidade das suas aplicações, entregando a melhor experiência para o usuário.

3. Transforme dados de forma inteligente
Simplifique a lógica da sua aplicação com operadores como combine, map e filter. Eles ajudam a transformar os dados para atender às suas necessidades sem modificar a origem.

val combinedFlow = flow1.combine(flow2) { value1, value2 -> value1 + value2 }
combinedFlow.collect { println("Valor combinado: $it") }

4. Teste e depure seus fluxos
Antes de implementar, use ferramentas como Turbine para testar o comportamento dos fluxos. Isso garante que você saiba exatamente como seus dados fluem na aplicação, mesmo em cenários complexos.

5. Aproveite a flexibilidade do SharedFlow
Configure o replay e o buffer para atender diferentes necessidades. Por exemplo, em uma aplicação de eventos ao vivo, configure o replay para garantir que novos usuários recebam as últimas mensagens enviadas.

Ao aplicar essas práticas, você não apenas aumenta a qualidade do seu código, mas também entrega uma experiência de usuário mais fluida e confiável. Combine as capacidades do StateFlow e do SharedFlow com a paixão pela tecnologia, e o resultado será nada menos que incrível.

Recursos extras para dominar o StateFlow e SharedFlow

• Documentação Oficial do StateFlow: a fonte definitiva de conhecimento sobre StateFlow. Explore todos os detalhes, métodos e parâmetros disponíveis. Essencial para consultas aprofundadas.

• Documentação Oficial do SharedFlow: Tudo que você precisa saber sobre SharedFlow, diretamente da fonte. Perfeito para entender as nuances e as diversas configurações.

• "Kotlin: Revolucione sua Carreira em Programação" (Blog da Rocketseat): Descubra como o Kotlin está transformando o mercado de desenvolvimento mobile e como você pode se destacar nessa área:

Conclusão: sua jornada começa agora!

Por que escolher a Rocketseat para sua jornada?

• Domine as tecnologias que o mercado deseja: aprenda Kotlin, Jetpack Compose, Clean Architecture e muito mais, em aulas que vão direto ao ponto, ministradas por instrutores experientes, como Bernardo Michel Slailati.

• Aprenda fazendo: trabalhe em projetos e desafios reais que não só consolidam seu aprendizado, mas também constroem um portfólio que brilha aos olhos de recrutadores.

• Conquiste oportunidades nas maiores empresas: Spotify, Uber e Slack são apenas algumas das gigantes que utilizam Kotlin. Domine essas tecnologias e aumente suas chances de se destacar no mercado de trabalho, que está em constante busca por profissionais qualificados em Kotlin.

• Ganhe suporte personalizado: desde tutorias individuais até mentorias de carreira, a Rocketseat vai além de ensinar. Ela te guia em cada passo, ajudando a transformar habilidades em uma carreira de sucesso.

Formação Android com Kotlin | Rocketseat

Domine o desenvolvimento de apps Android do zero à publicação na Play Store, usando Kotlin, Jetpack Compose, e práticas modernas como Clean Architecture e testes automatizados.

https://www.rocketseat.com.br/formacao/kotlin?utm_source=site&utm_medium=organic&utm_campaign=lead&utm_term=artigo&utm_content=link-kotlin_stateflow_sharedflow