Forem: Ronaldo Costa de Freitas

Melhorando a performance da Pokédex com Paging 3 e Flow API

Ronaldo Costa de Freitas — Thu, 17 Nov 2022 00:23:57 +0000

Até agora nós já conseguimos mostrar todos os pokémon da região de Kanto (os 151 primeiros) na tela do nosso app, junto com seus nomes, ids e tipos. Porém, nossa aplicação ainda está muito lenta: são necessários mais que 10 segundos para carregar apenas os primeiros monstrinhos de bolso. Por esse motivo, nesse post nós vamos melhorar a performance da nossa Pokédex usando a versão 3 da biblioteca Paging e a Flow API.

O que é `Paging 3`?

A Paging é uma biblioteca capaz de implementar um mecanismo chamado paginação, trata-se de carregar grandes quantidades de dados de forma gradual, reduzindo o uso de rede e de recursos do sistema. A versão 3 dessa biblioteca está estável, usa Kotlin coroutines por default e é por isso que vamos usá-la.

Vantagens de Paging 3:

Controla as chaves a serem utilizadas para recuperar a página seguinte e a anterior.
Automaticamente faz a requisição da página seguinte correta quando o usuário percorre a tela para o fim dos dados carregados.
Garante que múltiplas requisições não sejam disparadas ao mesmo tempo.
Rastreia o estado de carregamento e nos permite exibí-lo em uma RecyclerView e provê uma funcionalidade de retentativa fácil para casos de falha no carregamento.
Permite o uso de operações comuns como map ou filter na lista a ser exibida.
Provê um jeito fácil de implementar um separador de lista, como um footer, que iremos fazer.
Simplifica o cache dos dados, garantindo que nós não estaremos executando transformações de dados a cada mudança de configuração.

Como podemos ver, é uma ótima solução para o nosso problema de lentidão e limitação de exibição dos pokémon, com essa biblioteca seremos capazes de exibir todos os monstrinhos 🤩

O que é `Flow API`?

De forma resumida, em coroutines, um Flow é um tipo que pode emitir vários valores sequencialmente, ao contrário das suspend functions, que retornam apenas um valor. No nosso caso, o usaremos para emitir um fluxo de dados de pokémon a partir do Paging para criar a nossa pokédex.

Conceitualmente, um Flow é um stream (fluxo) de dados que pode ser computado de forma assíncrona. Os valores emitidos precisam ser do mesmo tipo. Por exemplo, um Flow<Int> é um fluxo que emite valores inteiros. Vejamos o exemplo abaixo:

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.delay

suspend fun main() {
    val flow: Flow<Int> = flow {
        (0..10).forEach {
            delay(2000)
            emit(it)
        }
    }.map {
        it * it
    }

    flow.collect {
        println(it)
    }
}

Podemos considerar esse exemplo como um Hello World de Flow, nele nós criamos um fluxo de dados de inteiros que são emitidos a cada 2 (dois) segundos. Esses dados são transformados usando a função map e depois coletados usando a função collect para enfim serem exibidos no console.

Com esse simples exemplo nós podemos enxergar e entender os componentes e entidades envolvidas no fluxo de dados: o Flow Builder (produtor), o Operator (intermediário) e o Collector (consumidor).

Em resumo, o Flow Builder realiza as tarefas e emite os dados, o Operator transforma os dados de um formato para outro e o Collector coleta os dados emitidos pelo Flow Builder que foram transformados pelo Operator.

Na nossa aplicação, a fonte da dados e o repositório representarão as tarefas do consumidor e intermediário, enquanto a UI será a consumidora.

Implementando a solução

Para implementar a nossa solução precisaremos criar um PagingSource, um Pager, um Flow de PagingData e um adaptador para a UI chamado PagingDataAdapter.

Ok, mas o que é essa sopa de letrinhas? Calma, vamos entender um por um.

`PagingSource`

Um PagingSource é a definição de uma fonte de dados para a paginação e a forma como esses dados serão recuperados de uma única fonte. O PagingSource deve ser parte da camada repository.

Vamos sobrescrever as funções getRefreshKey(), que provê uma chave para a função load(), e a própria função load(), que recupera os dados paginados da fonte de dados e retorna esses dados carregados junto com as informações sobre as chaves posterior e anterior. Ambas essas funções são suspend functions e por isso poderemos usar as funções que fazem as requisições à PokéAPI.

Primeiro de tudo, adicionaremos a dependência da biblioteca Paging ao nosso arquivo gradle.build:

def pagingVersion = "3.1.1"

dependencies {
        ...

    // Paging
    implementation "androidx.paging:paging-runtime:$pagingVersion"

        ...
}

Agora procederemos para o desenvolvimento da PagingSource, que chamaremos de PokedexPagingSource. O construtor primário da nossa classe vai receber uma instância de PokemonApi e ela vai herdar de PagingSource<Int, SinglePokemon>, ou seja, ela recebe uma chave inteira e devolve os dados de um pokémon. Iniciaremos com a construção do método getRefreshKey(), responsável por prover uma chave para o método load():

package br.com.pokedex.data.datasource.repository

import androidx.paging.PagingSource
import androidx.paging.PagingState
import br.com.pokedex.data.api.PokemonApi
import br.com.pokedex.domain.model.SinglePokemon

class PokedexPagingSource(
    private val api: PokemonApi
) : PagingSource<Int, SinglePokemon>() {

    override fun getRefreshKey(state: PagingState<Int, SinglePokemon>): Int? {
        return state.anchorPosition?.let { anchorPosition ->
            state.closestPageToPosition(anchorPosition)?.prevKey?.plus(1)
                ?: state.closestPageToPosition(anchorPosition)?.nextKey?.minus(1)
        }
    }
}

A chave que esse método retorna deve fazer com que load() carregue itens suficientes para preencher a viewport ao redor da última posição acessada, permitindo que a próxima geração os anime de forma transparente.

A última posição acessada pode ser recuperada via state.anchorPosition, a qual é tipicamente o mais alto ou mais baixo item na viewport devido ao acesso ser disparado pela ligação dos itens conforme eles rolam na tela. Mas no nosso caso, a última posição acessada não é o bastante, nós precisamos saber qual a chave/página mais próxima a essa posição e é por isso que usamos a função closestPageToPosition.

Por exemplo, digamos que temos que carregar 20 itens por página, carregar duas páginas significariam usar as chaves 1 e 2 e ter 40 itens carregados no total. Nessa situação, quando formos procurar pelo item na posição 30, state.anchorPosition retornaria 30, mas essa não pode ser nossa chave, nós precisa saber em qual página esse item está, ou seja, precisamos saber que é a página 2. É por isso que usamos state.anchorPosition e tentamos recuperar sua chave anterior, chave 1, plus(1) (”mais um”), resultando na chave 2. Caso a chave anterior seja nula, tentamos recuperar através da chave posterior, chave 3, minus(1) (”menos um”), resultando também na chave 2.

Chegou a hora de implementar a tão falada função load(). O seu retorno padrão é do tipo LoadResult<Key, Value>, no nosso caso é LoadResult<Int, SinglePokemon>. A classe LoadResult é uma sealed class. Uma sealed class é uma classe em que todas as suas subclasses devem ser desenvolvidas dentro dela mesma ou no mesmo arquivo. Essa nossa classe de retorno tem três subclasses: Error, Invalid e Page. Error representa um erro esperado (como uma falha de conexão de rede), Invalid representa a invalidação de qualquer futura requisição do PagingSource e Page representa o objeto retornado com sucesso.

A classe Page tem as seguintes propriedades relevantes para nós:

data: os dados carregados
prevKey: a chave para a página anterior, caso ela exista
nextKey: a chave para a página posterior, caso ela exista

Implementação da função load():

package br.com.pokedex.data.datasource.repository

import androidx.paging.PagingSource
import androidx.paging.PagingState
import br.com.pokedex.data.api.PokemonApi
import br.com.pokedex.data.datasource.Constants.LAST_OFFSET
import br.com.pokedex.data.datasource.Constants.LAST_POSITION
import br.com.pokedex.data.datasource.Constants.POKEMON_OFFSET
import br.com.pokedex.data.datasource.Constants.POKEMON_STARTING_OFFSET
import br.com.pokedex.data.mapper.toModel
import br.com.pokedex.domain.model.SinglePokemon
import okio.IOException
import retrofit2.HttpException

class PokedexPagingSource(
    private val api: PokemonApi
) : PagingSource<Int, SinglePokemon>() {

    // ...

    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, SinglePokemon> {
        val position = params.key ?: POKEMON_STARTING_OFFSET
        return try {
            val response = api.getPokemon(
                if (position == LAST_POSITION) {
                    LAST_OFFSET
                } else {
                    position * POKEMON_OFFSET
                }
            )
            val pokemon = mutableListOf<SinglePokemon>()
            response.body()?.results?.map { result ->
                val singlePokemon = api.getSinglePokemon(result.name)
                singlePokemon.body()?.toModel()?.let { pokemon.add(it) }
            }
            LoadResult.Page(
                data = pokemon,
                prevKey = if (position == POKEMON_STARTING_OFFSET) null else position,
                nextKey = if (position == LAST_POSITION) null else position + 1
            )
        } catch (exception: IOException) {
            return LoadResult.Error(exception)
        } catch (exception: HttpException) {
            return LoadResult.Error(exception)
        }
    }
}

Objeto Constants:

package br.com.pokedex.data.datasource

object Constants {
    const val BASE_URL = "https://pokeapi.co/api/v2/"
    const val POKEMON_STARTING_OFFSET = 0
    const val POKEMON_OFFSET = 20
    const val LAST_OFFSET = 885
    const val LAST_POSITION = 45
    const val PAGE_SIZE = 20
}

Também foi necessário modificar a PokemonApi com dois novos métodos: getPokemon(), que retorna certo número de pokémon de acordo com um offset e getSinglePokemon(), que obtêm os dados do pokémon a partir do seu nome. Além disso, o retorno dos métodos agora é do tipo Response<T>, necessário para a implementação com Paging:

package br.com.pokedex.data.api

import br.com.pokedex.data.api.dto.PokemonDTO
import br.com.pokedex.data.api.dto.SinglePokemonDTO
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query

interface PokemonApi {

    @GET("pokemon/")
    suspend fun getPokemon(
        @Query("offset") offset: Int?
    ): Response<PokemonDTO>

    @GET("pokemon/{name}")
    suspend fun getSinglePokemon(
        @Path("name") name: String?
    ) : Response<SinglePokemonDTO>

}

Classe PokemonDTO:

package br.com.pokedex.data.api.dto

import com.google.gson.annotations.SerializedName

data class PokemonDTO(
    @SerializedName("results") val results: List<PokemonResultDTO>
)

Iremos entender o código passo-a-passo.

Obtemos o valor da chave atual usando params.key, ou seja, usamos a função getRefreshKey(), caso seja nulo, usamos a constante POKEMON_STARTING_OFFSET:

val position = params.key ?: POKEMON_STARTING_OFFSET

O retorno da função é um try-catch em que tentamos recuperar os dados de 20 pokémon usando as constantes LAST_POSITION, LAST_OFFSET e POKEMON_OFFSET. A lógica é simples: para evitar obter pokémon com dados inconsistentes (além do id 905) nós passamos apenas o offset final, caso seja a última posição, caso não, fazemos o cálculo de position * POKEMON_OFFSET para obter os dados dos pokémon da vez. Além disso mapeamos o resultado dessa requisição para uma lista do tipo SinglePokemon. Por fim instanciamos um LoadResult e damos os valores às suas propriedades:

data recebe a lista de pokémon antes mencionada
prevKey recebe null, caso a posição atual seja 0 (zero), caso não, recebe a posição atual
nextKey recebe null, caso seja a última posição, caso não, recebe a posição atual mais 1

val response = api.getPokemon(
    if (position == LAST_POSITION) {
        LAST_OFFSET
    } else {
        position * POKEMON_OFFSET
    }
)
val pokemon = mutableListOf<SinglePokemon>()
response.body()?.results?.map { result ->
    val singlePokemon = api.getSinglePokemon(result.name)
    singlePokemon.body()?.toModel()?.let { pokemon.add(it) }
}
LoadResult.Page(
    data = pokemon,
    prevKey = if (position == POKEMON_STARTING_OFFSET) null else position,
    nextKey = if (position == LAST_POSITION) null else position + 1
)

Finalmente temos os catchs para protegermos nossa aplicação quanto a problemas de IO (conexão de rede, por exemplo) e HTTP (respostas com códigos diferentes de 2XX):

catch (exception: IOException) {
    return LoadResult.Error(exception)
} catch (exception: HttpException) {
    return LoadResult.Error(exception)
}

Ufa! Bastante coisa né? Mas calma que ainda tem mais.

`Pager` e `Flow<PagingData<T>>`

Agora que implementamos uma forma de lidar com nossa fonte de dados remota, já podemos modificar nosso repositório para essa mudança. A partir desse momento nosso repositório irá retornar um fluxo de dados do tipo PagingData<SinglePokemon> a partir de um Pager, mas o que é um Pager?

Um Pager nada mais é do que um construtor para um fluxo reativo (reactive stream) de PagingData, ele, unido ao Flow, lida com todos os estados da paginação, retornando um objeto em caso de sucesso e um erro em caso contrário.

Para instanciar um Pager, precisamos de um PageConfig, uma configuração para um Pager, no qual nós informamos o tamanho da página, 20, e além disso também é necessário informar a pagingSourceFactory, ou seja, como serão fabricados os dados daquele Pager, a saber, o PokédexPagingSource que definimos a pouco:

package br.com.pokedex.data.datasource.repository

import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import br.com.pokedex.data.api.PokemonApi
import br.com.pokedex.data.datasource.Constants.PAGE_SIZE
import br.com.pokedex.domain.model.SinglePokemon
import br.com.pokedex.domain.repository.PokemonRepository
import kotlinx.coroutines.flow.Flow

class PokemonRepositoryImpl(private val api: PokemonApi) : PokemonRepository {

    override fun getSinglePokemon(): Flow<PagingData<SinglePokemon>> {
        return Pager(
            config = PagingConfig(
                pageSize = PAGE_SIZE
            ),
            pagingSourceFactory = { PokedexPagingSource(api) }
        ).flow
    }
}

Por fim usamos a propriedade flow de Pager para indicar que será retornado um fluxo de PagingData, isto é, serão emitidas novas instâncias de PagingData em certas circunstâncias.

Interface PokemonRepository modificada:

package br.com.pokedex.domain.repository

import androidx.paging.PagingData
import br.com.pokedex.data.api.Resource
import br.com.pokedex.data.api.dto.SinglePokemonDTO
import br.com.pokedex.domain.model.SinglePokemon
import kotlinx.coroutines.flow.Flow

interface PokemonRepository {

    fun getSinglePokemon(): Flow<PagingData<SinglePokemon>>
}

`PagingDataAdapter`

Como já implementamos a camada de repository, vamos modificar a ViewModel para refletir essas mudanças. Não usaremos mais LiveData, usaremos Flow:

package br.com.pokedex.presentation

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.PagingData
import androidx.paging.cachedIn
import br.com.pokedex.domain.interactor.GetSinglePokemonUseCase
import br.com.pokedex.domain.model.SinglePokemon
import kotlinx.coroutines.flow.Flow

class PokedexViewModel(
    private val useCase: GetSinglePokemonUseCase
) : ViewModel() {

    fun getPokemonFlow(): Flow<PagingData<SinglePokemon>> {
        return useCase.execute().cachedIn(viewModelScope)
    }

}

Ficou bem mais simples, né? Nós basicamente mudamos o tipo de retorno da função getPokemonFlow(), antes chamada de getPokemon(), para Flow<PagingData<SinglePokemon>> e chamamos o UseCase, mas com a diferença que aplicamos uma nova função a essa chamada: cachedIn(). O que essa função faz?

A função cachedIn() cria um cache (área de memória de acesso rápido) de PagingData . Isso faz com que o flow seja mantido ativo enquanto o dado escopo está ativo, no nosso caso o escopo da ViewModel. Dessa forma garantimos que, qualquer que seja a mudança de configuração (rotação da tela, por exemplo), a nova Activity já irá receber os dados existentes, ao invés de fazer novas requisições para obter os dados do zero.

Note que o código do UseCase não foi alterado, graças a sintaxe enxuta do Kotlin:

package br.com.pokedex.domain.interactor

import br.com.pokedex.domain.repository.PokemonRepository

class GetSinglePokemonUseCase(private val repository: PokemonRepository) {

    fun execute() = repository.getSinglePokemon()
}

Pronto, já podemos criar o PagingDataAdapter que vai tornar possível conectar tudo isso com a UI. Basicamente vamos alterar o adapter já existente para refletir as mudanças que fizemos. O PokemonViewHolder se manterá o mesmo:

class PokemonViewHolder(binding: PokemonCardBinding) :
        RecyclerView.ViewHolder(binding.root) {
        private val image = binding.pokemonImage
        private val name = binding.pokemonName
        private val id = binding.pokemonId
        private val firstType = binding.firstPokemonType
        private val secondType = binding.secondPokemonType

        fun bind(singlePokemon: SinglePokemon) {
            loadPokemonImage(image, singlePokemon.imageUrl)
            name.text = singlePokemon.name
            id.text = singlePokemon.id.toString()
            firstType.text = singlePokemon.types.first().name
            secondType.text = singlePokemon.types.last().name
            secondType.apply {
                showIf(text.isNotEmpty())
            }
        }

        private fun loadPokemonImage(image: ImageView, imageUrl: String) {
            image.load(imageUrl)
        }
}

O retorno da nossa classe será PagingDataAdapter, no entanto, para utilizarmos esse tipo de adapter é necessário implementar a classe DiffUtil.ItemCallback. Essa classe é responsável por realizar um callback (passar uma função como parâmetro de outra) que calcula a diferença entre dois itens não-nulos na lista. Em outras palavras, ela serve para verificar se dois objetos representam o mesmo item e checar se dois itens tem os mesmos dados.

Vamos implementá-la como uma singleton class, uma classe de instância única. Kotlin desenvolve esse padrão de projeto com o uso da palavra chave object e como essa singleton class ficará dentro de outra, ela será um companion object:

companion object {
    private val POKEMON_COMPARATOR = object
        : DiffUtil.ItemCallback<SinglePokemon>() {

        override fun areItemsTheSame(
            oldItem: SinglePokemon,
            newItem: SinglePokemon
        ): Boolean =
            oldItem.id == newItem.id

        override fun areContentsTheSame(
            oldItem: SinglePokemon,
            newItem: SinglePokemon
        ): Boolean =
            oldItem == newItem
    }
}

Como podemos ver, sobrescrevemos dois métodos de DiffUtil.ItemCallback: areItemsTheSame() e areContentsTheSame(). Eles são encarregados de checar se dois itens são o mesmo item e se dois itens têm o mesmo conteúdo, respectivamente.

Nossa implementação é bem simples: para verificar se dois itens são o mesmo item, basta compararmos os ids dos pokémon e para verificar se dois itens têm o mesmo conteúdo podemos fazer uma comparação direta mesmo.

Podemos partir para o desenvolvimento das funções onBindViewHolder() e onCreateViewHolder(), não será necessário sobrescrevermos o método getItemCount(), o PagingDataAdapter será responsável por isso.

Nosso onBindViewHolder() ficará dessa forma:

override fun onBindViewHolder(holder: PokemonViewHolder, position: Int) {
    val singlePokemon = getItem(position)
    singlePokemon?.let {
        holder.bind(it)
    }
}

Aqui usamos o método getItem() fornecido pelo PagingDataAdapter que nos retorna o item que precisamos a partir da sua posição, visto que o retorno pode ser nulo, usamos uma safe call e finalmente realizamos o bind().

E quanto ao nosso método onCreateViewHolder(), nada muda:

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PokemonViewHolder {
        return PokemonViewHolder(
            PokemonCardBinding.inflate(
                LayoutInflater.from(context),
                parent,
                false
            )
        )
}

Está feito! Temos o nosso adapter:

package br.com.pokedex.presentation

import android.content.Context
import android.view.LayoutInflater
import android.view.ViewGroup
import android.widget.ImageView
import androidx.paging.PagingDataAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import br.com.pokedex.databinding.PokemonCardBinding
import br.com.pokedex.domain.model.SinglePokemon
import br.com.pokedex.util.showIf
import coil.load

class PokedexAdapter(
    private val context: Context
) : PagingDataAdapter<SinglePokemon, PokedexAdapter.PokemonViewHolder>(
    POKEMON_COMPARATOR
) {

    override fun onBindViewHolder(holder: PokemonViewHolder, position: Int) {
        val singlePokemon = getItem(position)
        singlePokemon?.let {
            holder.bind(it)
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PokemonViewHolder {
        return PokemonViewHolder(
            PokemonCardBinding.inflate(
                LayoutInflater.from(context),
                parent,
                false
            )
        )
    }

    inner class PokemonViewHolder(binding: PokemonCardBinding) :
        RecyclerView.ViewHolder(binding.root) {
        private val image = binding.pokemonImage
        private val name = binding.pokemonName
        private val id = binding.pokemonId
        private val firstType = binding.firstPokemonType
        private val secondType = binding.secondPokemonType

        fun bind(singlePokemon: SinglePokemon) {
            loadPokemonImage(image, singlePokemon.imageUrl)
            name.text = singlePokemon.name
            id.text = singlePokemon.id.toString()
            firstType.text = singlePokemon.types.first().name
            secondType.text = singlePokemon.types.last().name
            secondType.apply {
                showIf(text.isNotEmpty())
            }
        }

        private fun loadPokemonImage(image: ImageView, imageUrl: String) {
            image.load(imageUrl)
        }
    }

    companion object {
        private val POKEMON_COMPARATOR = object
            : DiffUtil.ItemCallback<SinglePokemon>() {

            override fun areItemsTheSame(
                oldItem: SinglePokemon,
                newItem: SinglePokemon
            ): Boolean =
                oldItem.id == newItem.id

            override fun areContentsTheSame(
                oldItem: SinglePokemon,
                newItem: SinglePokemon
            ): Boolean =
                oldItem == newItem
        }
    }

}

Conectando o adapter na UI

Procederemos para a conexão do adapter na UI. As duas funções mais importantes que construiremos serão as seguintes: setUpAdapter() e getPokemon(). A função setUpAdapter() se encarregará de configurar o nosso adapter:

private fun setUpAdapter() {
        pokedexAdapter.addLoadStateListener { loadState ->
            when(loadState.refresh) {
                is LoadState.Loading -> setUpLoadingView()
                is LoadState.Error -> setUpErrorView()
                else -> setUpSuccessView()
            }
        }
}

O PagingDataAdapter nos fornece uma excelente classe para tratamento de erros chamada CombinedLoadStates, que provê todos os estados de carregamento do adapter. O que nos interessa aqui é o estado refresh, que representa o estado do adapter no seu primeiro carregamento: Loading, Error e NotLoading, nos interessa apenas os dois primeiros. Caso esse estado seja Loading, configuramos a UI para representar um carregamento, caso seja Erorr, configuramos a UI para representar um erro e caso não seja nenhum desses dois, consideramos sucesso e apresentamos a lista de pokémon.

Métodos de configuração da UI:

private fun setUpSuccessView() {
        binding.apply {
            pokedexRecyclerView.showView()
            pokedexCircularProgressIndicator.hideView()
            pokedexErrorMessage.hideView()
        }
}

private fun setUpErrorView() {
    binding.apply {
        pokedexRecyclerView.hideView()
        pokedexCircularProgressIndicator.hideView()
        pokedexErrorMessage.showView()
    }
}

private fun setUpLoadingView() {
    binding.apply {
        pokedexRecyclerView.hideView()
        pokedexCircularProgressIndicator.showView()
        pokedexErrorMessage.hideView()
    }
}

Já conhecemos pokedexRecyclerView, mas aqui referenciamos duas outras views: pokedexCircularProgressIndicator e pokedexErrorMessage. A primeira se trata de uma progress bar em forma de círculo fornecida pelo Material Design e a segunda é apensa um TextView que apresenta uma mensagem de erro. Segue código modificado de activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/pokedexRecyclerView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:listitem="@layout/pokemon_card"
        android:visibility="visible"/>

    <TextView
        android:id="@+id/pokedexErrorMessage"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAlignment="center"
        app:layout_constraintTop_toBottomOf="@id/pokedexRecyclerView"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        android:text="@string/error_message"
        android:visibility="gone"/>

    <com.google.android.material.progressindicator.CircularProgressIndicator
        android:id="@+id/pokedexCircularProgressIndicator"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:indeterminate="true"
        android:visibility="gone"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Deixamos as duas views auxiliares gone por padrão e controlamos as suas visibilidades por meio dos seguintes métodos:

package br.com.pokedex.util

import com.google.android.material.progressindicator.CircularProgressIndicator

fun CircularProgressIndicator.showView() {
    visibility = CircularProgressIndicator.VISIBLE
}

fun CircularProgressIndicator.hideView() {
    visibility = CircularProgressIndicator.GONE
}

package br.com.pokedex.util

import android.widget.TextView

fun TextView.showIf(condition: Boolean) {
    if(condition) {
        visibility = TextView.VISIBLE
    }
}

fun TextView.showView() {
    visibility = TextView.VISIBLE
}

fun TextView.hideView() {
    visibility = TextView.GONE
}

package br.com.pokedex.util

import androidx.recyclerview.widget.RecyclerView

fun RecyclerView.showView() {
    visibility = RecyclerView.VISIBLE
}

fun RecyclerView.hideView() {
    visibility = RecyclerView.GONE
}

Também atualizamos o arquivo strings.xml, que contém as strings do nosso projeto:

<resources>
    <string name="app_name">Pokédex</string>
    <string name="error_message">Something went wrong\nPlease, check your network connection and try reopen the app</string>
</resources>

Agora vamos analisar o método getPokemon(). Esse método é responsável por coletar os dados a partir da ViewModel e submetê-los para o adapter. Para fazer isso usamos as funções collectLatest do Flow e submitData() do PagingDataAdapter, respectivamente:

private fun getPokemon() {
        lifecycleScope.launch {
            viewModel.getPokemonFlow().collectLatest { pokemon ->
                pokedexAdapter.submitData(pokemon)
            }
        }
}

Por fim, nossa classe PokedexActivity ficará dessa forma:

package br.com.pokedex.presentation

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import androidx.paging.LoadState
import androidx.recyclerview.widget.LinearLayoutManager
import br.com.pokedex.databinding.ActivityPokedexBinding
import br.com.pokedex.util.hideView
import br.com.pokedex.util.showView
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import org.koin.androidx.viewmodel.ext.android.viewModel

class PokedexActivity : AppCompatActivity() {

    private val binding by lazy {
        ActivityPokedexBinding.inflate(layoutInflater)
    }

    private val viewModel: PokedexViewModel by viewModel()
    private val pokedexAdapter by lazy {
        PokedexAdapter(this)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        setUpAdapter()
        setUpPokedexRecyclerView()
        getPokemon()
    }

    private fun setUpAdapter() {
        pokedexAdapter.addLoadStateListener { loadState ->
            when(loadState.refresh) {
                is LoadState.Loading -> setUpLoadingView()
                is LoadState.Error -> setUpErrorView()
                else -> setUpSuccessView()
            }
        }
    }

    private fun setUpSuccessView() {
        binding.apply {
            pokedexRecyclerView.showView()
            pokedexCircularProgressIndicator.hideView()
            pokedexErrorMessage.hideView()
        }
    }

    private fun setUpErrorView() {
        binding.apply {
            pokedexRecyclerView.hideView()
            pokedexCircularProgressIndicator.hideView()
            pokedexErrorMessage.showView()
        }
    }

    private fun setUpLoadingView() {
        binding.apply {
            pokedexRecyclerView.hideView()
            pokedexCircularProgressIndicator.showView()
            pokedexErrorMessage.hideView()
        }
    }

    private fun setUpPokedexRecyclerView() {
        binding.pokedexRecyclerView.apply {
            layoutManager = LinearLayoutManager(context)
            adapter = pokedexAdapter
        }
    }

    private fun getPokemon() {
        lifecycleScope.launch {
            viewModel.getPokemonFlow().collectLatest { pokemon ->
                pokedexAdapter.submitData(pokemon)
            }
        }
    }

}

Já podemos rodar o app e vermos os três tipos de visualização:

Tela de loading:

Tela de erro:

Tela de sucesso:

Com essa implementação conseguimos reduzir o tempo de espera de carregamento dos pokémon para menos de 5 segundos, uma melhora de mais de 50%! Parabéns para nós 😎👊

Mas ainda temos um problema: apesar de tratarmos possíveis erros no primeiro carregamento da tela, não fazemos isso depois. Ou seja, caso a internet do celular pare de funcionar por algum motivo, o usuário ficará sem saber o que fazer. Precisamos melhorar essa experiência. Como podemos fazer isso? Adicionando um footer!

Melhorando a experiência com footer

A biblioteca Paging oferece diversas ferramentas para melhorar a experiência da sua implementação, uma delas é o footer, que nada mais é do que um rodapé, um texto, botão ou imagem que sempre vai ficar no fim da tela. Usaremos esse footer para exibir uma progress bar circular de carregamento ou uma mensagem de erro e um botão para tentar carregar os dados restantes novamente.

Antes de tudo vamos criar um layout para esse footer, ele será composto de um CircularProgressIndicator, para representar o carregamento, um TextView, o texto de erro e um MaterialButton, o botão para tentar novamente. Todos eles terão visibilidade gone por default:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <TextView
        android:id="@+id/loadStateErrorMessage"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/error_message"
        android:layout_gravity="center"
        android:textAlignment="center"
        android:visibility="gone"/>

    <com.google.android.material.button.MaterialButton
        android:id="@+id/loadStateTryAgainButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/try_again"
        android:layout_gravity="center"
        android:visibility="gone"
        android:layout_marginTop="16dp"/>

    <com.google.android.material.progressindicator.CircularProgressIndicator
        android:id="@+id/loadStateProgressBar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:indeterminate="true"
        android:layout_gravity="center" />

</LinearLayout>

Arquivo strings.xml modificado:

<resources>
    <string name="app_name">Pokédex</string>
    <string name="error_message">Something went wrong\nCheck your network connection and try again</string>
    <string name="try_again">Try again</string>
    <string name="load_error_message">Something went wrong\nTry again</string>
</resources>

Para implementarmos esse footer também precisaremos criar um adapter, o LoadStateAdapter e esse adapter precisa de um ViewHolder. Vamos chamá-lo de PokedexLoadStateViewHolder:

package br.com.pokedex.presentation

import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.paging.LoadState
import androidx.recyclerview.widget.RecyclerView
import br.com.pokedex.R
import br.com.pokedex.databinding.PokedexLoadStateFooterBinding
import br.com.pokedex.util.hideView
import br.com.pokedex.util.showView

class PokedexLoadStateViewHolder(
    private val binding: PokedexLoadStateFooterBinding,
    tryAgain: () -> Unit
) : RecyclerView.ViewHolder(binding.root) {

    init {
        binding.loadStateTryAgainButton.setOnClickListener { tryAgain.invoke() }
    }

    fun bind(loadState: LoadState) {
        when(loadState) {
            is LoadState.Loading -> {
                binding.loadStateProgressBar.showView()
                binding.loadStateErrorMessage.hideView()
                binding.loadStateTryAgainButton.hideView()
            }
            is LoadState.Error -> {
                binding.loadStateErrorMessage.showView()
                binding.loadStateTryAgainButton.showView()
                binding.loadStateProgressBar.hideView()
            }
            is LoadState.NotLoading -> {
                // Do nothing
            }
        }
    }

    companion object {
        fun create(parent: ViewGroup, tryAgain: () -> Unit) : PokedexLoadStateViewHolder {
            val view = LayoutInflater.from(parent.context)
                .inflate(R.layout.pokedex_load_state_footer, parent, false)
            val binding = PokedexLoadStateFooterBinding.bind(view)
            return PokedexLoadStateViewHolder((binding), tryAgain)
        }
    }
}

Código das extension functions do MaterialButton:

package br.com.pokedex.util

import com.google.android.material.button.MaterialButton

fun MaterialButton.showView() {
    visibility = MaterialButton.VISIBLE
}

fun MaterialButton.hideView() {
    visibility = MaterialButton.GONE
}

O nosso ViewHolder recebe duas coisas no seu construtor: uma propriedade binding, que contém as referências às views do nosso layout, um callback da função que será executada ao clicar no botão de tentar novamente. Aqui também usamos uma initializer block, trata-se de um bloco de código que será executado sempre que a classe for criada. Nele nós informamos que a ação de clique no botão irá invocar a função callback tryAgain(), ou seja, irá executá-la.

class PokedexLoadStateViewHolder(
    private val binding: PokedexLoadStateFooterBinding,
    tryAgain: () -> Unit
) : RecyclerView.ViewHolder(binding.root) {

    init {
        binding.loadStateTryAgainButton.setOnClickListener { tryAgain.invoke() }
    }

    // ...

}

Depois disso criamos a função bind(), que irá ligar o adapter ao ViewHolder. Em resumo, ela usa os loadStates para tornar a UI reativa, faz com que ela reaja aos estados de sucesso, erro e carregamento:

fun bind(loadState: LoadState) {
        when(loadState) {
            is LoadState.Loading -> {
                binding.loadStateProgressBar.showView()
                binding.loadStateErrorMessage.hideView()
                binding.loadStateTryAgainButton.hideView()
            }
            is LoadState.Error -> {
                binding.loadStateErrorMessage.showView()
                binding.loadStateTryAgainButton.showView()
                binding.loadStateProgressBar.hideView()
            }
            is LoadState.NotLoading -> {
                // Do nothing
            }
        }
    }

Por fim, desenvolvemos uma função que retorna uma instância desse ViewHolder em um companion object, ela recebe uma ViewGroup, que chamamos de parent, e uma função callback tryAgain(). O parent trata-se do layout-pai desse outro layout, isto é, o activity_main.xml, e o tryAgain() é a função que será executada ao clicar no botão de tentar novamente:

companion object {
    fun create(parent: ViewGroup, tryAgain: () -> Unit) : PokedexLoadStateViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.pokedex_load_state_footer, parent, false)
        val binding = PokedexLoadStateFooterBinding.bind(view)
        return PokedexLoadStateViewHolder((binding), tryAgain)
    }
}

O código do nosso adapter será bem simples: sobrescrevemos os métodos onBindViewHolder() e onCreateViewHolder(). No primeiro, chamamos a função bind() do ViewHolder e no segundo chamamos a função create():

package br.com.pokedex.presentation

import android.view.ViewGroup
import androidx.paging.LoadState
import androidx.paging.LoadStateAdapter

class PokedexLoadStateAdapter(
    private val tryAgain: () -> Unit
) : LoadStateAdapter<PokedexLoadStateViewHolder>() {

    override fun onBindViewHolder(holder: PokedexLoadStateViewHolder, loadState: LoadState) {
        holder.bind(loadState)
    }

    override fun onCreateViewHolder(
        parent: ViewGroup,
        loadState: LoadState
    ): PokedexLoadStateViewHolder {
        return PokedexLoadStateViewHolder.create(parent, tryAgain)
    }

}

Note que o PokedexLoadStateAdapter recebe por parâmetro uma função callback, se trata da função que é executada ao clicar no botão de tentar novamente. Estamos a propagando desde a UI até o ViewHolder a passando na função create() no método onCreateViewHolder().

Estamos quase finalizando, mas antes precisamos fazer uma alteração em PokedexAdapter. Da forma como desenvolvemos o footer ele será exibido com o tamanho de um único span no RecyclerView e como planejamos apresentar os pokémon na forma de um grid de duas colunas, temos que consertar isso.

A lógica é a seguinte: caso o item de visualização seja um pokémon, esse item terá tamanho de span um, caso não seja, terá tamanho de span dois. Vamos começar sobrescrevendo a função getViewType() da PokedexAdapter:

override fun getItemViewType(position: Int): Int {
    return if (position == itemCount) {
        NETWORK_VIEW_TYPE
    } else {
        POKEMON_VIEW_TYPE
    }
}

Se a posição atual for igual a última, ou seja, igual a itemCount, o tipo de item de visualização será NETWORK_VIEW_TYPE, isto é, será um item que irá exibir a progress bar ou o erro. Caso não seja, será um item do tipo POKEMON_VIEW_TYPE, em outras palavras, o item exibirá um pokémon.

Objeto Constants modificado:

package br.com.pokedex.util

object Constants {
    const val BASE_URL = "https://pokeapi.co/api/v2/"
    const val POKEMON_STARTING_OFFSET = 0
    const val POKEMON_OFFSET = 20
    const val LAST_OFFSET = 885
    const val LAST_POSITION = 45
    const val PAGE_SIZE = 20
    const val NETWORK_VIEW_TYPE = 2
    const val POKEMON_VIEW_TYPE = 1
}

Pronto, já podemos começar a conectar o adpter à UI. A principal modifição será no método setUpPokedexRecyclerView(). É nele que vamos implementar essa lógica de tamanho de span:

package br.com.pokedex.presentation

import ...

private const val SPAN_COUNT = 2

class PokedexActivity : AppCompatActivity() {

    //...    

    private fun setUpPokedexRecyclerView() {
        binding.pokedexRecyclerView.apply {
            val gridLayoutManager = GridLayoutManager(context, SPAN_COUNT)
            gridLayoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
                override fun getSpanSize(position: Int): Int {
                    val viewType = pokedexAdapter.getItemViewType(position)
                    return if (viewType == POKEMON_VIEW_TYPE) ONE_SPAN_SIZE
                    else TWO_SPANS_SIZE
                }
            }
            layoutManager = gridLayoutManager
            adapter = pokedexAdapter.withLoadStateFooter(
                footer = PokedexLoadStateAdapter { pokedexAdapter.retry() }
            )
        }
    }

    //...

}

Objeto Constants modificado:

package br.com.pokedex.util

object Constants {
    const val BASE_URL = "https://pokeapi.co/api/v2/"
    const val POKEMON_STARTING_OFFSET = 0
    const val POKEMON_OFFSET = 20
    const val LAST_OFFSET = 885
    const val LAST_POSITION = 45
    const val PAGE_SIZE = 20
    const val NETWORK_VIEW_TYPE = 2
    const val POKEMON_VIEW_TYPE = 1
    const val ONE_SPAN_SIZE = 1
    const val TWO_SPANS_SIZE = 2
}

Primeiro nós criamos um GridLayoutManager, com span_count igual a dois. Depois nós instanciamos uma nova classe de SpanSizeLookUp como uma classe singleton e sobrescrevemos o método getSpanSizeLookUp(). Dentro desse método, nós obtemos o viewType do item atual, caso seja um pokémon, seu span terá tamanho um, caso não, seu span terá tamanho dois. Após isso, definimos que o gridLayout que configuramos será o layoutManager do RecyclerView e na definição do adapter fazemos uma modificação no código: informamos que agora a pokedexAdapter terá um footer, o PokedexLoadStateAdapter. Note que aqui finalmente passamos a função que será executada ao clicar no botão de tentar novamente: pokedexAdapter.retry(), essa função tenta recarregar qualquer requisição que falhou durante a paginação.

Para prover essa funcionalidade de retry() também no carregamento inicial, modificamos nosso layout da activity, inserindo um MaterialButton que quando clicado executa a função retry():

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/pokedexRecyclerView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:listitem="@layout/pokemon_card" />

    <TextView
        android:id="@+id/pokedexErrorMessage"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/error_message"
        android:textAlignment="center"
        android:visibility="gone"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/pokedexRecyclerView" />

    <com.google.android.material.button.MaterialButton
        android:id="@+id/pokedexTryAgainButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="@string/try_again"
        android:visibility="gone"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/pokedexErrorMessage" />

    <com.google.android.material.progressindicator.CircularProgressIndicator
        android:id="@+id/pokedexCircularProgressIndicator"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:indeterminate="true"
        android:visibility="gone"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Para relembrar como está o strings.xml:

<resources>
    <string name="app_name">Pokédex</string>
    <string name="error_message">Something went wrong\nCheck your network connection and try again</string>
    <string name="try_again">Try again</string>
    <string name="load_error_message">Something went wrong\nTry again</string>
</resources>

Sendo assim, a nossa classe PokedexActivity ficará dessa forma:

package br.com.pokedex.presentation

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import androidx.paging.LoadState
import androidx.recyclerview.widget.GridLayoutManager
import br.com.pokedex.databinding.ActivityPokedexBinding
import br.com.pokedex.util.Constants.NETWORK_VIEW_TYPE
import br.com.pokedex.util.Constants.ONE_SPAN_SIZE
import br.com.pokedex.util.Constants.POKEMON_VIEW_TYPE
import br.com.pokedex.util.Constants.TWO_SPANS_SIZE
import br.com.pokedex.util.hideView
import br.com.pokedex.util.showView
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
import org.koin.androidx.viewmodel.ext.android.viewModel

private const val SPAN_COUNT = 2

class PokedexActivity : AppCompatActivity() {

    private val binding by lazy { ActivityPokedexBinding.inflate(layoutInflater) }
    private val pokedexAdapter by lazy { PokedexAdapter(this) }
    private val viewModel: PokedexViewModel by viewModel()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        setUpAdapter()
        setUpTryAgainButton()
        setUpPokedexRecyclerView()
        getPokemon()
    }

    private fun setUpAdapter() {
        pokedexAdapter.addLoadStateListener { loadState ->
            when(loadState.refresh) {
                is LoadState.Loading -> setUpLoadingView()
                is LoadState.Error -> setUpErrorView()
                else -> setUpSuccessView()
            }
        }
    }

    private fun setUpSuccessView() {
        binding.apply {
            pokedexRecyclerView.showView()
            pokedexCircularProgressIndicator.hideView()
            pokedexErrorMessage.hideView()
            pokedexTryAgainButton.hideView()
        }
    }

    private fun setUpErrorView() {
        binding.apply {
            pokedexRecyclerView.hideView()
            pokedexCircularProgressIndicator.hideView()
            pokedexErrorMessage.showView()
            pokedexTryAgainButton.showView()
        }
    }

    private fun setUpLoadingView() {
        binding.apply {
            pokedexRecyclerView.hideView()
            pokedexCircularProgressIndicator.showView()
            pokedexErrorMessage.hideView()
            pokedexTryAgainButton.hideView()
        }
    }

    private fun setUpTryAgainButton() {
        binding.pokedexTryAgainButton.setOnClickListener {
            pokedexAdapter.refresh()
        }
    }

    private fun setUpPokedexRecyclerView() {
        binding.pokedexRecyclerView.apply {
            val gridLayoutManager = GridLayoutManager(context, SPAN_COUNT)
            gridLayoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
                override fun getSpanSize(position: Int): Int {
                    val viewType = pokedexAdapter.getItemViewType(position)
                    return if (viewType == POKEMON_VIEW_TYPE) ONE_SPAN_SIZE
                    else TWO_SPANS_SIZE
                }
            }
            layoutManager = gridLayoutManager
            adapter = pokedexAdapter.withLoadStateFooter(
                footer = PokedexLoadStateAdapter { pokedexAdapter.retry() }
            )
        }
    }

    private fun getPokemon() {
        lifecycleScope.launch {
            viewModel.getPokemonFlow().collectLatest { pokemon ->
                pokedexAdapter.submitData(pokemon)
            }
        }
    }

}

Finalmente nosso trabalho por hoje acabou! Vamos rodar o app e ver como ficaram as telas.

Tela de erro modificada:

Tela de pokémon com footer de carregamento:

Tela de pokémon com o footer de erro:

Próximos posts

Nos próximos posts vamos embelezar nossa Pokédex usando Navigation e Material Design, também vamos salvar os dados dos pokémon em um banco de dados usando Android Room e testar nosso app usando JUnit e Mockk.

Obrigado pela atenção e até a próxima!

Repo no github:

ronaldocoding / pokedex

A simple Pokédex

Pokédex

A simple Pokédex

View on GitHub

Post anterior:

Melhorando a arquitetura da Pokédex

Ronaldo Costa de Freitas ・ Nov 11 '22

#kotlin #android #cleancode #pokemon

Interfaces em Kotlin

Ronaldo Costa de Freitas — Tue, 15 Nov 2022 01:42:06 +0000

Hoje vamos nos aprofundar no entendimento de Programação Orientada a Objetos em Kotlin, veremos como a linguagem lida com interfaces e suas diferenças em relação a Java. As interfaces de Kotlin se diferenciam da sua equivalente em Java. Em Kotlin, as interfaces podem conter declarações de propriedades, por exemplo, algo que não ocorre em Java.

Similarmente a Java, elas podem conter definições de métodos abstratos assim como definições de métodos não abstratos, mas elas não podem conter nenhum estado.

interface Clickable {
    fun click()
}

Para criar um interface usamos a palavra-chave interface, seguida de seu nome e chaves. No exemplo acima temos uma interface chamada Clickable que contém a definição de um método abstrato chamado click(). Qualquer classe não abstrata que implemente essa interface será obrigada a implementar esse método:

class Button : Clickable {
    override fun click() = println("I was clicked")
}

>>> Button().click()
I was clicked

A classe desenvolvida acima Button implementa a interface Clickable (indicado pelos :, que substituem ambas as palavras-chave implements e extends de Java) e sobrescreve o método click(). Essa sobrescrita foi indicada pelo modificador override que é obrigatório em Kotlin, diferentemente de Java.

Como dito anteriormente, as interfaces tanto em Kotlin quanto em Java podem ter definições de métodos não abstratos, com a diferença que a notação default não é necessária:

Kotlin:

interface Clickable {
    fun click()
    fun showOff() = println("I'm clickable!")
}

Java 8:

interface Clickable {
    void click();
    default void showOff() {
        System.out.println("I'm clickable!")
    }
}

Implementando propriedades declaradas em interfaces

Se uma interface declarou uma ou mais propriedades, todas as classes que a implementam devem dar algum jeito de obter o valor dessa ou dessas propriedades.

Interface User:

interface User {
    val nickname: String
}

Vamos observar três possíveis formas de se inicializar a propriedade nickname da interface User em três classes que a implementam: PrivateUser, SubscribingUser e FacebookUser:

class PrivateUser(override val nickname: String) : User

class SubscribingUser(val email: String) : User {
    override val nickname: String
            get() = email.substringBefore('@')
}

class FacebookUser(val accountId: Int) : User {
    override val nickname = getFacebookName(accountId)
}

A primeira classe PrivateUser diz que o valor da propriedade será passado no construtor primário dela mesma, a classe SubscribingUser desenvolve um getter customizado para obter o valor da propriedade e, por fim, a classe FacebookUser apenas inicializa a propriedade de cara. Note que todas as implementações da propriedade foram marcadas com o modificador override.

As interfaces em Kotlin também podem conter getters e setters, mas não podem armazenar dados, visto que isso seria armazenar um estado, o que não é permitido como já dito. Vamos ver um exemplo:

interface User {
    val email: String
    val nickname: String
        get() = email.substringBefore('@')
}

Podemos ver que o valor da propriedade não é armazenado na interface, mas sim calculado todas as vezes que ela é implementada.

Fonte

O post de hoje foi baseado totalmente no incrível e conciso capítulo 4 de Kotlin in Action de Dmitry Jemerov e Svetlana Isakova. Confira o material original para maior entendimento de interfaces na nossa querida linguagem Kotlin.

Próximos posts

Nos próximos post vamos finalizar nossos estudo em Kotlin entendendo como a linguagem lida com classes e objetos. Obrigado pela atenção e até a próxima!

Post anterior:

Estruturas de controle em Kotlin

Ronaldo Costa de Freitas ・ Nov 8 ・ 5 min read

#kotlin #java

Criando uma API com Spring Boot e Kotlin — parte 3

Ronaldo Costa de Freitas — Sat, 12 Nov 2022 21:16:43 +0000

O post de hoje vai ser bem curto, vamos apenas desenvolver os métodos PUT (atualizar) e DELETE (deletar) da nossa API. Lembrando que estamos desenvolvendo um CRUD de um setup de PC. Um setup nada mais é do que um conjunto de peças necessárias para montar um computador de mesa: placa-mãe, placa de vídeo, processador, memória ram, etc.

Função `updateSetup`

Muito bem, vamos lá, para atualizarmos um setup específico do nosso banco de dados precisamos receber seu id e o próprio objeto setup com os dados atualizados, após isso é necessário verificar se um setup com esse id realmente existe, caso exista, nós o atualizamos, caso não, vamos retornar um objeto de setup vazio. Segue o código:

@PutMapping("{id}")
fun updateSetup(@PathVariable id: Long, @RequestBody setup: Setup): Setup {
  if(repository.existsById(id)) {
      return repository.save(setup)
  }
  return Setup()
}

Bem simples, não? Primeiro usamos a notação @PutMapping para indicar que a função irá mapear o método HTPP PUT, depois informamos que uma propriedade id será necessária no caminho da url.

Procedendo para o desenvolvimento da função em si, seus parâmetros são: um id, que será usado no caminho da url, como já dito, e um objeto setup, que será passado no body (corpo) da requisição.

Então nós verificamos se um setup com o id informado realmente existe com a função existsById(), se existir, nós salvamos o setup atualizado e caso não exista, nós retornamos um objeto de setup vazio.

Para retornar esse objeto vazio, precisamos fazer algumas alterações nas nossas classes models. É preciso que as propriedades delas tenham valores-padrão, a classe Part ficará dessa forma:

package br.com.pchunter.model

import br.com.pchunter.util.emptyString
import br.com.pchunter.util.zeroFloatNumber
import br.com.pchunter.util.zeroLongNumber
import com.fasterxml.jackson.annotation.JsonProperty
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.Id

@Entity
data class Part(
    @Id
    @GeneratedValue
    @JsonProperty(value = "id", access = JsonProperty.Access.READ_ONLY)
    val id: Long = zeroLongNumber(),
    val title: String = emptyString(),
    val description: String = emptyString(),
    val url: String = emptyString(),
    val value: Float = zeroFloatNumber()
)

Aqui nós definimos que os valores-padrão serão números zero e string vazias por meio das funções zeroLongNumber(), emptyString() e zeroFloatNumber:

package br.com.pchunter.util

fun emptyString() = ""

fun zeroLongNumber() = 0L

fun zeroFloatNumber() = 0.0f

Quanto a classe Setup, vamos definir os valores-padrão das suas propriedades como objetos de Part vazios e listas de Part também vazias:

package br.com.pchunter.model

import br.com.pchunter.util.zeroLongNumber
import com.fasterxml.jackson.annotation.JsonProperty
import javax.persistence.*

@Entity
data class Setup(
    @Id
    @GeneratedValue
    @JsonProperty(value = "id", access = JsonProperty.Access.READ_ONLY)
    val id: Long = zeroLongNumber(),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val cpu: Part = Part(),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val motherboard: Part = Part(),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val gpus: List<Part> = listOf(Part()),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val hds: List<Part> = listOf(Part()),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val ssds: List<Part> = listOf(Part()),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val rams: List<Part> = listOf(Part()),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val fans: List<Part> = listOf(Part()),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val powerSupply: Part = Part(),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val cabinet: Part = Part(),
    @OneToMany(cascade = [CascadeType.PERSIST])
    val monitors: List<Part> = listOf(Part()),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val keyboard: Part = Part(),
    @OneToOne(cascade = [CascadeType.PERSIST])
    val mouse: Part = Part()
) {
    val totalValue: Float
        get() {
            var acm = 0.0f
            acm += cpu.value +
                    motherboard.value +
                    powerSupply.value +
                    cabinet.value +
                    keyboard.value +
                    mouse.value
            gpus.forEach { gpu ->
                acm += gpu.value
            }
            hds.forEach { hd ->
                acm += hd.value
            }
            ssds.forEach { ssd ->
                acm += ssd.value
            }
            rams.forEach { ram ->
                acm += ram.value
            }
            fans.forEach { fan ->
                acm += fan.value
            }
            monitors.forEach { monitor ->
                acm += monitor.value
            }
            return acm
        }
}

Pronto, agora vamos testar essa função. Usando o Postman, faremos uma requisição GET para observarmos como estão os setups atuais:

[
    {
        "id": 474,
        "cpu": {
            "id": 476,
            "title": "Processador AMD Ryzen 5 5600X",
            "description": "Processador AMD Ryzen 5 5600X, 3.7GHz (4.6GHz Max Turbo), Cache 35MB, 6 Núcleos, 12 Threads, AM4 - 100-100000065BOX",
            "url": "https://www.kabum.com.br/produto/129451/processador-amd-ryzen-5-5600x-3-7ghz-4-6ghz-max-turbo-cache-35mb-6-nucleos-12-threads-am4-100-100000065box",
            "value": 1199.99
        },
        "motherboard": {
            "id": 478,
            "title": "Placa-Mãe Gigabyte B550M",
            "description": "Placa-Mãe Gigabyte B550M Aorus Elite, AMD AM4, Micro ATX, DDR4",
            "url": "https://www.kabum.com.br/produto/114781/placa-mae-gigabyte-b550m-aorus-elite-amd-am4-micro-atx-ddr4",
            "value": 849.99
        },
        "gpus": [
            {
                "id": 482,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 483,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 487,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 485,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 486,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 481,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 480,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 475,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 484,
                "title": "Monitor Gamer LG Ultra Gear 27 Full HD",
                "description": "Monitor Gamer LG Ultra Gear 27 Full HD, 144 Hz, 1ms, IPS, HDMI e DisplayPort, sRGB 99%, HDR10, FreeSync, VESA, Altura Ajustável - 27GL650F-B",
                "url": "https://www.kabum.com.br/produto/380514/monitor-gamer-lg-ultra-gear-27-full-hd-144-hz-1ms-ips-hdmi-e-displayport-srgb-99-hdr10-freesync-vesa-altura-ajustavel-27gl650f-b",
                "value": 1559.99
            }
        ],
        "keyboard": {
            "id": 477,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 479,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 7879.911
    },
    {
        "id": 488,
        "cpu": {
            "id": 490,
            "title": "Processador AMD Ryzen 5 5600X",
            "description": "Processador AMD Ryzen 5 5600X, 3.7GHz (4.6GHz Max Turbo), Cache 35MB, 6 Núcleos, 12 Threads, AM4 - 100-100000065BOX",
            "url": "https://www.kabum.com.br/produto/129451/processador-amd-ryzen-5-5600x-3-7ghz-4-6ghz-max-turbo-cache-35mb-6-nucleos-12-threads-am4-100-100000065box",
            "value": 1199.99
        },
        "motherboard": {
            "id": 492,
            "title": "Placa-Mãe Gigabyte B550M",
            "description": "Placa-Mãe Gigabyte B550M Aorus Elite, AMD AM4, Micro ATX, DDR4",
            "url": "https://www.kabum.com.br/produto/114781/placa-mae-gigabyte-b550m-aorus-elite-amd-am4-micro-atx-ddr4",
            "value": 849.99
        },
        "gpus": [
            {
                "id": 496,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 497,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 501,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 499,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 500,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 495,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 494,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 489,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 498,
                "title": "Monitor Gamer LG UltraGear 32 LED",
                "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
                "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
                "value": 1899.99
            }
        ],
        "keyboard": {
            "id": 491,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 493,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 8219.911
    }
]

Podemos observar que existem dois setups, vamos escolher o primeiro para modificar, seu id é 474. Esse será o novo setup passado no corpo da requisição PUT:

{
  "cpu": {
    "title": "Processador AMD Ryzen 7 5800X",
    "description": "Processador AMD Ryzen 7 5800X, 3.8GHz (4.7GHz Max Turbo), Cache 36MB, Octa Core, 16 Threads, AM4 - 100-100000063WOF",
    "url": "https://www.kabum.com.br/produto/129459/processador-amd-ryzen-7-5800x-3-8ghz-4-7ghz-max-turbo-cache-36mb-octa-core-16-threads-am4-100-100000063wof",
    "value": 1899.99
  },
  "motherboard": {
    "title": "Placa Mãe B650M-A MSI PRO Wi-Fi",
    "description": "Placa Mãe B650M-A MSI PRO Wi-Fi, AMD AM5, mATX, DDR5 - PRO B650M-A WIFI",
    "url": "https://www.kabum.com.br/produto/392613/placa-mae-b650m-a-msi-pro-wi-fi-amd-am5-matx-ddr5-pro-b650m-a-wifi",
    "value": 1999.99
  },
  "gpus": [
    {
      "title": "GTX 1660 Super",
      "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
      "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
      "value": 1299.99
    }
  ],
  "hds": [
    {
      "title": "HD Seagate 2TB",
      "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
      "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
      "value": 299.99
    }
  ],
  "ssds": [
    {
      "title": "SSD 512 GB",
      "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
      "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
      "value": 409.99
    }
  ],
  "rams": [
    {
      "title": "Memoria, Ram 8, Gb",
      "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
      "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
      "value": 390.06
    },
    {
      "title": "Memoria, Ram 8, Gb",
      "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
      "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
      "value": 390.06
    }
  ],
  "fans": [
    {
      "title": "Cooler Fan Rise Mode Energy",
      "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
      "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
      "value": 129.99
    }
  ],
  "powerSupply": {
    "title": "Fonte Corsair CV550",
    "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
    "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
    "value": 359.99
  },
  "cabinet": {
    "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
    "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
    "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
    "value": 399.99
  },
  "monitors": [
    {
      "title": "Monitor Gamer LG UltraGear 32 LED",
      "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
      "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
      "value": 1899.99
    }
  ],
  "keyboard": {
    "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
    "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
    "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
    "value": 419.99
  },
  "mouse": {
    "title": "Mouse Gamer HyperX Pulsefire Surge",
    "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
    "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
    "value": 169.89
  }
}

Apenas atualizamos alguns dados da cpu e da motherboard. Ao fazer a requisição, recebemos o seguinte resultado:

{
    "id": 502,
    "cpu": {
        "id": 504,
        "title": "Processador AMD Ryzen 7 5800X",
        "description": "Processador AMD Ryzen 7 5800X, 3.8GHz (4.7GHz Max Turbo), Cache 36MB, Octa Core, 16 Threads, AM4 - 100-100000063WOF",
        "url": "https://www.kabum.com.br/produto/129459/processador-amd-ryzen-7-5800x-3-8ghz-4-7ghz-max-turbo-cache-36mb-octa-core-16-threads-am4-100-100000063wof",
        "value": 1899.99
    },
    "motherboard": {
        "id": 506,
        "title": "Placa Mãe B650M-A MSI PRO Wi-Fi",
        "description": "Placa Mãe B650M-A MSI PRO Wi-Fi, AMD AM5, mATX, DDR5 - PRO B650M-A WIFI",
        "url": "https://www.kabum.com.br/produto/392613/placa-mae-b650m-a-msi-pro-wi-fi-amd-am5-matx-ddr5-pro-b650m-a-wifi",
        "value": 1999.99
    },
    "gpus": [
        {
            "id": 510,
            "title": "GTX 1660 Super",
            "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
            "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
            "value": 1299.99
        }
    ],
    "hds": [
        {
            "id": 511,
            "title": "HD Seagate 2TB",
            "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
            "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
            "value": 299.99
        }
    ],
    "ssds": [
        {
            "id": 515,
            "title": "SSD 512 GB",
            "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
            "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
            "value": 409.99
        }
    ],
    "rams": [
        {
            "id": 513,
            "title": "Memoria, Ram 8, Gb",
            "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
            "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
            "value": 390.06
        },
        {
            "id": 514,
            "title": "Memoria, Ram 8, Gb",
            "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
            "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
            "value": 390.06
        }
    ],
    "fans": [
        {
            "id": 509,
            "title": "Cooler Fan Rise Mode Energy",
            "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
            "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
            "value": 129.99
        }
    ],
    "powerSupply": {
        "id": 508,
        "title": "Fonte Corsair CV550",
        "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
        "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
        "value": 359.99
    },
    "cabinet": {
        "id": 503,
        "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
        "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
        "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
        "value": 399.99
    },
    "monitors": [
        {
            "id": 512,
            "title": "Monitor Gamer LG UltraGear 32 LED",
            "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
            "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
            "value": 1899.99
        }
    ],
    "keyboard": {
        "id": 505,
        "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
        "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
        "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
        "value": 419.99
    },
    "mouse": {
        "id": 507,
        "title": "Mouse Gamer HyperX Pulsefire Surge",
        "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
        "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
        "value": 169.89
    },
    "totalValue": 10069.911
}

O setup foi atualizado, mas repare que os ids também foram, o que não deveria acontecer, já que ele deveria ser um identificador imutável, apenas de leitura. Isso é uma falha de segurança que trataremos no próximo post. Nosso método PUT está pronto por enquanto.

Função `deleteSetup` e `deleteAllSetups`

Nossa função para deletar um setup será tão simples quanto a de atualizar:

@DeleteMapping("{id}")
fun deleteSetup(@PathVariable id: Long) {
    if (repository.existsById(id)) {
        repository.deleteById(id)
    }
}

Aqui também utilizamos uma notação chamada @DeleteMapping, que indica que a função irá mapear um método HTTP DELETE. Além disso, a função recebe um id como parâmetro que irá ficar no caminho da url. A lógica é bem simples: primeiro verificamos se existe um setup com esse id, caso exista, nós o deletamos.

Adicionalmente, vamos fazer uma função para deletar todos os setups:

@DeleteMapping()
fun deleteAllSetups() {
    repository.deleteAll()
}

Bem simples, apenas utilizamos a função deleteAll() do repository.

Agora vamos testar as funções. Primeiro vamos usar GET para vermos quais setups estão salvos no banco de dados:

[
    {
        "id": 474,
        "cpu": {
            "id": 476,
            "title": "Processador AMD Ryzen 5 5600X",
            "description": "Processador AMD Ryzen 5 5600X, 3.7GHz (4.6GHz Max Turbo), Cache 35MB, 6 Núcleos, 12 Threads, AM4 - 100-100000065BOX",
            "url": "https://www.kabum.com.br/produto/129451/processador-amd-ryzen-5-5600x-3-7ghz-4-6ghz-max-turbo-cache-35mb-6-nucleos-12-threads-am4-100-100000065box",
            "value": 1199.99
        },
        "motherboard": {
            "id": 478,
            "title": "Placa-Mãe Gigabyte B550M",
            "description": "Placa-Mãe Gigabyte B550M Aorus Elite, AMD AM4, Micro ATX, DDR4",
            "url": "https://www.kabum.com.br/produto/114781/placa-mae-gigabyte-b550m-aorus-elite-amd-am4-micro-atx-ddr4",
            "value": 849.99
        },
        "gpus": [
            {
                "id": 482,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 483,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 487,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 485,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 486,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 481,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 480,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 475,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 484,
                "title": "Monitor Gamer LG Ultra Gear 27 Full HD",
                "description": "Monitor Gamer LG Ultra Gear 27 Full HD, 144 Hz, 1ms, IPS, HDMI e DisplayPort, sRGB 99%, HDR10, FreeSync, VESA, Altura Ajustável - 27GL650F-B",
                "url": "https://www.kabum.com.br/produto/380514/monitor-gamer-lg-ultra-gear-27-full-hd-144-hz-1ms-ips-hdmi-e-displayport-srgb-99-hdr10-freesync-vesa-altura-ajustavel-27gl650f-b",
                "value": 1559.99
            }
        ],
        "keyboard": {
            "id": 477,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 479,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 7879.911
    },
    {
        "id": 488,
        "cpu": {
            "id": 490,
            "title": "Processador AMD Ryzen 5 5600X",
            "description": "Processador AMD Ryzen 5 5600X, 3.7GHz (4.6GHz Max Turbo), Cache 35MB, 6 Núcleos, 12 Threads, AM4 - 100-100000065BOX",
            "url": "https://www.kabum.com.br/produto/129451/processador-amd-ryzen-5-5600x-3-7ghz-4-6ghz-max-turbo-cache-35mb-6-nucleos-12-threads-am4-100-100000065box",
            "value": 1199.99
        },
        "motherboard": {
            "id": 492,
            "title": "Placa-Mãe Gigabyte B550M",
            "description": "Placa-Mãe Gigabyte B550M Aorus Elite, AMD AM4, Micro ATX, DDR4",
            "url": "https://www.kabum.com.br/produto/114781/placa-mae-gigabyte-b550m-aorus-elite-amd-am4-micro-atx-ddr4",
            "value": 849.99
        },
        "gpus": [
            {
                "id": 496,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 497,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 501,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 499,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 500,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 495,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 494,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 489,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 498,
                "title": "Monitor Gamer LG UltraGear 32 LED",
                "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
                "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
                "value": 1899.99
            }
        ],
        "keyboard": {
            "id": 491,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 493,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 8219.911
    },
    {
        "id": 502,
        "cpu": {
            "id": 504,
            "title": "Processador AMD Ryzen 7 5800X",
            "description": "Processador AMD Ryzen 7 5800X, 3.8GHz (4.7GHz Max Turbo), Cache 36MB, Octa Core, 16 Threads, AM4 - 100-100000063WOF",
            "url": "https://www.kabum.com.br/produto/129459/processador-amd-ryzen-7-5800x-3-8ghz-4-7ghz-max-turbo-cache-36mb-octa-core-16-threads-am4-100-100000063wof",
            "value": 1899.99
        },
        "motherboard": {
            "id": 506,
            "title": "Placa Mãe B650M-A MSI PRO Wi-Fi",
            "description": "Placa Mãe B650M-A MSI PRO Wi-Fi, AMD AM5, mATX, DDR5 - PRO B650M-A WIFI",
            "url": "https://www.kabum.com.br/produto/392613/placa-mae-b650m-a-msi-pro-wi-fi-amd-am5-matx-ddr5-pro-b650m-a-wifi",
            "value": 1999.99
        },
        "gpus": [
            {
                "id": 510,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 511,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 515,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 513,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 514,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 509,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 508,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 503,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 512,
                "title": "Monitor Gamer LG UltraGear 32 LED",
                "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
                "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
                "value": 1899.99
            }
        ],
        "keyboard": {
            "id": 505,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 507,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 10069.911
    }
]

Podemos ver que existem três setups com os seguintes ids: 474, 488 e 502. Vamos usar a função deleteSetup() para deletar o setup com id 474 fazendo uma requisição DELETE por meio do postman.

Após isso, vamos usar GET de novo para ver como ficou o banco de dados:

[
    {
        "id": 488,
        "cpu": {
            "id": 490,
            "title": "Processador AMD Ryzen 5 5600X",
            "description": "Processador AMD Ryzen 5 5600X, 3.7GHz (4.6GHz Max Turbo), Cache 35MB, 6 Núcleos, 12 Threads, AM4 - 100-100000065BOX",
            "url": "https://www.kabum.com.br/produto/129451/processador-amd-ryzen-5-5600x-3-7ghz-4-6ghz-max-turbo-cache-35mb-6-nucleos-12-threads-am4-100-100000065box",
            "value": 1199.99
        },
        "motherboard": {
            "id": 492,
            "title": "Placa-Mãe Gigabyte B550M",
            "description": "Placa-Mãe Gigabyte B550M Aorus Elite, AMD AM4, Micro ATX, DDR4",
            "url": "https://www.kabum.com.br/produto/114781/placa-mae-gigabyte-b550m-aorus-elite-amd-am4-micro-atx-ddr4",
            "value": 849.99
        },
        "gpus": [
            {
                "id": 496,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 497,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 501,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 499,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 500,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 495,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 494,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 489,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 498,
                "title": "Monitor Gamer LG UltraGear 32 LED",
                "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
                "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
                "value": 1899.99
            }
        ],
        "keyboard": {
            "id": 491,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 493,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 8219.911
    },
    {
        "id": 502,
        "cpu": {
            "id": 504,
            "title": "Processador AMD Ryzen 7 5800X",
            "description": "Processador AMD Ryzen 7 5800X, 3.8GHz (4.7GHz Max Turbo), Cache 36MB, Octa Core, 16 Threads, AM4 - 100-100000063WOF",
            "url": "https://www.kabum.com.br/produto/129459/processador-amd-ryzen-7-5800x-3-8ghz-4-7ghz-max-turbo-cache-36mb-octa-core-16-threads-am4-100-100000063wof",
            "value": 1899.99
        },
        "motherboard": {
            "id": 506,
            "title": "Placa Mãe B650M-A MSI PRO Wi-Fi",
            "description": "Placa Mãe B650M-A MSI PRO Wi-Fi, AMD AM5, mATX, DDR5 - PRO B650M-A WIFI",
            "url": "https://www.kabum.com.br/produto/392613/placa-mae-b650m-a-msi-pro-wi-fi-amd-am5-matx-ddr5-pro-b650m-a-wifi",
            "value": 1999.99
        },
        "gpus": [
            {
                "id": 510,
                "title": "GTX 1660 Super",
                "description": "Placa de Vídeo GTX 1660 Super Twin Fan Zotac Gaming NVIDIA GeForce, 6GB, GDDR6 - ZT-T16620F-10L",
                "url": "https://www.kabum.com.br/produto/110396/placa-de-video-gtx-1660-super-twin-fan-zotac-gaming-nvidia-geforce-6gb-gddr6-zt-t16620f-10l",
                "value": 1299.99
            }
        ],
        "hds": [
            {
                "id": 511,
                "title": "HD Seagate 2TB",
                "description": "HD Seagate 2TB BarraCuda, 3.5', SATA - ST2000DM008",
                "url": "https://www.kabum.com.br/produto/100916/hd-seagate-2tb-barracuda-3-5-sata-st2000dm008",
                "value": 299.99
            }
        ],
        "ssds": [
            {
                "id": 515,
                "title": "SSD 512 GB",
                "description": "SSD 512 GB XPG S41 TUF, M.2 PCIe, Leitura: 3500MB/s e Gravação: 2400MB/s - AGAMMIXS41-512G-C",
                "url": "https://www.kabum.com.br/produto/127700/ssd-512-gb-xpg-s41-tuf-m-2-pcie-leitura-3500mb-s-e-gravacao-2400mb-s-agammixs41-512g-c",
                "value": 409.99
            }
        ],
        "rams": [
            {
                "id": 513,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            },
            {
                "id": 514,
                "title": "Memoria, Ram 8, Gb",
                "description": "Memoria, Ram 8, Gb, Xpg, D60g, 3200 Mhz, Rgb, Ddr4, Ax4u320088g16ast60.",
                "url": "https://www.kabum.com.br/produto/219915/memoria-ram-8-gb-xpg-d60g-3200-mhz-rgb-ddr4-ax4u320088g16ast60-",
                "value": 390.06
            }
        ],
        "fans": [
            {
                "id": 509,
                "title": "Cooler Fan Rise Mode Energy",
                "description": "Cooler Fan Rise Mode Energy, 3 Unidades, 120mm, ARGB, Preto - FN-02-RGB-5V",
                "url": "https://www.kabum.com.br/produto/153647/cooler-fan-rise-mode-energy-3-unidades-120mm-argb-preto-fn-02-rgb-5v",
                "value": 129.99
            }
        ],
        "powerSupply": {
            "id": 508,
            "title": "Fonte Corsair CV550",
            "description": "Fonte Corsair CV550, 550W, 80 Plus Bronze - CP-9020210-BR",
            "url": "https://www.kabum.com.br/produto/108257/fonte-corsair-cv550-550w-80-plus-bronze-cp-9020210-br",
            "value": 359.99
        },
        "cabinet": {
            "id": 503,
            "title": "Gabinete Gamer Corsair Carbide Series Spec Delta",
            "description": "Gabinete Gamer Corsair Carbide Series Spec Delta, Mid-Tower, RGB, Lateral em Vidro Temperado, Preto, CC-9011166-WW",
            "url": "https://www.kabum.com.br/produto/100004/gabinete-gamer-corsair-carbide-series-spec-delta-mid-tower-rgb-lateral-em-vidro-temperado-preto-cc-9011166-ww",
            "value": 399.99
        },
        "monitors": [
            {
                "id": 512,
                "title": "Monitor Gamer LG UltraGear 32 LED",
                "description": "Monitor Gamer LG UltraGear 32 LED, 165 Hz, QHD, 1ms, HDMI/DisplayPort, 95% sRGB, FreeSync Premium, HDR 10, VESA, Preto - 32GN600-B",
                "url": "https://www.kabum.com.br/produto/364835/monitor-gamer-lg-ultragear-32-led-165-hz-qhd-1ms-hdmi-displayport-95-srgb-freesync-premium-hdr-10-vesa-preto-32gn600-b",
                "value": 1899.99
            }
        ],
        "keyboard": {
            "id": 505,
            "title": "Teclado Mecânico Gamer HyperX Alloy Origins Core",
            "description": "Teclado Mecânico Gamer HyperX Alloy Origins Core, RGB, Switch HyperX Red, ABNT2 - HX-KB7RDX-BR",
            "url": "https://www.kabum.com.br/produto/105009/teclado-mecanico-gamer-hyperx-alloy-origins-core-rgb-switch-hyperx-red-abnt2-hx-kb7rdx-br",
            "value": 419.99
        },
        "mouse": {
            "id": 507,
            "title": "Mouse Gamer HyperX Pulsefire Surge",
            "description": "Mouse Gamer HyperX Pulsefire Surge RGB 16000 DPI - HX-MC002B",
            "url": "https://www.kabum.com.br/produto/95566/mouse-gamer-hyperx-pulsefire-surge-rgb-16000-dpi-hx-mc002b",
            "value": 169.89
        },
        "totalValue": 10069.911
    }
]

A nossa função funcionou :), o setup foi deletado. Por fim, usaremos a função deleteAllSetups() para deletar todos os setups e usar GET de novo para obtermos a seguinte resposta:

[]

Recebemos um JSON vazio, nossa outra função também funcionou! E assim terminamos nosso post de hoje.

Próximo post

No próximo post vamos finalizar a primeira parte dessa nossa API simples melhorando sua segurança, impedindo que os ids dos setups e das peças sejam sobrescritos, por exemplo.

Repositório no github:

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

PCHunter API

View on GitHub

Post anterior:

Criando uma API com Spring Boot e Kotlin — parte 2

Ronaldo Costa de Freitas ・ Nov 6 ・ 9 min read

#kotlin #spring #api

Melhorando a arquitetura da Pokédex

Ronaldo Costa de Freitas — Fri, 11 Nov 2022 02:38:26 +0000

Nesse post nós vamos usar o Koin para delegar a injeção das dependências da nossa aplicação, como Retrofit, API service, repositórios e ViewModels e implementar a arquitetura limpa no nosso projeto com interfaces e use cases.

Clean Architecture

A Clean Architecture (Arquitetura Limpa) é, como o próprio nome diz, uma arquitetura de desenvolvimento de software que visa focar no domínio da aplicação; sendo os drivers, frameworks e libraries apenas detalhes da aplicação. O objetivo é o principio da responsabilidade única, separando o interesse de cada módulo e mantendo as regras de negócio sem conhecer qualquer detalhe sobre o mundo exterior; assim, eles podem ser testados sem dependência de qualquer elemento externo.

De forma resumida, o nosso sistema será dividido em três camadas:

Presentation (módulo Android): responsável pela interface do aplicativo e a exibição dos dados recebidos do domínio.
Domain (módulo Kotlin): responsável pelas entidades e as regras de domínio específicas do projeto. Esse módulo deve ser totalmente independente da plataforma Android.
Infrastructure (módulo Android): responsável pelo banco de dados, acesso a internet e outros “detalhes” da aplicação.

Na camada presentation temos as Activities e Fragments, não deve haver lógica dentro delas que não seja a lógica de UI.

Por outro lado, na camada domain estão as entidades, interfaces dos repositories e use cases, é aqui que fica nossa lógica de negócios e serve como ponte entre a camada presentation e a infrastructure.

Por fim, na camada infrastructure estão os dados necessários para a nossa aplicação (chamadas à uma API Rest no nosso caso) que são acessados a partir dos repositories definidos na camada domain.

Então o que muda? Bem, já estávamos fazendo algo parecido com isso, mas nossos repositories não estão separados em contratos (interfaces) e implementações e nem estamos usando use cases para acessar as implementações dos repositories e mandar os dados para a camada presentation.

Para unir todos esses módulos e fazer a arquitetura funcionar, vamos usar o framework Koin para aplicar a Dependency Inversion Principle (Princípio da Inversão da dependência), o D do SOLID. Esse princípio diz que módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender da abstração e abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.

Ou seja, em várias partes do nosso código, o repository estava responsável por criar uma instância de um service, uma ViewModel estava responsável por criar uma instância de um *repository, isso muda agora.

Obs: explicação da Clean Architecture retirada do excelente artigo do Marcello Galhardo.

Usando o `Koin`

Koin é um framework leve de injeção de dependência totalmente escrito em Kotlin, sendo bem fácil de aprender e usar. Para usá-lo, precisamos entender as suas terminologias:

module: cria um módulo em Koin que pode ser usado para prover todas as dependências.
single: cria um singleton que pode ser usado em todo o app como uma uma instância singular.
factory: provê uma definição bean, a qual vai criar uma nova instância cada vez que ela é injetada.
get(): é usada no construtor da classe que provê a dependência necessária.

Agora vamos adicionar o Koin ao nosso projeto por meio do arquivo build.gradle:

def koinVersion = "3.2.2"

dependencies {
    ...

  // Koin
  implementation "io.insert-koin:koin-android:$koinVersion"
  implementation "io.insert-koin:koin-android-compat:$koinVersion"
  implementation "io.insert-koin:koin-androidx-workmanager:$koinVersion"
  implementation "io.insert-koin:koin-androidx-navigation:$koinVersion" 

    ...
}

Para começarmos a usar o Koin no nosso projeto, primeiro de tudo, precisamos criar uma interface para nosso PokemonRepository, fazemos isso para obedecer aos princípios da arquitetura limpa.

package br.com.pokedex.domain.repository

import br.com.pokedex.domain.model.SinglePokemon

interface PokemonRepository {

    suspend fun getSinglePokemon(id: Int): SinglePokemon
}

Classe PokemonRepository vai ser renomeada para PokemonRepositoryImpl e modificada:

package br.com.pokedex.data.repository

import br.com.pokedex.data.api.PokemonApi
import br.com.pokedex.data.mapper.toModel
import br.com.pokedex.domain.repository.PokemonRepository

class PokemonRepositoryImpl(private val api: PokemonApi) : PokemonRepository {

    override suspend fun getSinglePokemon(id: Int) = api.getSinglePokemon(id).toModel()
}

Note que removemos a criação do service aqui, fizemos isso pois o Koin ficará responsável por injetar essa dependência, assim, aplicando o Princípio da Inversão da dependência.

Partiremos para a criação do use case que servirá de ponte entre o repository e a ViewModel. No momento ele será bem simples, terá apenas uma função execute() que acessará o PokemonRepository e retornará um SinglePokemon:

package br.com.pokedex.domain.interactor

import br.com.pokedex.domain.model.SinglePokemon
import br.com.pokedex.domain.repository.PokemonRepository

class GetSinglePokemonUseCase(private val repository: PokemonRepository) {

    suspend fun execute(id: Int) : SinglePokemon {
        return repository.getSinglePokemon(id)
    }
}

Modificação em PokedexViewModel:

package br.com.pokedex.presentation

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import br.com.pokedex.domain.interactor.GetSinglePokemonUseCase
import br.com.pokedex.domain.model.SinglePokemon
import br.com.pokedex.domain.repository.PokemonRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

private const val MIN_POKEMON_ID = 1
private const val MAX_POKEMON_ID = 151

class PokedexViewModel(private val useCase: GetSinglePokemonUseCase) : ViewModel() {

    private val _pokemon = MutableLiveData<List<SinglePokemon>>()
    val pokemon: LiveData<List<SinglePokemon>>
        get() = _pokemon

    fun getPokemon() {
        viewModelScope.launch(Dispatchers.IO) {
            val data = mutableListOf<SinglePokemon>()

            for (i in MIN_POKEMON_ID..MAX_POKEMON_ID) {
                data.add(useCase.execute(i))
            }

            withContext(Dispatchers.Main) {
                _pokemon.postValue(data.toList())
            }
        }
    }

}

Pronto, vamos começar a usar efetivamente o Koin. Inicialmente criaremos um package chamado di(abreviação para dependency injection), é nele que vamos construir nossos arquivos de injeção de dependências. Após isso, criamos o arquivo InfrastructureModule.kt, e vamos criar algumas funções que provêem instâncias de dependências importantes nele: Retrofit e PokemonApi:

package br.com.pokedex.di

import br.com.pokedex.BuildConfig
import br.com.pokedex.data.api.PokemonApi
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

private fun providePokemonApi(retrofit: Retrofit): PokemonApi {
    return retrofit.create(PokemonApi::class.java)
}

private fun provideRetrofit(): Retrofit {
    return Retrofit.Builder().run {
        addConverterFactory(GsonConverterFactory.create())
        baseUrl(BuildConfig.POKE_API)
        build()
    }
}

Repare que em provideRetrofit() nós referenciamos uma string POKE_API, trata-se da url base da PokéAPI, fazemos isso para separá-la da lógica de negócios, nós a colocamos no arquivo build.gradle da seguinte forma:

def POKE_API = "POKE_API"
def URL_BASE_POKE_API = "\"https://pokeapi.co/api/v2/\""

android {
        ...
    buildTypes {

        debug {
            applicationIdSuffix ".dev"
            debuggable true
            buildConfigField "String", POKE_API, URL_BASE_POKE_API
        }

    }
    ...
}

Neste momento em que já temos esses providers, podemos construir o módulo que irá prover essas dependências para a aplicação, vamos chamá-lo de InfrastructureModule, ele será uma coleção de dependências em que a instância de cada uma será retornada usando a função factory e depois injetada quando necessário for:

package br.com.pokedex.di

import br.com.pokedex.BuildConfig
import br.com.pokedex.data.api.PokemonApi
import br.com.pokedex.data.repository.PokemonRepositoryImpl
import br.com.pokedex.domain.repository.PokemonRepository
import org.koin.dsl.module
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

fun infrastructureModule() = module {
    factory { provideRetrofit() }
    factory { providePokemonApi(get()) }
    factory<PokemonRepository> { PokemonRepositoryImpl(get()) }
}

private fun providePokemonApi(retrofit: Retrofit): PokemonApi {
    return retrofit.create(PokemonApi::class.java)
}

private fun provideRetrofit(): Retrofit {
    return Retrofit.Builder().run {
        addConverterFactory(GsonConverterFactory.create())
        baseUrl(BuildConfig.POKE_API)
        build()
    }
}

Note que programamos o módulo de tal forma que quando uma instância de PokemonRepository for requisitada, retornaremos uma instância de PokemonRepositoryImpl, fazendo com que referenciemos apenas a abstração no código e não a implementação.

Faltam apenas duas dependências: GetSinglePokemonUseCase e PokedexViewModel, procedemos com o desenvolvimento de outros dois arquivos: DomainModule.kt, para o use case, e PresentationModule.kt, para a ViewModel:

package br.com.pokedex.di

import br.com.pokedex.domain.interactor.GetSinglePokemonUseCase
import org.koin.dsl.module

fun domainModule() = module {
    factory { GetSinglePokemonUseCase(get()) }
}

package br.com.pokedex.di

import br.com.pokedex.presentation.PokedexViewModel
import org.koin.androidx.viewmodel.dsl.viewModel
import org.koin.dsl.module

fun presentationModule() = module {
    viewModel { PokedexViewModel(get()) }
}

Sendo assim, já temos os três módulos prontos para serem injetados. Para realizar essa injeção, construiremos uma classe que será a raiz do nosso projeto, a Pokedex:

package br.com.pokedex

import android.app.Application

class Pokedex : Application() {}

Ela é subclasse de Application porque ela é a classe base do app que contém todos os outros componentes, como activities e services, ela é instanciada antes de qualquer outra classe quando o processo para a nossa aplicação é criado. E não podemos esquecer de adicioná-la ao AndroidManifest:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    ...

    <application
        android:name=".Pokedex"
        ...
        >

        ...

    </application>

</manifest>

Agora vamos criar o arquivo que irá lidar com todas essas dependências, o Injector.kt, nele nós desenvolvemos uma extension function de Application chamada inject() que inicia o Koin com todas as dependências necessárias:

package br.com.pokedex.di

import android.app.Application
import org.koin.android.ext.koin.androidContext
import org.koin.android.ext.koin.androidLogger
import org.koin.core.context.startKoin

fun Application.inject() {
    startKoin {
        androidLogger()
        androidContext(this@inject)
        modules(getModules())
    }
}

fun getModules() = listOf(
    infrastructureModule(),
    domainModule(),
    presentationModule()
)

Além de usarmos a função startKoin, também usamos androidLogger(), que fornece uma API simples para realizar logs relacionados ao Koin, androidContext(), o qual adiciona uma instância de Context para o contêiner do Koin, modules(), para carregar as definições dos módulos, e getModules(), que retorna todos os módulos que nós criamos.

Pronto, já podemos inserir essea função na nossa classe Application dando um override na função onCreate():

package br.com.pokedex

import android.app.Application
import br.com.pokedex.di.inject

class Pokedex : Application() {

    override fun onCreate() {
        super.onCreate()
        inject()
    }
}

Sendo assim, nosso projeto ficou estruturado dessa forma:

Após rodarmos o app, vamos perceber que nada mudou visualmente, mas sabemos que nosso projeto está bem melhor estruturado e desacoplado, obedecendo aos princípios da Arquitetura Limpa!

Próximos posts

Nos próximos posts vamos melhorar a performance da nossa Pokédex usando a biblioteca Paging e a Flow API, além de deixá-las mais bonita, é claro.

Repositório no github:

ronaldocoding / pokedex

A simple Pokédex

Pokédex

A simple Pokédex

View on GitHub

Post anterior:

Mostrando os Pokémon com Coil em Android

Ronaldo Costa de Freitas ・ Nov 3 ・ 11 min read

#kotlin #android #pokemon #recyclerview

Próximo post:

Melhorando a performance da Pokédex com Paging 3 e Flow API

Ronaldo Costa de Freitas ・ Nov 17 ・ 23 min read

#kotlin #android #paging #flow

Estruturas de controle em Kotlin

Ronaldo Costa de Freitas — Tue, 08 Nov 2022 03:10:30 +0000

Kotlin, assim como outras linguagens de programação de alto nível, tem estruturas de controle básicas como while, for e if. No post de hoje vamos conhecê-las e aprender sobre a estrutura substituta do switch, o when.

Estrutura `while`

Essa estrutura de controle é bem similar ao Java, sendo praticamente idêntica. Além de while, também temos sua irmã, a estrutura do-while. Como são muito parecidas com as em Java, vamos analisar brevemente dois códigos sobre elas.

A estrutura while tem o seguinte formato:

fun main() {
    var palavra = ""

    while(palavra.length <= 10) {
        palavra += 'z'
    }
}

Ou seja, o programa irá executar repetidamente uma ou mais linhas de código enquanto uma condição for atendida. No caso acima, o loop irá ocorrer até que o tamanho da string seja menor ou igual a 10, o loop irá cessar quando a palavra alcançar o tamanho 11.

Por outro lado, a estrutura do-while tem o seguinte formato:

fun main() {
    var palavra = ""

    do {
        palavra += 'z'
    } while(palavra.length != 0)
}

Enquanto na estrutura while, não temos a garantia de que o loop será executado, na do-while sabemos que ele ocorre ao menos uma vez. Como podemos ver acima, primeiro incrementamos a palavra em um caractere e depois comparamos se seu tamanho é diferente de zero, o que ocasiona em um loop infinito, visto que seu tamanho sempre será diferente de zero. No entanto, se usássemos while, isso não teria ocorrido, já que a comparação teria sido feita antes do incremento.

Estrutura `for`

Diferentemente de while e do-while, a estrutura de controle for em Kotlin é diferente da em Java e tem várias formas de uso específico, como iterar sobre um intervalo ou uma coleção.

Iterando sobre intervalos

Se quisermos imprimir todos os números naturais (incluindo o zero) até um certo outro número natural, excluindo ele mesmo, como podemos fazer em Kotlin? Podemos usar o operador .. entre zero e o determinado número menos 1. Esse operador indica que estamos usando um intervalo entre dois valores:

import kotlin.random.Random

fun main() {
    val numeroRandom = Random.nextInt(0, 100)

    for(i in 0 .. numeroRandom-1) {
        println(i)
    }
}

No código acima, primeiro obtemos um número pseudo-randômico entre 0 e 100 e depois usamos for com o operador .. pra indicar que iremos iterar sobre esse intervalo, além de utilizarmos o operador in que garante que o valor de i esteja no intervalo especificado. Podemos deixar esse código mais idiomático usando a função until, que simula esse comportamento de 0 (intervalo) valor - 1:

import kotlin.random.Random

fun main() {
    val numeroRandom = Random.nextInt(0, 100)

    for(i in 0 until numeroRandom) {
        println(i)
    }
}

Também podemos iterar sobre intervalos utilizando outros funções como downTo e step. Se queremos imprimir todos os número pares entre 100 e 0, podemos fazer o seguinte:

fun main() {

    for(i in 100 downTo 0 step 2) {
        println(i)
    }
}

A função downTo indica que o intervalo é de trás para frente e a função step faz com que dois números sejam pulados a cada iteração, assim, imprimindo apenas os números pares. Essa função está presente em todos esses fors que envolvem intervalo, quando não a utilizamos explicitamente ela tem o comportamento padrão de pular um número de cada vez, ou seja step 1.

Iterando sobre coleções

Assim como em Java, também podemos iterar sobre coleções (estruturas de dados de alto nível) em Kotlin, fazendo um trabalho semelhante ao forEach(). Vamos fazer um programa que adiciona os quadrados dos números de uma lista de inteiros em outra:

fun main() {

  val numeros = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  val numerosQuadrados = mutableListOf<Int>()

  for(numero in numeros)
      numerosQuadrados.add(numero * numero)

  println(numerosQuadrados)
}

Note que também usamos o operador in para iterar sobre a lista, basicamente desempacotando cada número da lista em uma variável chamada numero. Também podemos usar o in para iterar sobre caracteres:

fun main() {

    val palavra = "Palavra"
    var palavraEmMaiusculas = ""

    for(letra in palavra) {
        palavraEmMaiusculas += letra.toUpperCase()
    }

    println(palavraEmMaiusculas)
}

No código acima, nós iteramos sobre uma string e adicionamos cada caractere dela como uma letra maiúscula em outra string.

Estrutura `if`

De forma semelhante a while, a estrutura de controla if é praticamente idêntica a sua equivalente em Java, o que muda aqui é, conforme estudamos no último post, em Kotlin if não é um statement, mas sim uma expressão, ou seja, ela tem um retorno. Vamos analisar a função abaixo:

fun ePar(numero: Int): Boolean {
    return if(numero % 2 == 0) {
        true
    } else {
        false
    }
}

O que fazemos aqui é retorna o resultado da expressão if que compara se um número inteiro, quando divido por 2, deixa resto zero. Também podemos fazer uma estrutura if aninhada em Kotlin, usando else if:

fun compara(A: Int, B: Int): String {
    return if(A > B) {
        "$A é maior que $B"
    } else if(A < B) {
        "$A é menor que $B"
    } else {
        "$A e $B são iguais"
    }
}

Estrutura `when`

A estrutura when é uma substituta para o if em alguns casos, ela funciona como um switch em Java e assim como o if ela pode ter ramificações e retornar valores. Vamos reescrever os dois últimos códigos usando when:

fun eParWhen(numero: Int) =
    when {
        numero % 2 == 0 -> {
            true
        }
        else -> false
    }

fun comparaWhen(A: Int, B: Int) =
    when {
        A > B -> "$A é maior que $B"
        A < B -> "$A é menor que $B"
        else -> "$A e $B são iguais"
    }

A estrutura when é muito útil para se lidar com Enums, vamos analisar um exemplo do Kotlin in Action. Primeiro vamos criar a enum Color que irá representar cores no formato RGB:

enum class Color(
    val red: Int, val green: Int, val blue: Int
) {
    RED(255, 0, 0), ORANGE(255, 165, 0), YELLOW(255, 255, 0), GREEN(0, 255, 0),
    BLUE(0, 0, 255), INDIGO(75, 0, 130), VIOLET(238, 130, 238), WHITE(255, 255, 255);

    fun rgb() = (red * 256 + green) * 256 + blue
}

Como pode ver, além de constantes, uma enum em Kotlin pode ter propriedades e funções, em adição a isso esse exemplo também mostra o único caso de uso de ponto e vírgula em Kotlin: para separar as constantes de uma enum das suas funções.

As constantes que foram definidas representam certas cores para certos valores das três propriedades e a função rgb() retorna a ordem dessa cor na gama de cores que podem ser representadas no formato RGB.

Por exemplo, se usarmos essa função para a cor BLUE, veremos que ela é a cor de número 255, agora se usarmos para a cor WHITE, podemos observar que ela é a cor de número 16777215, ou seja, a última cor, já que podem ser representadas pouco mais de 16 milhões de cores em RGB.

Agora vamos usar when para facilitar a nossa vida: caso precisássemos fazer uma função que retorna a "temperatura” de um certa cor, como faríamos ser usar vários ifs? Simples:

fun obtemTemperaturaCor(color: Color) =
    when(color) {
            Color.RED, Color.ORANGE, Color.YELLOW -> "Quente"
            Color.GREEN -> "Neutra"
            Color.BLUE, Color.INDIGO, Color.INDIGO, Color.VIOLET, Color.WHITE -> "Fria" 
    }

Veja só que beleza: podemos até combinar múltiplos valores em uma única ramificação, não é incrível 🤩?

Sendo assim, podemos observar que a forma dessa estrutura é a seguinte:

when (valorOpcional) {
    condicao1 -> {
        // faz alguma coisa
    }
    condicao2 -> {
        //faz outra coisa
    }
    else -> { // else opcional
        // faz algo
    }
}

Diferentemente do switch, não somos obrigados a passar o valor que será comparado entre parênteses e nem escrever declarações break ao fim de cada ramificação.

Próximos posts

Nos próximos posts vamos nos aprofundar no estudo de funções e estudar classes, objetos e interfaces. Obrigado pela atenção, até a próxima!

Post anterior:

Introdução ao Kotlin

Ronaldo Costa de Freitas ・ Nov 2 ・ 6 min read

#kotlin #java #jetbrains #oop

Próximo post:

Interfaces em Kotlin

Ronaldo Costa de Freitas ・ Nov 15 ・ 3 min read

#kotlin #java #oop

Criando uma API com Spring Boot e Kotlin — parte 2

Ronaldo Costa de Freitas — Sun, 06 Nov 2022 03:18:42 +0000

Seguindo nossa série de posts sobre como construir uma API simples para servir de back-end para um app de construção de setups de PC que criamos há algum tempo, hoje vamos escrever nossas classes models, configurar nosso banco de dados e implementar as requisições GET e POST do nosso serviço.

Criando classes models

Para representar um Setup com todas as suas peças vamos precisar de duas entidades: Part, para representar uma peça, e Setup, para representar um Setup.

Código da classe Part:

package br.com.pchunter.model

import com.fasterxml.jackson.annotation.JsonProperty
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.Id

@Entity
data class Part(
    @Id
    @GeneratedValue
    @JsonProperty(value = "id", access = JsonProperty.Access.READ_ONLY)
    val id: Long,
    val title: String,
    val description: String,
    val url: String,
    val value: Float
)

É uma classe bem simples composta por propriedades para representar seu título, descrição, url e valor. Também temos a propriedade id que é autogerada. A notação de mesmo nome indica que propriedade é um identificador no banco de dados, GeneratedValue significa que seu valor será gerado ao ser criada uma instância dessa entidade, JsonProperty, em resumo, protege a propriedade identificadora de ser alterada. Além disso, a notação Entity indica que essa classe é a representação de uma entidade do banco de dados.

Código da classe Setup:

package br.com.pchunter.model

import com.fasterxml.jackson.annotation.JsonProperty
import javax.persistence.*

@Entity
data class Setup(
    @Id
    @GeneratedValue
    @JsonProperty(value = "id", access = JsonProperty.Access.READ_ONLY)
    val id: Long,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val cpu: Part,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val motherboard: Part,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val gpus: List<Part>,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val hds: List<Part>,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val ssds: List<Part>,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val rams: List<Part>,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val fans: List<Part>,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val powerSupply: Part,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val cabinet: Part,
    @OneToMany(cascade = [CascadeType.PERSIST])
    val monitors: List<Part>,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val keyboard: Part,
    @OneToOne(cascade = [CascadeType.PERSIST])
    val mouse: Part
) {
    val totalValue: Float
        get() {
            var acm = 0.0f
            acm += cpu.value +
                    motherboard.value +
                    powerSupply.value +
                    cabinet.value +
                    keyboard.value +
                    mouse.value
            gpus.forEach { gpu ->
                acm += gpu.value
            }
            hds.forEach { hd ->
                acm += hd.value
            }
            ssds.forEach { ssd ->
                acm += ssd.value
            }
            rams.forEach { ram ->
                acm += ram.value
            }
            fans.forEach { fan ->
                acm += fan.value
            }
            monitors.forEach { monitor ->
                acm += monitor.value
            }
            return acm
        }
}

A classe Setup é composta por várias classes Part, cada uma representando uma peça. Temos também a propriedade totalValue que retorna o valor total do setup, sendo composto pela soma dos valores de todas as peças.

Em relação às anotações, temos algumas novas aqui:

OneToOne: indica que a relação entre a entidade Setup e essa outra entidade específica é de 1:1, ou seja, um setup tem apenas uma entidade dessa.
OneToMany: indica que a relação entre a entidade Setup e essa outra entidade é de 1:N, ou seja, um setup pode ter várias dessa entidade.
cascade = [CascadeType.PERSIST]: significa que a operação de persistência será persistida de pai para filho, ou seja, sempre que um setup for salvo, todas as suas peças também serão.

Pronto: já temos nossas entidades da camada model.

Configurando o banco de dados

A configuração do nosso banco de dados será bem simples, primeiro nos vamos renomear o arquivo application.properties para application.yaml e escrever o seguinte:

spring:
  datasource:
    url: jdbc:hsqldb:file:database/main/db
    username: ronaldo
    driver-class-name: org.hsqldb.jdbc.JDBCDriver
  jpa:
    properties.hibernate.dialect: org.hibernate.dialect.HSQLDialect
    hibernate.ddl-auto: update

Aqui temos uma sopa de letrinhas, vamos lá:

spring:datasource:url: é o endereço do banco de dados que será utilizado
spring:datasource:username: é o nome do usuário do banco de dados
spring:datasource:driver-class-name: é o driver que permite a comunicação entre nossa aplicação e o HSQLDB
jpa:properties.hibernate.dialect: indica que o SQL vai reconhecer o HSQLDB
jpa:properties.hibernate.dialect: indica ao Hibernate que ele deve gerar as tabelas de acordo com as entidades do ORM

Para finalizar a configuração do banco, vamos viabilizar o nosso CRUD, para isso vamos criar uma interface que estenda de CrudRepository do Spring Data:

package br.com.pchunter.repository

import br.com.pchunter.model.Setup
import org.springframework.data.repository.CrudRepository

interface SetupRepository : CrudRepository<Setup, Long> {}

Parece até mentira, mas é só isso mesmo: delegamos toda a tarefa de persistir os dados, criar um repositório, injetar a dependência para o Spring e já temos acesso a funções como findAll() e save() que logo usaremos.

Requisições GET e POST

Agora basta implementar as funções GET e POST para finalizar nosso trabalho de hoje, para isso vamos criar uma classe controller. Uma classe Controller em Spring é uma classe responsável por lidar com requisições web.

Segue nossa SetupController:

package br.com.pchunter.controller

import br.com.pchunter.model.Setup
import br.com.pchunter.repository.SetupRepository
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
@RequestMapping("setup")
class SetupController {

    @Autowired
    lateinit var repository: SetupRepository

    @GetMapping
    fun getAllSetups(): List<Setup> = repository.findAll().toList()

    @PostMapping
    fun addSetup(@RequestBody setup: Setup) = repository.save(setup)
}

Logo no início usamos duas novas notações: @RestController, significa que nossa classe é um controller que atende à uma API REST, @RequestMapping, indica qual o caminho da url que esse controller está mapeando.

Depois nós delegamos a injeção da dependência do nosso repositório para o Spring por meio do @Autowired. Repare que a propriedade é uma lateinit var, ou seja, ela será inicializada no futuro.

Por fim, finalmente temos a implementação dos nossos métodos GET e POST.

Nosso método GET é bem simples, ele retorna todos os Setup salvos no nosso banco de dados por meio do método findAll(), depois convertemos o resultado para o tipo List<Setup>. Como é um método GET, usamos a notação @GetMapping, indicando que o método mapeia esse tipo de requisição.

Quanto ao nosso método POST, ele recebe um Setup por meio do corpo (*body*) da requisição, por isso usamos a notação @RequestBody para mapear a propriedade, é salvo e retornamos esse Setup salvo no banco de dados usando a função save(). Do mesmo modo, usamos a notação @PostMapping, para indicar que o método mapeia uma requisição POST.

Agora sim, já podemos testar nossa API!

Testando a API

Para começar, vamos testar a função que mapeia a requisição POST. Mandamos esse seguinte JSON para a nossa API usando o Postman:

{
  "cpu": {
    "title": "Cpu",
    "description": "Cpu",
    "url": "cpu.com",
    "value": 879.0
  },
  "motherboard": {
    "title": "Motherboard",
    "description": "Motherboard",
    "url": "motherboard.com",
    "value": 765.0
  },
  "gpus": [
    {
      "title": "Gpu",
      "description": "Gpu",
      "url": "gpu.com",
      "value": 1600.9
    }
  ],
  "hds": [
    {
      "title": "Hd",
      "description": "Hd",
      "url": "hd.com",
      "value": 300.9
    }
  ],
  "ssds": [
    {
      "title": "Ssd",
      "description": "Ssd",
      "url": "ssd.com",
      "value": 350.99
    }
  ],
  "rams": [
    {
      "title": "Ram",
      "description": "Ram",
      "url": "ram.com",
      "value": 250.9
    }
  ],
  "fans": [
    {
      "title": "Fan",
      "description": "Fan",
      "url": "fan.com",
      "value": 125.99
    }
  ],
  "powerSupply": {
    "title": "PSU",
    "description": "PSU",
    "url": "psu.com",
    "value": 450.9
  },
  "cabinet": {
    "title": "Cabinet",
    "description": "Cabinett",
    "url": "cabinet.com",
    "value": 300.9
  },
  "monitors": [
    {
      "title": "Monitor",
      "description": "Monitor",
      "url": "monitor.com",
      "value": 1800.9
    }
  ],
  "keyboard": {
    "title": "Keyboard",
    "description": "Keyboard",
    "url": "keyboard.com",
    "value": 800.9
  },
  "mouse": {
    "title": "Mouse",
    "description": "Mouse",
    "url": "mouse.com",
    "value": 350.9
  }
}

E temos esse resultado:

{
    "id": 44,
    "cpu": {
        "id": 46,
        "title": "Cpu",
        "description": "Cpu",
        "url": "cpu.com",
        "value": 879.0
    },
    "motherboard": {
        "id": 48,
        "title": "Motherboard",
        "description": "Motherboard",
        "url": "motherboard.com",
        "value": 765.0
    },
    "gpus": [
        {
            "id": 52,
            "title": "Gpu",
            "description": "Gpu",
            "url": "gpu.com",
            "value": 1600.9
        }
    ],
    "hds": [
        {
            "id": 53,
            "title": "Hd",
            "description": "Hd",
            "url": "hd.com",
            "value": 300.9
        }
    ],
    "ssds": [
        {
            "id": 56,
            "title": "Ssd",
            "description": "Ssd",
            "url": "ssd.com",
            "value": 350.99
        }
    ],
    "rams": [
        {
            "id": 55,
            "title": "Ram",
            "description": "Ram",
            "url": "ram.com",
            "value": 250.9
        }
    ],
    "fans": [
        {
            "id": 51,
            "title": "Fan",
            "description": "Fan",
            "url": "fan.com",
            "value": 125.99
        }
    ],
    "powerSupply": {
        "id": 50,
        "title": "PSU",
        "description": "PSU",
        "url": "psu.com",
        "value": 450.9
    },
    "cabinet": {
        "id": 45,
        "title": "Cabinet",
        "description": "Cabinett",
        "url": "cabinet.com",
        "value": 300.9
    },
    "monitors": [
        {
            "id": 54,
            "title": "Monitor",
            "description": "Monitor",
            "url": "monitor.com",
            "value": 1800.9
        }
    ],
    "keyboard": {
        "id": 47,
        "title": "Keyboard",
        "description": "Keyboard",
        "url": "keyboard.com",
        "value": 800.9
    },
    "mouse": {
        "id": 49,
        "title": "Mouse",
        "description": "Mouse",
        "url": "mouse.com",
        "value": 350.9
    },
    "totalValue": 7978.1797
}

Repare que todos os IDs foram criados, para cada entidade, e também temos o valor total do Setup na chave-valor totalValue.

Vamos usar novamente essa requisição mandando esse json (praticamente igual ao anterior):

{
  "cpu": {
    "title": "Tpu",
    "description": "Cpu",
    "url": "cpu.com",
    "value": 879.0
  },
  "motherboard": {
    "title": "Motherboard",
    "description": "Motherboard",
    "url": "motherboard.com",
    "value": 765.0
  },
  "gpus": [
    {
      "title": "Gpu",
      "description": "Gpu",
      "url": "gpu.com",
      "value": 1600.9
    }
  ],
  "hds": [
    {
      "title": "Hd",
      "description": "Hd",
      "url": "hd.com",
      "value": 300.9
    }
  ],
  "ssds": [
    {
      "title": "Ssd",
      "description": "Ssd",
      "url": "ssd.com",
      "value": 350.99
    }
  ],
  "rams": [
    {
      "title": "Ram",
      "description": "Ram",
      "url": "ram.com",
      "value": 250.9
    }
  ],
  "fans": [
    {
      "title": "Fan",
      "description": "Fan",
      "url": "fan.com",
      "value": 125.99
    }
  ],
  "powerSupply": {
    "title": "PSU",
    "description": "PSU",
    "url": "psu.com",
    "value": 450.9
  },
  "cabinet": {
    "title": "Cabinet",
    "description": "Cabinett",
    "url": "cabinet.com",
    "value": 300.9
  },
  "monitors": [
    {
      "title": "Monitor",
      "description": "Monitor",
      "url": "monitor.com",
      "value": 1800.9
    }
  ],
  "keyboard": {
    "title": "Keyboard",
    "description": "Keyboard",
    "url": "keyboard.com",
    "value": 800.9
  },
  "mouse": {
    "title": "Mouse",
    "description": "Mouse",
    "url": "mouse.com",
    "value": 350.9
  }
}

E temos o seguinte resultado:

{
    "id": 70,
    "cpu": {
        "id": 72,
        "title": "Tpu",
        "description": "Cpu",
        "url": "cpu.com",
        "value": 879.0
    },
    "motherboard": {
        "id": 74,
        "title": "Motherboard",
        "description": "Motherboard",
        "url": "motherboard.com",
        "value": 765.0
    },
    "gpus": [
        {
            "id": 78,
            "title": "Gpu",
            "description": "Gpu",
            "url": "gpu.com",
            "value": 1600.9
        }
    ],
    "hds": [
        {
            "id": 79,
            "title": "Hd",
            "description": "Hd",
            "url": "hd.com",
            "value": 300.9
        }
    ],
    "ssds": [
        {
            "id": 82,
            "title": "Ssd",
            "description": "Ssd",
            "url": "ssd.com",
            "value": 350.99
        }
    ],
    "rams": [
        {
            "id": 81,
            "title": "Ram",
            "description": "Ram",
            "url": "ram.com",
            "value": 250.9
        }
    ],
    "fans": [
        {
            "id": 77,
            "title": "Fan",
            "description": "Fan",
            "url": "fan.com",
            "value": 125.99
        }
    ],
    "powerSupply": {
        "id": 76,
        "title": "PSU",
        "description": "PSU",
        "url": "psu.com",
        "value": 450.9
    },
    "cabinet": {
        "id": 71,
        "title": "Cabinet",
        "description": "Cabinett",
        "url": "cabinet.com",
        "value": 300.9
    },
    "monitors": [
        {
            "id": 80,
            "title": "Monitor",
            "description": "Monitor",
            "url": "monitor.com",
            "value": 1800.9
        }
    ],
    "keyboard": {
        "id": 73,
        "title": "Keyboard",
        "description": "Keyboard",
        "url": "keyboard.com",
        "value": 800.9
    },
    "mouse": {
        "id": 75,
        "title": "Mouse",
        "description": "Mouse",
        "url": "mouse.com",
        "value": 350.9
    },
    "totalValue": 7978.1797
}

E finalmente vamos usar a requisição GET:

[
    {
        "id": 44,
        "cpu": {
            "id": 46,
            "title": "Cpu",
            "description": "Cpu",
            "url": "cpu.com",
            "value": 879.0
        },
        "motherboard": {
            "id": 48,
            "title": "Motherboard",
            "description": "Motherboard",
            "url": "motherboard.com",
            "value": 765.0
        },
        "gpus": [
            {
                "id": 52,
                "title": "Gpu",
                "description": "Gpu",
                "url": "gpu.com",
                "value": 1600.9
            }
        ],
        "hds": [
            {
                "id": 53,
                "title": "Hd",
                "description": "Hd",
                "url": "hd.com",
                "value": 300.9
            }
        ],
        "ssds": [
            {
                "id": 56,
                "title": "Ssd",
                "description": "Ssd",
                "url": "ssd.com",
                "value": 350.99
            }
        ],
        "rams": [
            {
                "id": 55,
                "title": "Ram",
                "description": "Ram",
                "url": "ram.com",
                "value": 250.9
            }
        ],
        "fans": [
            {
                "id": 51,
                "title": "Fan",
                "description": "Fan",
                "url": "fan.com",
                "value": 125.99
            }
        ],
        "powerSupply": {
            "id": 50,
            "title": "PSU",
            "description": "PSU",
            "url": "psu.com",
            "value": 450.9
        },
        "cabinet": {
            "id": 45,
            "title": "Cabinet",
            "description": "Cabinett",
            "url": "cabinet.com",
            "value": 300.9
        },
        "monitors": [
            {
                "id": 54,
                "title": "Monitor",
                "description": "Monitor",
                "url": "monitor.com",
                "value": 1800.9
            }
        ],
        "keyboard": {
            "id": 47,
            "title": "Keyboard",
            "description": "Keyboard",
            "url": "keyboard.com",
            "value": 800.9
        },
        "mouse": {
            "id": 49,
            "title": "Mouse",
            "description": "Mouse",
            "url": "mouse.com",
            "value": 350.9
        },
        "totalValue": 7978.1797
    },
    {
        "id": 57,
        "cpu": {
            "id": 59,
            "title": "Tpu",
            "description": "Cpu",
            "url": "cpu.com",
            "value": 879.0
        },
        "motherboard": {
            "id": 61,
            "title": "Motherboard",
            "description": "Motherboard",
            "url": "motherboard.com",
            "value": 765.0
        },
        "gpus": [
            {
                "id": 65,
                "title": "Gpu",
                "description": "Gpu",
                "url": "gpu.com",
                "value": 1600.9
            }
        ],
        "hds": [
            {
                "id": 66,
                "title": "Hd",
                "description": "Hd",
                "url": "hd.com",
                "value": 300.9
            }
        ],
        "ssds": [
            {
                "id": 69,
                "title": "Ssd",
                "description": "Ssd",
                "url": "ssd.com",
                "value": 350.99
            }
        ],
        "rams": [
            {
                "id": 68,
                "title": "Ram",
                "description": "Ram",
                "url": "ram.com",
                "value": 250.9
            }
        ],
        "fans": [
            {
                "id": 64,
                "title": "Fan",
                "description": "Fan",
                "url": "fan.com",
                "value": 125.99
            }
        ],
        "powerSupply": {
            "id": 63,
            "title": "PSU",
            "description": "PSU",
            "url": "psu.com",
            "value": 450.9
        },
        "cabinet": {
            "id": 58,
            "title": "Cabinet",
            "description": "Cabinett",
            "url": "cabinet.com",
            "value": 300.9
        },
        "monitors": [
            {
                "id": 67,
                "title": "Monitor",
                "description": "Monitor",
                "url": "monitor.com",
                "value": 1800.9
            }
        ],
        "keyboard": {
            "id": 60,
            "title": "Keyboard",
            "description": "Keyboard",
            "url": "keyboard.com",
            "value": 800.9
        },
        "mouse": {
            "id": 62,
            "title": "Mouse",
            "description": "Mouse",
            "url": "mouse.com",
            "value": 350.9
        },
        "totalValue": 7978.1797
    },
    {
        "id": 70,
        "cpu": {
            "id": 72,
            "title": "Tpu",
            "description": "Cpu",
            "url": "cpu.com",
            "value": 879.0
        },
        "motherboard": {
            "id": 74,
            "title": "Motherboard",
            "description": "Motherboard",
            "url": "motherboard.com",
            "value": 765.0
        },
        "gpus": [
            {
                "id": 78,
                "title": "Gpu",
                "description": "Gpu",
                "url": "gpu.com",
                "value": 1600.9
            }
        ],
        "hds": [
            {
                "id": 79,
                "title": "Hd",
                "description": "Hd",
                "url": "hd.com",
                "value": 300.9
            }
        ],
        "ssds": [
            {
                "id": 82,
                "title": "Ssd",
                "description": "Ssd",
                "url": "ssd.com",
                "value": 350.99
            }
        ],
        "rams": [
            {
                "id": 81,
                "title": "Ram",
                "description": "Ram",
                "url": "ram.com",
                "value": 250.9
            }
        ],
        "fans": [
            {
                "id": 77,
                "title": "Fan",
                "description": "Fan",
                "url": "fan.com",
                "value": 125.99
            }
        ],
        "powerSupply": {
            "id": 76,
            "title": "PSU",
            "description": "PSU",
            "url": "psu.com",
            "value": 450.9
        },
        "cabinet": {
            "id": 71,
            "title": "Cabinet",
            "description": "Cabinett",
            "url": "cabinet.com",
            "value": 300.9
        },
        "monitors": [
            {
                "id": 80,
                "title": "Monitor",
                "description": "Monitor",
                "url": "monitor.com",
                "value": 1800.9
            }
        ],
        "keyboard": {
            "id": 73,
            "title": "Keyboard",
            "description": "Keyboard",
            "url": "keyboard.com",
            "value": 800.9
        },
        "mouse": {
            "id": 75,
            "title": "Mouse",
            "description": "Mouse",
            "url": "mouse.com",
            "value": 350.9
        },
        "totalValue": 7978.1797
    }
]

E assim, os dois setups criados foram retornados com sucesso!

Próximos posts

Nossa API ainda tem muito o que melhorar: ainda precisamos implementar os métodos PUT e DELETE, melhorar sua segurança e adicionar testes. Vamos fazer isso nós próximos dois posts.

Link do repo no github:

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

PCHunter API

View on GitHub

Post anterior:

Criando uma API com Spring Boot e Kotlin — parte 1

Ronaldo Costa de Freitas ・ Oct 29 '22

#kotlin #api #spring

Próximo post:

Criando uma API com Spring Boot e Kotlin — parte 3

Ronaldo Costa de Freitas ・ Nov 12 '22

#kotlin #java #spring #api

Obrigado pela atenção e até a próxima!

Mostrando os Pokémon com Coil em Android

Ronaldo Costa de Freitas — Thu, 03 Nov 2022 03:06:05 +0000

No último post, nós conseguimos construir uma arquitetura MVVM simples, conectar nosso app a PokéAPI e listar os pokémon de Kanto por meio de log. Mas não listamos os pokémon na tela da nossa Pokédex muito menos mostramos as imagens dos monstrinhos. Sendo assim, nesse post vamos refatorar um pouco nosso código, implementar uma Recycler View e usar o Coil para exibir os pokémon na tela.

Corrigindo um pequeno erro

Anterioirmente, eu acabei cometendo um erro no mapeamento da API, especificamente na estrutura do JSON que continha a imagem que queremos usar do pokémon. Eu mapeei assim:

"sprites": {
    "official-artwork": {
      "front-default": "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/other/official-artwork/4.png"
    }
}

O que deveria ser assim:

"sprites": {
    "other": {
        "official-artwork": {
            "front_default": "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/other/official-artwork/4.png"
        }
    }
}

Para corrigir isso, precisamos fazer alguns ajustes simples: primeiro vamos criar a classe Other:

package br.com.pokedex.api

import com.google.gson.annotations.SerializedName

data class Other(
    @SerializedName("official-artwork") val officialArtwork: OfficialArtWork
)

Após isso, basta modificar a classe Sprites dessa forma:

package br.com.pokedex.api

import com.google.gson.annotations.SerializedName

data class Sprites(
    @SerializedName("other") val other: Other
)

E, por fim, corrigir o mapeamento front-default da classe OfficialArtWork para front_default:

package br.com.pokedex.api

import com.google.gson.annotations.SerializedName

data class OfficialArtWork(
    @SerializedName("front_default") val frontDefault: String? = null
)

Pronto: agora nosso mapeamento da api está correto!

Refatorando o código

Outro “erro” do último post foi misturar os conceitos de classes Models e classes DTO (Data Transfer Object) ao fazer o mapeamento da API. Classes DTO são um padrão de software com o intuito de transferir informações entre as camadas de um sistema. Ele serve, por exemplo, para receber dados em um estado muito específico sem fazer contato entre as camadas inferiores da aplicação. No nosso caso, ele é útil justamente para serializar o JSON recebido como resposta pela PokéAPI. Sendo assim, vamos renomear todas as nossas antes classes Models para classes DTO e colocá-las em um pacote específico dto:

Agora que já temos nossas classes DTO, vamos realmente fazer nossas classes Models, que servirão como receptoras dos dados armazenados pelas DTO. Primeiro temos a classe que irá representar um único pokémon, a SinglePokemon:

package br.com.pokedex.model

data class SinglePokemon(
    val name: String,
    val id: Int,
    val imageUrl: String,
    val types: List<Type>
)

Agora vamos desenvolver a classe para representar os tipos do pokémon, a classe Type:

package br.com.pokedex.model

data class Type (
    val name: String
)

Bem simples, não? Essas duas classes Model contém todos os dados dos pokémon que nós vamos precisar no momento. Agora vamos criar funções para mapear classes DTO para classes Models em um arquivo chamado PokedexMappers. A primeira delas é uma função para mapear uma SlotTypeDTO para uma Type:

package br.com.pokedex.data.mapper

import br.com.pokedex.api.dto.SlotTypeDTO
import br.com.pokedex.model.Type
import br.com.pokedex.util.emptyString

fun SlotTypeDTO.toModel() = Type(
    name = typeDTO.name ?: emptyString()
)

Repare que nós usamos uma função chamada emptyString(), ela retorna apenas uma string vazia, como seu nome diz, fazemos isso para tornar nosso código mais idiomático, aqui seu código em um arquivo chamado StringExt:

package br.com.pokedex.util

fun emptyString() = ""

Agora vamos fazer uma função para mapear uma lista de SlotTypeDTO para uma lista de Type:

package br.com.pokedex.data.mapper

import br.com.pokedex.api.dto.SlotTypeDTO
import br.com.pokedex.model.Type
import br.com.pokedex.util.emptyString

fun SlotTypeDTO.toModel() = Type(
    name = typeDTO.name ?: emptyString()
)

fun List<SlotTypeDTO>.toModel(): List<Type> {
    val types = mutableListOf<Type>()
    types.add(this.first().toModel())
    this.first().let { firstType ->
        this.last().let { secondType ->
            if(secondType != firstType) {
                types.add(secondType.toModel())
            } else {
                types.add(Type(emptyString()))
            }
        }
    }
    return types.toList()
}

Essa é uma pouco mais complexa, mas o que fazemos aqui é criar uma MutableList de Type e adicionar o primeiro tipo do pokémon, depois analisamos se ele tem um segundo tipo obtendo o último elemento da lista de SlotTypeDTO, caso esse elemento seja diferente do primeiro, isso significa que há um segundo tipo, então nós o adicionamos na lista, caso seja igual, não há um segundo tipo, então nós adicionamos uma string vazia. Por fim, retornarmos a lista como uma List<Type>.

Agora basta mapearmos uma SinglePokemonDTO para uma SinglePokemon:

package br.com.pokedex.data.mapper

import br.com.pokedex.api.dto.SinglePokemonDTO
import br.com.pokedex.api.dto.SlotTypeDTO
import br.com.pokedex.model.SinglePokemon
import br.com.pokedex.model.Type
import br.com.pokedex.util.emptyString
import br.com.pokedex.util.zeroNumber

fun SlotTypeDTO.toModel() = Type(
    name = typeDTO.name ?: emptyString()
)

fun List<SlotTypeDTO>.toModel(): List<Type> {
    val types = mutableListOf<Type>()
    types.add(this.first().toModel())
    this.first().let { firstType ->
        this.last().let { secondType ->
            if(secondType != firstType) {
                types.add(secondType.toModel())
            } else {
                types.add(Type(emptyString()))
            }
        }
    }
    return types.toList()
}

fun SinglePokemonDTO.toModel() = SinglePokemon(
    name = name ?: emptyString(),
    id = id ?: zeroNumber(),
    imageUrl = sprites.other.officialArtworkDTO.frontDefault ?: emptyString(),
    types = types.toModel()
)

Note que também usamos uma função zeroNumber() para deixar nosso código mais legível. Eis o código dela no arquivo IntExt:

package br.com.pokedex.util

fun zeroNumber() = 0

Agora temos que substituir a menção a essas classes DTO no código para suas respectivas models, com especial atenção para a seguinte:

package br.com.pokedex.data.repository

import br.com.pokedex.api.PokemonApi
import br.com.pokedex.data.mapper.toModel
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

class PokemonRepositoryImpl {

    private val api: PokemonApi = Retrofit.Builder()
        .baseUrl("https://pokeapi.co/api/v2/")
        .addConverterFactory(GsonConverterFactory.create())
        .build()
        .create(PokemonApi::class.java)

    suspend fun getSinglePokemon(id: Int) = api.getSinglePokemon(id).toModel()
}

Aqui nós usamos a função que mapeia para um único pokémon: em resumo, mudamos o tipo de retorno de getSinglePokemon() para SinglePokemon.

Por fim, mas não menos importante, vamos renomear nossa interface PokemonService para PokemonApi, com o intuito de deixar claro de que se trata da interface que contém as chamadas à PokéAPI:

package br.com.pokedex.api

import br.com.pokedex.api.dto.SinglePokemonDTO
import retrofit2.http.GET
import retrofit2.http.Path

interface PokemonApi {

    @GET("pokemon/{id}/")
    suspend fun getSinglePokemon(
        @Path("id") id: Int?
    ): SinglePokemonDTO

}

E pronto: refatoramos nosso código! Agora ele está melhor do que antes nos quesitos de legibilidade e consistência de dados.

Construindo a Recycler View

Para a nossa Pokédex ser realmente uma Pokédex, precisamos mostrar nossos monstrinhos de bolso como uma lista e para isso existem diversas soluções em Android, como a Recycler View. Vamos usa ela por sua eficiência em exibir conjuntos grandes e dinâmicos de dados.

Com Recycler View nós fornecemos os dados e definimos a aparência de cada item, após isso, como o próprio nome indica, esses dados são reciclados: quando um item rola para fora da tela, o Recycler reutiliza sua visualização para novos itens que passarem a aparecer na tela. Isso melhora muito o desempenho, aperfeiçoando a capacidade de resposta do app e reduzindo o consumo de energia. Mais informações aqui: developer.android.

Implementar um Recycler View não é uma tarefa trivial: é necessário (1) primeiro decidir se será uma lista ou uma grade, (2) depois criar a aparência e o comportamento de cada elemento da lista, (3) estender da classe ViewHolder, responsável por fornecer todas as funcionalidades para os itens da lista, e por fim, (4) definir o Adapter que associa seus dados à visualização ViewHolder. Ufa, bastante coisa, não? Então vamos começar logo!

Para início de conversa, vamos fazer a nossa pokédex como uma lista por enquanto e definir como será a aparência dos itens. Sendo assim, criamos o layout pokemon_card.xml da seguinte forma:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:padding="32dp">

    <ImageView
        android:id="@+id/pokemonImage"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:importantForAccessibility="no"
        tools:src="@drawable/bulbasaur"/>

    <TextView
        android:id="@+id/pokemonName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toBottomOf="@id/pokemonImage"
        tools:text="Bulbasaur" />

    <TextView
        android:id="@+id/pokemonId"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="@id/pokemonName"
        app:layout_constraintEnd_toEndOf="@id/pokemonName"
        app:layout_constraintTop_toBottomOf="@id/pokemonName"
        tools:text="#001" />

    <TextView
        android:id="@+id/firstPokemonType"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="@id/pokemonName"
        app:layout_constraintEnd_toEndOf="@id/pokemonName"
        app:layout_constraintTop_toBottomOf="@id/pokemonId"
        tools:text="Grass" />

    <TextView
        android:id="@+id/secondPokemonType"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="gone"
        app:layout_constraintStart_toStartOf="@id/firstPokemonType"
        app:layout_constraintEnd_toEndOf="@id/firstPokemonType"
        app:layout_constraintTop_toBottomOf="@id/firstPokemonType"
        tools:text="Poison" />

</androidx.constraintlayout.widget.ConstraintLayout>

É um layout bem simples: temos a imagem do pokémon, seu nome, seu id e seus tipos. Repare que o segundo tipo está gone como padrão, ou seja, não está na tela, faremos assim pois nem todo pokémon têm dois tipos. Com esse layout teremos esse resultado:

Em seguida vamos adicionar a ViewGroup do RecyclerView na nossa pokedex_activity_xml e informar que seu listitem é o layout que acabamos de construir:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/pokedexRecyclerView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:listitem="@layout/pokemon_card" />

</androidx.constraintlayout.widget.ConstraintLayout>

Está feito, agora vamos criar nosso Adapter e por consequência estender e personalizar a ViewHolder, vamos chamar essa classe de PokedexAdapter:

package br.com.pokedex.presentation

import android.content.Context
import android.view.LayoutInflater
import android.view.ViewGroup
import android.widget.ImageView
import androidx.recyclerview.widget.RecyclerView
import br.com.pokedex.databinding.PokemonCardBinding
import br.com.pokedex.model.SinglePokemon
import br.com.pokedex.util.showIf

class PokedexAdapter(
    private val context: Context,
    private val pokemon: List<SinglePokemon>
) : RecyclerView.Adapter<PokedexAdapter.PokemonViewHolder>() {

    inner class PokemonViewHolder(binding: PokemonCardBinding) :
        RecyclerView.ViewHolder(binding.root) {
        private val name = binding.pokemonName
        private val id = binding.pokemonId
        private val firstType = binding.firstPokemonType
        private val secondType = binding.secondPokemonType

        fun bind(singlePokemon: SinglePokemon) {
            name.text = singlePokemon.name
            id.text = singlePokemon.id.toString()
            firstType.text = singlePokemon.types.first().name
            secondType.text = singlePokemon.types.last().name
            secondType.apply {
                showIf(text.isNotEmpty())
            }
        }
    }

    override fun onCreateViewHolder(
            parent: ViewGroup, 
            viewType: Int
        ): PokemonViewHolder {
        return PokemonViewHolder(
            PokemonCardBinding.inflate(
                LayoutInflater.from(context),
                parent,
                false
            )
        )
    }

    override fun onBindViewHolder(
            holder: PokemonViewHolder, 
            position: Int
        ) {
        holder.bind(pokemon[position])
    }

    override fun getItemCount() = pokemon.size
}

Ok, dessa vez o código é bem grande, vamos por partes. Primeiro de tudo, nossa classe estende de RecyclerView.Adapter e usa PokedexViewHolder para fazer o bind (ligação) de dados. Essa nossa classe tem duas propriedades: um context, que será usado para inflar o layout, e uma lista de pokémon, nossa pokédex.

Sendo assim, definimos nossa ViewHolder, que usa view binding para ter acesso às view do layout e tem todas as propriedades necessárias para representar um pokémon. Nossa ViewHolder também tem o método bind(), que serve justamente para ligar os dados da lista de pokémon com as views do layout. Repare que nele usamos uma função chamada showIf(), essa função serve para tornar um TextView visível de acordo com uma condição, nesse caso se o conteúdo não for uma string vazia. Segue o código contido no arquivo TextViewExt:

package br.com.pokedex.util

import android.widget.TextView

fun TextView.showIf(condition: Boolean) {
    if(condition) {
        visibility = TextView.VISIBLE
    }
}

Note que temos três funções sobreescritas: onCreateViewHolder(), onBindViewHolder() e getItemCount(), esses métodos são o motor da RecyclerView. Abaixo seguem as funções de cada uma de acordo com o site oficial dos desenvolvedores android:

onCreateViewHolder(): RecyclerView chama esse método sempre que precisa criar um novo ViewHolder. O método cria e inicializa o ViewHolder e a View associada, mas não preenche o conteúdo da visualização. O ViewHolderainda não foi vinculado a dados específicos.
onBindViewHolder(): RecyclerView chama esse método para associar um ViewHolder aos dados. O método busca os dados apropriados e usa esses dados para preencher o layout do fixador de visualização. Por exemplo, se a RecyclerView exibir uma lista de nomes, o método poderá encontrar o nome apropriado na lista e preencher o widget TextViewdo fixador de visualização. No nosso caso, os dados preenchidos são de um pokémon específico.
getItemCount(): a RecyclerView chama esse método para ver o tamanho do conjunto de dados. Por exemplo, em um app de lista de endereços, pode ser o número total de endereços. O RecyclerView usa essa função para determinar quando não há mais itens a serem exibidos.

Ufa, finalmente terminamos nosso adapter, agora vamos configurar a RecyclerView na nossa activity. Para isso basta que definamos seu layout manager e o adapter que acabamos de construir. O layout manager por enquanto será o LinearLayoutManager, visto que vamos exibir uma lista. O código que configura a RecyclerView está contido na função setUpPokedexRecyclerView():

package br.com.pokedex.presentation

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import br.com.pokedex.databinding.ActivityPokedexBinding
import br.com.pokedex.model.SinglePokemon

class PokedexActivity: AppCompatActivity() {

    private val binding by lazy {
        ActivityPokedexBinding.inflate(layoutInflater)
    }

    private lateinit var viewModel: PokedexViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        viewModel = ViewModelProvider(this)[PokedexViewModel::class.java]

        viewModel.getPokemon()

        viewModel.pokemon.observe(this@PokedexActivity) { pokedex ->
            setUpPokedexRecyclerView(pokedex)
        }
    }

    private fun setUpPokedexRecyclerView(pokedex: List<SinglePokemon>?) {
        pokedex?.let { pokemonList ->
            binding.pokedexRecyclerView.apply {
                layoutManager = LinearLayoutManager(context)
                adapter = PokedexAdapter(context, pokemonList)
            }
        }
    }

}

Com isso já estamos quase acabando nosso trabalho de hoje, falta apenas exibirmos as imagens dos nossos monstrinhos com o Coil.

O que é Coil?

Coil é uma biblioteca de carregamento de imagens construída com Kotlin Coroutines. Ela é rápida, leve (adiciona mais ou menos 2000 métodos para a APK, o que comparado ao Picasso e Glide é significantemente menor), fácil de usar e moderna (Coil foi feita em Kotlin e usa bibliotecas modernas como Coroutines, OkHttp, Okio and AndroidX Lifecycles.

E é por isso que vamos usá-la.

Curiosidade: Coil é o acrônimode Coroutine Image Loader

Mostrando os Pokémon com Coil

De início precisamos incluir o Coil como uma dependência no nosso arquivo gradle:

dependencies {
    ...

    // Coil
    implementation("io.coil-kt:coil:2.2.2")

    ...
}

Após sincronizarmos nosso arquivo gradle, já temos acesso às funções do gradle. Fique tranquilo, carregar as imagens dos pokémon será a parte mais fácil de hoje, analise o código abaixo:

package br.com.pokedex.presentation

import android.content.Context
import android.view.LayoutInflater
import android.view.ViewGroup
import android.widget.ImageView
import androidx.recyclerview.widget.RecyclerView
import br.com.pokedex.databinding.PokemonCardBinding
import br.com.pokedex.model.SinglePokemon
import br.com.pokedex.util.showIf
import coil.load

class PokedexAdapter(
    private val context: Context,
    private val pokemon: List<SinglePokemon>
) : RecyclerView.Adapter<PokedexAdapter.PokemonViewHolder>() {

    inner class PokemonViewHolder(binding: PokemonCardBinding) :
        RecyclerView.ViewHolder(binding.root) {
        private val image = binding.pokemonImage
        private val name = binding.pokemonName
        private val id = binding.pokemonId
        private val firstType = binding.firstPokemonType
        private val secondType = binding.secondPokemonType

        fun bind(singlePokemon: SinglePokemon) {
            loadPokemonImage(image, singlePokemon.imageUrl)
            name.text = singlePokemon.name
            id.text = singlePokemon.id.toString()
            firstType.text = singlePokemon.types.first().name
            secondType.text = singlePokemon.types.last().name
            secondType.apply {
                showIf(text.isNotEmpty())
            }
        }

        private fun loadPokemonImage(image: ImageView, imageUrl: String) {
            image.load(imageUrl)
        }
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PokemonViewHolder {
        return PokemonViewHolder(
            PokemonCardBinding.inflate(
                LayoutInflater.from(context),
                parent,
                false
            )
        )
    }

    override fun onBindViewHolder(holder: PokemonViewHolder, position: Int) {
        holder.bind(pokemon[position])
    }

    override fun getItemCount() = pokemon.size
}

Conseguiu notar o que mudou? Nós apenas tivemos que usar a função load() do Coil para carregar cada imagem dos nossos pokémon e extraímos esse código para a função loadPokemon() 😱

E pronto! Basta rodarmos o app para vermos o resultado:

Incrível né? Nós finalmente temos uma pokédex minimamente visualizável, parabéns!

Próximos posts

Nossa pokédex, apesar de visualizável, ainda está bem feia e lenta, levou cerca de 20 segundos para todas as imagens dos monstrinhos de bolso serem carregadas. Nós próximos posts vamos melhorar sua performance e deixá-la mais bonita.

Link do repositório no github:

ronaldocoding / pokedex

A simple Pokédex

Pokédex

A simple Pokédex

View on GitHub

Post anterior:

Construindo uma Pokédex com Android

Ronaldo Costa de Freitas ・ Oct 28 '22

#kotlin #android #pokémon

Próximo post:

Melhorando a arquitetura da Pokédex

Ronaldo Costa de Freitas ・ Nov 11 '22

#kotlin #android #cleancode #pokemon

Obrigado pela atenção e até a próxima!

Introdução ao Kotlin

Ronaldo Costa de Freitas — Wed, 02 Nov 2022 04:04:06 +0000

Kotlin tomou o lugar do Java como linguagem oficial do Android e diversas grandes empresas vem migrando seus back-ends de Java para Kotlin. Neste post vou mostrar a você porquê isso vem acontecendo.

O poder do Kotlin

Kotlin é tão poderosa quanto o Java e isso é incrível. No post anterior eu falei um pouco sobre a interoperabilidade entre as duas e contei brevemente a história da linguagem criada pelos engenheiros da Jetbrains. Essa interoperabilidade, aliada ao quão concisa Kotlin é, a torna uma substituta perfeita para a mãe dos legados.

Vamos tomar como exemplo uma classe que representa uma conta corrente em Java e em Kotlin.

Em Java:

Em Kotlin:

É isso mesmo, o código Kotlin acima faz exatamente o que o em Java faz 😱

A ideia da classe ContaCorrente é representar um conta com as seguintes propriedades: um titular, que pode ser mudado, um cpf, uma agência, uma conta, todos imutáveis e um saldo, mutável, é claro. Para construi essa classe em Java respeitando os princípios do encapsulamento, temos que desenvolver os getters e setters necessários, além de criar funções auxiliares como toString(), copy(), equals() e hashCode(). Mas para fazer isso em Kotlin basta criar uma data class, usar os declaradores de propriedades corretos (var e val) e pronto: temos todos os getters e setters necessários além das funções antes mencionadas!

Para verificarmos a veracidade disso, vamos analisar o código abaixo:

Nesse programa Kotlin nós instanciamos as duas classes que representam uma conta corrente e chamamos todos os seus métodos para compararmos seus poderes de abstração. Repare que para acessar os getters e setters em Kotlin, basta usarmos a notação de .. Eis a saída:

Ronaldo
João
022.521.260-94
69624
246964
10000.0
12000.0
ContaCorrenteKt(titular=João, cpf=12345678901, agencia=69624, conta=246964, saldo=12000.0)
152796811
false

Ronaldo
João
022.521.260-94
69624
246964
10000.0
12000.0
ContaCorrenteJava(titular=João, cpf=12345678901, agencia=69624, conta=246964, saldo=12000.0)
181425962
false

ContaCorrenteKt(titular=João, cpf=12345678901, agencia=69624, conta=246964, saldo=12000.0)
ContaCorrenteJava(titular=João, cpf=12345678901, agencia=69624, conta=246964, saldo=12000.0)

Como podemos ver, ambas tem o mesmo poder de abstração, mas a diferença de verbosidade entre as duas é gigante! E esse é um pequeno gostinho do porquê Kotlin é cada vez mais adotado quando comparada a Java.

Var e Val

Você deve ter reparado que usamos diversas vezes duas palavras-chaves muito importantes em Kotlin: var e val. E o que elas significam? Basicamente, essa é a notação que a linguagem usa para declarar propriedades que são mutáveis e aquelas que são imutáveis.

Ao declarar uma propriedade como var (vem de variable), queremos dizer que ela é mutável e ganhamos de brinde os seus setter e getter de forma implícita, ela corresponde a uma variável em Java com seus métodos getter e setter.

Ao declarar uma propriedade como val (vem de value), queremos dizer que ela é imutável e, é claro, já temos seu método getter implementado implicitamente. Desse modo, ela corresponde a uma variável final em Java com seu getter já desenvolvido.

É importante salientar que apesar das propriedades já virem com seus getters e setters implementados, não significa que nós não podemos customizá-los. Vamos implementar uma nova propriedade na nossa classe de conta corrente e criar um getter customizado. Essa propriedade representa a resposta para a pergunta: “a conta está negativada?”, true para sim e false para não. Dessa forma basta que o getter dessa propriedade seja a comparação entre o saldo da conta e zero:

E pronto: já temos um getter customizado! Agora para fazer um setter customizado vamos implementar um setter para a propriedade saldo. A lógica é a seguinte: o saldo só será alterado se o valor passado para o setter for positivo:

Feito. Repare que antes de implementar o setter, tivemos que inicializar a propriedade, isso foi necessário pois o setter usa o valor da propriedade para fazer a atribuição, por isso ela não pode ser nula. E quanto a palavra-chave field, ela representa a própria propriedade, é algo parecido ao usar this.saldo em Java.

Funções

Como já deve ter percebido, para se declarar uma função em Kotlin, usamos a palavra-chave fun, pra você ver como é divertido programar em Kotlin 🤣. Além disso a função chamada main é a função especial que indica onde o programa deve começar a ser executado. Agora vamos analisar de forma mais profunda a sintaxe das funções com um exemplo do Kotlin in Action:

Assim como em Java, o nome da função vem logo no início, nesse caso max, depois entre parênteses temos seus parâmetros na forma <nome>: <Tipo>, em seguida após os dois pontos o tipo de retorno da função e por fim, entre chaves, o seu corpo em si. Essa função compara dois valores e retorna o maior. Repare que em Kotlin o if não é uma declaração (statement), mas sim uma expressão, ou seja, ela tem um valor, que está atrelado às suas comparações lógicas. No caso acima, se a for maior que b, o valor da expressão será a, caso contrário será b, e é por isso que a expressão pode ser retornada.

Obs: existe outra forma mais concisa de escrever a função max em Kotlin:

O = substitui o tipo de retorno da função, as chaves e a palavra-chave return. Muito legal, né?

Null safety

Para fechar com chave de ouro vamos falar sobre uma das melhores qualidades do Kotlin: sua segurança. Você, pessoa desenvolvedora Java, quantos vezes já não se deparou com o maldito NullPointerException? Pois saiba que com Kotlin seus problemas acabaram, ou quase isso.

Nessa tão querida linguagem, nós podemos declarar propriedades como nuláveis ou não-nuláveis (em português isso fica bem feio, mas em inglês é nullable e non-nullable), da seguinte forma:

Para acessar a propriedade nome, não temos nenhum problema, pois sabemos que ela não pode ser nula. Mas e quanto a propriedade `sobrenome? Em Java, seria necessário fazer o seguinte:

if(sobrenome != null) System.out.println(sobrenome.length());

Mas em Kotlin, nós temos uma feature muito útil chamada safe call. De modo que o código acima pode ser reduzido ao seguinte:

println(sobrenome?.length)

Trata-se da notação ?., ela garante que estamos acessando uma propriedade que não está nula no momento, do contrário retorna apenas null. Essa notação é muito útil em chamadas encadeadas como o seguinte exemplo de kotlinlang.org:

bob?.department?.head?.name = managersPool.getManager()

Se qualquer uma das propriedade da cadeia for nula, essa atribuição é pulada e não considerada.

Mas e para o caso de eu querer fazer uma atribuição de uma propriedade non-nullable para uma propriedade nullable? Você poderia fazer o seguinte:

val l: Int = if (b != null) b.length else -1

Porém veja que mais uma vez precisamos de uma expressão inteira para uma simples atribuição. Foi pensando em solucionar isso que Kotlin tem o brilhante Elvis operator!

val l: Int = b?.length ?: -1

Nome criativo, não? Esse operador ?: serve para avaliar se a expressão à esquerda é nula, caso ela não seja, ele a retorna, caso seja, ele retorna o operador à direita!

Agora, se mesmo com todas essas opções você ainda quiser ver um NullPointerException, Kotlin deixa, basta usar o operador !!:

val l = b!!.length

Nesse caso, se b não for nulo, seu valor será retornado, mas caso seja, uma NullPointerException será lançada!

Próximos posts

E por hoje é isso, pessoal! Conseguimos falar um pouco sobre Kotlin, mas faltam alguns conceitos importantes como as clássicas expressões for, while, uma expressão nova chamada when, entre outras que vamos discutir no próximo post sobre Kotlin.

Obrigado pela atenção, até a próxima!

Post anterior:

Breve história do Kotlin

Ronaldo Costa de Freitas ・ Oct 25 '22

#kotlin #jetbrains #java

Próximo post:

Estruturas de controle em Kotlin

Ronaldo Costa de Freitas ・ Nov 8 '22

#kotlin #java

Criando uma API com Spring Boot e Kotlin — parte 1

Ronaldo Costa de Freitas — Sat, 29 Oct 2022 02:20:37 +0000

Existem diversas formas e ferramentas para se construir APIs, hoje inicio uma série de posts em que construo uma API simples usando Spring Boot e Kotlin para um app que eu e meus amigos criamos há um tempo.

O app Android que criamos servia para ajudar consumidores a montar PCs por meio da escolha das suas peças, como placa-mãe, processador, memória ram, etc. Como nosso app não tem um back-end próprio, o back-end é basicamente feito por meio do Firebase, então resolvi construir um back-end para ele.

A API vai ser basicamente um CRUD de um Setup, uma entidade composta por um nome e suas peças, as peças do Setup. Fazer um CRUD significa criar (Create), ler (Read), atualizar (Update) e deletar (Delete).

Nesse primeiro post nós vamos configurar e criar nosso projeto usando a ferramenta Spring Initializr do site do Spring Boot.

O que é Spring Boot?

Spring Boot é um framework Java/Kotlin que facilita a criação de aplicações Web como APIs e webservices. Ele provê de forma default servidores como o Tomcat e dependências que simplificam a configuração do build.

Nessa série de posts nós vamos usar o Spring Boot para criar uma API RESTful para um CRUD básica usufruindo de algumas dependências do Spring como a Spring Web e a Spring Data JPA.

Configurando o projeto

Para configurar o projeto, usaremos a ferramenta Spring Initializr que permite em poucos passos gerar um projeto Spring.

Ao acessarmos o site, nós deparamos que a tela de configuração completa, onde escolheremos a build tool do projeto, a linguagem, a versão do Spring Boot, os metadados do projeto, o tipo de empacotamento, a versão do Java e as dependências.

Como pode ver nosso projeto vai usar o build tool Gradle, a linguagem Kotlin, a versão 2.7.5 do Spring Boot, os metadados como Group, que representa a organização que desenvolverá o projeto e o Artifact, que se refere ao nome do projeto, é pchunter, Jar como empacotamento e versão 11 do Java.

Agora quanto as dependências do nosso projeto, vamos usar as seguinte:

Spring Web: possibilita a utilização do Spring MVC e do Apache Tomcat como container default,
Spring Data JPA: permite o armazenamento e a persistência de dados em SQL com a Java Persistence API usando o Spring Data e o Hibernate,
HyperSQL Database: um motor leve para um banco de dados que permite o armazenamento e a persistência de dados tanto em memória quanto em arquivo, ou seja, poderemos usar um banco de dados sem a necessidade de instalar um software para isso, como o MySQL, Oracle e Postgres e
DevTools: essa dependência é do próprio Spring Boot, ela serve para facilitar o processo de deploy do nosso servidor durante o desenvolvimento.

Pronto, basta clicar em GENERATE e nosso projeto será baixado como .zip!

Rodando nosso projeto

Após extrair o projeto, basta abrirmos o projeto em alguma IDE que suporte desenvolvimento Web com Java/Kotlin. Eu optei pelo IntelliJ da Jetbrains porque ele dá suporte a Kotlin e Gradle de forma nativa.

Ao abrirmos o projeto, podemos ver a estrutura criada pelo Initializr como o pacote do projeto com o nosso Group como br.com.pchunter, entre outros com os arquivos do gradle e do build.

Agora, vamos analizar o arquivo .kt gerado automaticamente pelo Initializr, o PchunterApplication. Esse arquivo é a classe padrão com o intuito de rodar o Spring Boot para nós.

Note que essa classe tem a annotation @SpringBootApplication, ela serve para indicar a classe de configuração do Spring, ou seja, podemos realizar as configurações do nosso projeto a partir dessa classe.

Pronto, já podemos executar nosso projeto rodando a classe PchunterApplication:

Note que nosso servidor já está operando na porta 8080, ou seja, nossa aplicação já está funcionando!

Ao acessarmos localhost:8080 podemos ver que o Spring Boot respondeu a requisição com um 404 porque ainda não configuramos nenhuma classe Controller para receber a requisição e responder de alguma forma.

Nosso trabalho acaba por aqui 🤓

Segue repo do github:

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

PCHunter API

View on GitHub

Próximo post:

Criando uma API com Spring Boot e Kotlin — parte 2

Ronaldo Costa de Freitas ・ Nov 6 ・ 9 min read

#kotlin #spring #api

No próximo post vamos criar as classes referentes ao Setup e as funções de GET e POST para a nossa aplicação. Obrigado pela atenção e até a próxima!

Construindo uma Pokédex com Android

Ronaldo Costa de Freitas — Fri, 28 Oct 2022 01:50:31 +0000

Hoje começo uma série de posts em que vamos construir uma Pokédex com Android e a API PokéAPI onde vamos aprender muitas coisas novas, como arquitetura MVVM (Model-View-ViewModel), coroutines, comunicação com APIs usando Retrofit e carregamento de imagens com Coil.

Nesse primeiro post, vamos focar em criar os models para representar o JSON (JavaScript Object Notation) de retorno da PokéApi ao pedirmos um GET na url https://pokeapi.co/api/v2/{id}, nós comunicar com a API usando Retrofit e listar como LOG os 151 Pokémon da 1° geração.

Resumão MVVM (Model-View-ViewModel)

MVVM é um padrão de arquitetura de desenvolvimento Android adotado por quase toda a indústria e é baseado em três camadas: Model, View e ViewModel.

Model: representa os dados e a lógica de negócios da aplicação Android. Ela consiste da lógica de negócios — fonte de dados local e remota, classes models e repositories.

View: é basicamente o código da UI (Activities, Fragments), XML. Envia a ação do usuário para a ViewModel mas não recebe a resposta de volta diretamente. Para conseguir a resposta, ela deve consultar os observables os quais a ViewModel expõe.

ViewModel: é a ponte entre a View e a Model (lógica de negócios). Ela não tem a menor ideia de qual View a usa, assim como não tem uma referência direta para a View. Então, basicamente, a ViewModel não deve estar ciente da View que está interagindo com ela. Desse modo, ela interage com a Model e expõe os observables que podem ser consultados pela View.

Criando o projeto

Agora que entendemos um pouco sobre MVVM vamos iniciar o desenvolvimento do nosso projeto. Como estamos desenvolvendo um app Android Nativo, vamos usar o Android Studio e Kotlin.

Para começar, nós podemos escolher se o nosso projeto já vai ter alguma Activity desenvolvida por padrão. Para esse primeiro post não importa muito, podemos tanto escolher No Activity quanto Empty Activity, a única diferença é que se escolhermos a primeira opção vamos ter um trabalhinho a mais no final para criarmos a activity, mas isso é de boa.

Depois, damos um nome para nosso app, o nome do seu pacote e escolhemos seu local de armazenamento. No nosso caso, vamos chamar de pokedex, mantemos o resto das configurações como padrão, clicamos em Finish e pronto: nosso projeto está criado!

Configurando o arquivo gradle

Após criarmos nosso projeto, precisamos configurar o arquivo build.gradle para adicionarmos algumas dependências e configurações.

De forma bem resumida, o Gradle é uma build tool responsável por configurar todo o processo de build do Android: todas as bibliotecas, plugins, etc.

Primeiro nós configuramos que queremos usar View Binding no nosso projeto. View Binding é um recurso que facilita a programação de códigos que interagem com views, ao ser ativada, ela gera uma classe de vinculação parar cada arquivo de layout XML. A instância de uma classe de vinculação contém referências diretas a todos as views que têm no código do layout correspondente. Na maioria dos casos, o View Binding substitui o uso do método findViewById().

Agora vamos adicionar as dependências que precisamos: Retrofit, Gson, Coroutines, ViewModel e LiveData:

Feito! Basta clicarmos em Sync Now e nosso arquivo gradle estará configurado e sincronizado.

Construindo os models

Para construir a camada Model, primeiro precisamos analisar a estrutura do JSON retornado nas requisições GET que vamos fazer na PokéAPI.

A estrutura do resultado de GET https://pokeapi.co/api/v2/{1} é a seguinte:

O JSON retornado é bem grande, esse do Bulbasaur chega a 11451 linhas! Mas para nossa Pokédex, vamos usar apenas alguns campos, de forma que o nosso JSON vai ficar mais ou menos assim:

Agora que sabemos como é a estrutura do nosso JSON, já podemos criar nossas models como data classes. Data classes são um recurso muito bom do Kotlin que nos ajuda evitar escrever código boilerplate, ou seja, código repetitivo, comum de qualquer implementação. Basicamente, são classes que tem o intuito de armazenar dados e criam métodos úteis para todas as suas propriedades, como toString(), hashCode() e copy().

A nossa primeira data class delas é a SinglePokemonResponse:

Ela representa justamente o JSON que recebemos com resposta ao fazer a requisição GET descrita anteriormente. A annotation @SerializedName() é um recurso do Retrofit para indicar que essa propriedade em específica deve ser serializada para JSON com o nome fornecido no seu campo, em outras palavras, ela mapeia uma chave-valor da estrutura JSON recebida.

Seguem as outras data classes que compõem SinglePokemonResponse:

Sprites:

OfficialArtwork:

SlotType:

Type:

Pronto: terminamos nossos models!

Criando o PokemonService

Chegou a hora de criarmos nosso service. O service se trata de uma interface que contém as funções que farão as requisições HTTP usando o Retrofit, no nosso caso, será apenas a de pegar as informações de um Pokémon específico:

Aqui nós usamos mais duas annotations do Retrofit: a @GET, que indica que essa função fará uma requisição GET, e a @Path, que indica que a propriedade a seguir irá substituir no caminho da url, nesse caso é o id do Pokémon.

Note que nós usamos uma suspend fun, a palavra-chave suspend significa que essa função pode ser bloqueada, suspendida, ela pode apenas ser usada no contexto de Coroutines. Em resumo, Coroutines nos permitem criar programas assíncronos de uma forma fluída, em Android elas servem como threads leves para gerenciar a chamada assíncrona das nossas requisições HTTP e definir quais threads devem ser executadas, evitando assim que o nosso app rode de forma perigosa na Thread Main do device e cause crashs.

Bem simples, não? Nosso PokemonService já está pronto.

Criando o PokemonRepository

Agora vamos partir para a criação do nosso repository. Um repository serve para acessarmos nossa fonte de dados, seja ela remota ou local. No nosso caso, como estamos consumindo uma API, é uma fonte de dados remota.

Nosso PokemonRepository é basicamente uma classe que tem a propriedade service do tipo PokemonService e buildamos uma instância do Retrofit. Após isso, acessamos nossa fonte de dados remota a partir da função getSinglePokemon():

Para entendermos o que aconteceu, vou explicar passo-a-passo:

primeiro criamos o builder do Retrofit passando a url base da API,
depois adicionamos o Gson como converter para transformar o JSON em objeto e
por fim, usamos o create , no qual informamos nossa interface PokemonApi.

Dessa forma, já temos o poder do Retrofit para fazermos as requisições.

E assim, terminamos nosso PokemonRepository e por consequência nossa camada Model!

Construindo nossa PokedexViewModel

Vamos fazer nossa ViewModel. Como dito anteriormente, a ViewModel é a ponte entre a Model e a View, sendo assim, a responsabilidade é expor observables com dados da Model para serem consultados pela View.

Sendo assim, na nossa PokedexViewModel vamos pegar os dados da Model através do PokemonRepository e depois vamos expor o observable chamado pokemon que é composto por um MutableLiveData _pokemon, que devolve uma lista de Pokemon, o Mutable no nome indica que essa variável pode ser alterada, e também é composto por um LiveData pokemon, diferentemente do MutableLiveData, esse LiveData é imutável, ela basicamente é o observable que está exposto para consumo da View, fazemos desse jeito por um questão de seguranção, afinal não queremos que a lista de Pokemon seja alterada, apenas consumida.

Note que usamos o escopo da ViewModel viewModelScope para indicar qual Thread queremos usar através do Dispatchers.IO da Coroutine. No nosso caso, como é uma requisição HTTO, o indicado é usar a Thread de IO para não sobrecarregar a Main Thread e corrermos o risco de termos um crash no app.

Após isso, para atualizar e expor nosso LiveData, trocamos para a Thread Main a partir da função da Coroutines withContext().

Pronto, já temos nossa PokedexViewModel!

Finalmente listando os Pokémon

FINALMENTE vamos listar nossos Pokémon! Para isso, precisamos começar a fazer algo básico, que é habilitar a permissão de acesso a internet, visto que vamos acessar uma API. Para isso basta acessarmos o AndroidManifest.xml e escrever o seguinte:

Após isso, aos que escolheram criar o app com a opção No Activity, precisamos criar nossa Activity, para isso bastar criarmos uma classe chamada PokedexActivity:

Nessa Activity, nós fazemos várias coisas, então vamos passo-a-passo. Primeiro criamos nossa variável da ViewBinding, vamos usá-la para inflar nosso layout. Depois, criamos uma variável da ViewModel como lateinit var ou seja, para ser inicializada posteriormente.

Chegou a hora tão esperada! Para podermos usar nossa ViewModel utilizamos o ViewModelProvider que é responsável por prover/injetar uma instância da classe PokedexViewModel para nós.

Após isso, chamamos o método getPokemon() da ViewModel e pronto: já temos nossos Pokémon! Agora basta observarmos o LiveData. Para fazer isso, utilizamos o método observe() , assim, ele vai ficar observando qualquer alteração nessa variável que irá acontecer dentro da ViewModel. Toda vez que o valor for alterado, o conteúdo do Observer será executado.

Por fim, dentro do Observer, percorremos a lista de Pokémon e para cada um deles, imprimimos seu nome usando Log() e pronto: se você escolheu a opção de criar o projeto com uma Empty Activity seu trabalho termina aqui!

Mas se você não fez isso, siga os próximos passos: (1) crie um arquivo xml chamado activity_pokedex.xml, não precisa alterar nada nele, e (2) declare sua Activity criada com Main e Launcher no AndroidManifest.xml.

activity_pokedex.xml:

Alteração no AndroidManifest.xml:

Agora sim! Se rodarmos nosso app e observarmos o Logcat, veremos os nomes do nossos Pokémon:

Parabéns, demos um passo importante na construção da nossa Pokédex 🤓👍

Próximos posts

Esse é o primeiro post de uma série de outros em que vamos construir uma Pokédex muito legal. Percebam que nosso código tem várias limitações: não temos testes, poderíamos criar UseCases para separar um pouco do código da ViewModel e precisamos melhorar nossa comunicação com a API, visto que fazemos 151 requisições para pegar as informações dos Pokémon, isso é muito ineficiente, tanto que optei por limitar os Pokémon apenas para os da 1º geração, porque fazer quase mil requisições para pegar todos os Pokémon seria inviável. São pontos para melhorarmos no futuro.

Repo no github:

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

PCHunter API

View on GitHub

Próximo post:

Mostrando os Pokémon com Coil em Android

Ronaldo Costa de Freitas ・ Nov 3 ・ 11 min read

#kotlin #android #pokemon #recyclerview

Obrigado pela atenção, até a próxima!

Breve história do Kotlin

Ronaldo Costa de Freitas — Tue, 25 Oct 2022 01:31:14 +0000

No prefácio de Kotlin In Action, Andrey Breslav, ex-Líder de Design do Kotlin (2010–2020), conta que a ideia de criar a linguagem veio após uma visita dele a Jetbrains, em 2010, na qual se discutiu diversos problemas e desafios de bases de código de larga escala em produção.

Na época, a Jetbrains já era uma empresa consolidada no mercado de desenvolvimento de ferramentas para pessoas desenvolvedoras Java, C#, JavaScript, Python, entre outras. O carro-chefe da empresa era o famoso IntelliJ IDEA, uma IDEA de Java.

A ideia de criar o Kotlin veio da experiência deles em construir essas diversas ferramentas para tantas linguagens ainda em Java, mas não conseguir enxergar uma linguagem que pudesse substituí-la.

Os requerimentos, segundo eles, para uma possível substituta seria (1) ter tipagem estática, (2) ter compatibilidade total com o código Java existente, (3) ser seguramente uma ferramenta de qualidade e, finalmente, (4) ser fácil de aprender e usar.

Percebendo essa grande necessidade da empresa, eles entenderam que outras empresas também poderiam se beneficiar da nova linguagem. Então decidiram embarcar nessa aventura e a versão 1.0 do Kotlin saiu em fevereiro de 2016.

O nome Kotlin foi inspirado em uma ilha próxima de São Petersburgo, na Rússia, onde a maior parte do time estava vivendo. Desse modo, eles mantiveram a tradição estabelecida pelo Java e Ceylon de dar nome de ilhas para as linguagens de programação.

O que é Kotlin?

Kotlin é uma linguagem de programação que visa atingir o ecossistema Java. Kotlin é concisa, segura, pragmática e focada na interoperabilidade com código Java. Ela pode ser usada em quase todo lugar em que Java é usado: desenvolvimento server-side, aplicações Android e muito mais!

Kotlin funciona muito bem com todas as bibliotecas e frameworks existentes de Java e executa com o mesmo nível de performance que Java.

Por que é legal aprender Kotlin?

(Trecho baseado no excelente artigo Why Learn Kotlin? da Ksenia Shneyveys do blog do Kotlin)

Existem diversos motivos para se aprender Kotlin, como por exemplo ela ser uma linguagem moderna, fácil de aprender e ter uma grande comunidade, mas os principais são: ser o legado de Java e ser multiplataforma.

A interoperabilidade entre Kotlin e Java nos possibilita aproveitar do universo gigantesco já estabelecido do ecossistema, nos livrar de alguns problemas de Java e acrescentar features que ainda não existiam.

Por ser uma linguagem que suporta multiplataforma, podemos executar Kotlin em virtualmente qualquer dispositivo hoje em dia, seja PC, no Mac ou smartphones. Assim como o tempo despendido escrevendo e mantendo o mesmo código para essas plataformas é reduzido com o compartilhamento de código Kotlin entre elas.

Além disso, o Kotlin se tornou em 2017 a linguagem oficial do desenvolvimento Android e ainda provê tecnologia para se construir aplicações mobile cross-platform. Isso elimina todas as desvantagens de outras abordagens que permite que se crie aplicativos com desempenho e UIs nativos enquanto a lógica de negócios é totalmente compartilhada.

Próximos posts

Esse é o primeiro post de um série que vou fazer esse mês estudando de uma forma mais aprofundada a linguagem Kotlin, me siga para ser notificado dos próximos 😎👍

Próximo post:

Introdução ao Kotlin

Ronaldo Costa de Freitas ・ Nov 2 ・ 6 min read

#kotlin #java #jetbrains #oop

Forem: Ronaldo Costa de Freitas

Melhorando a performance da Pokédex com Paging 3 e Flow API

O que é Paging 3?

O que é Flow API?

Implementando a solução

PagingSource

Pager e Flow<PagingData<T>>

PagingDataAdapter

Conectando o adapter na UI

Melhorando a experiência com footer

Próximos posts

ronaldocoding / pokedex

A simple Pokédex

Pokédex

Melhorando a arquitetura da Pokédex

Ronaldo Costa de Freitas ・ Nov 11 '22

Interfaces em Kotlin

Implementando propriedades declaradas em interfaces

Fonte

Próximos posts

Estruturas de controle em Kotlin

Ronaldo Costa de Freitas ・ Nov 8 ・ 5 min read

Criando uma API com Spring Boot e Kotlin — parte 3

Função updateSetup

Função deleteSetup e deleteAllSetups

Próximo post

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

Criando uma API com Spring Boot e Kotlin — parte 2

Ronaldo Costa de Freitas ・ Nov 6 ・ 9 min read

Melhorando a arquitetura da Pokédex

Clean Architecture

Usando o Koin

Próximos posts

ronaldocoding / pokedex

A simple Pokédex

Pokédex

Mostrando os Pokémon com Coil em Android

Ronaldo Costa de Freitas ・ Nov 3 ・ 11 min read

Melhorando a performance da Pokédex com Paging 3 e Flow API

Ronaldo Costa de Freitas ・ Nov 17 ・ 23 min read

Estruturas de controle em Kotlin

Estrutura while

Estrutura for

Iterando sobre intervalos

Iterando sobre coleções

Estrutura if

Estrutura when

Próximos posts

Introdução ao Kotlin

Ronaldo Costa de Freitas ・ Nov 2 ・ 6 min read

Interfaces em Kotlin

Ronaldo Costa de Freitas ・ Nov 15 ・ 3 min read

Criando uma API com Spring Boot e Kotlin — parte 2

Criando classes models

Configurando o banco de dados

Requisições GET e POST

Testando a API

Próximos posts

ronaldocoding / pchunter-api

PCHunter API

pchunter-api

Criando uma API com Spring Boot e Kotlin — parte 1

Ronaldo Costa de Freitas ・ Oct 29 '22

Criando uma API com Spring Boot e Kotlin — parte 3

Ronaldo Costa de Freitas ・ Nov 12 '22

Mostrando os Pokémon com Coil em Android

Corrigindo um pequeno erro

Refatorando o código

Construindo a Recycler View

O que é Coil?

Mostrando os Pokémon com Coil

Próximos posts

ronaldocoding / pokedex

A simple Pokédex

Pokédex

Construindo uma Pokédex com Android

Ronaldo Costa de Freitas ・ Oct 28 '22

Melhorando a arquitetura da Pokédex

O que é `Paging 3`?

O que é `Flow API`?

`PagingSource`

`Pager` e `Flow<PagingData<T>>`

`PagingDataAdapter`

Função `updateSetup`

Função `deleteSetup` e `deleteAllSetups`

Usando o `Koin`

Estrutura `while`

Estrutura `for`

Estrutura `if`

Estrutura `when`