Picasso: o que é, carregamento de imagens e trabalho em aplicativos Android

O que é o Picasso?

Picasso é uma biblioteca para carregamento assíncrono de imagens no Android, criada pela Square. Recebeu o nome em homenagem ao artista Pablo Picasso, refletindo a filosofia da biblioteca: transformar uma tarefa complexa em uma API simples e elegante. É a biblioteca mais popular para carregamento de imagens na comunidade Android.

A arquitetura do Picasso é minimalista: a biblioteca usa um pool de threads para carregamento, LruCache para cache em memória e DiskLruCache para cache em disco. Ao contrário do Glide, o Picasso não requer configuração do AppGlideModule e está pronto para uso imediatamente após adicionar a dependência. Isso o torna uma escolha ideal para protótipos e projetos pequenos.

Picasso 2.8 é a versão estável mais recente, compatível com Android API 21+ e Java 8+. A biblioteca não requer configuração de plugins Gradle ou anotações, o que simplifica a migração entre versões e reduz a probabilidade de erros durante as atualizações. Apesar de sua longa história, o Picasso continua sendo demandado em milhares de projetos em todo o mundo.

A principal tarefa do Picasso é carregar uma imagem por URL, decodificá-la, redimensioná-la se necessário e exibi-la em um ImageView. A biblioteca gerencia automaticamente as threads em segundo plano, o cache e a reutilização do ImageView em listas.

Desde seu lançamento em 2013, o Picasso se tornou o padrão para carregamento de imagens na comunidade Android. A biblioteca é usada em milhares de aplicativos graças ao seu mínimo limiar de entrada — apenas uma linha de código é necessária para o primeiro uso.

Prioridades e cancelamento de solicitações

As prioridades no Picasso permitem gerenciar a ordem de carregamento das imagens. Por padrão, todas as solicitações têm prioridade normal, mas para imagens críticas é possível definir uma prioridade alta através do método priority. Se um ImageView for reutilizado (por exemplo, em RecyclerView), o Picasso cancela automaticamente a solicitação anterior e inicia uma nova, evitando cintilação de imagens durante a rolagem.

Principais recursos do Picasso

Picasso oferece um conjunto de recursos que cobrem os principais cenários de trabalho com imagens em aplicativos móveis sem complexidade desnecessária.

Cache multinível

O cache do Picasso consiste em dois níveis: RAM para acesso rápido e disco para armazenamento permanente. Ao solicitar uma imagem, a biblioteca primeiro verifica o cache em memória, depois o disco e só então realiza uma solicitação de rede. Isso acelera significativamente a exibição de imagens carregadas repetidamente.

Transformações de imagens

As transformações permitem redimensionar, cortar ou girar uma imagem sem decodificar o original toda vez. O Picasso fornece transformações integradas CenterCrop e CenterInside, e também permite criar transformações personalizadas através da interface Transformation. Imagens transformadas são armazenadas em cache separadamente.

Placeholder e imagens de erro

O placeholder é exibido enquanto a imagem está sendo carregada da rede, dando ao usuário feedback visual. A imagem de erro é mostrada quando o carregamento falha. O Picasso também suporta uma imagem que é exibida até que uma nova versão seja carregada, o que é útil para avatares atualizáveis.

Carregamento de diferentes fontes

Picasso suporta carregamento de imagens de URLs, recursos, arquivos, provedores de conteúdo e URIs. O método load() é sobrecarregado para todos esses tipos, e a biblioteca determina automaticamente a fonte. Para recursos e arquivos, o Picasso não realiza uma solicitação de rede, mas carrega os dados diretamente, o que acelera a exibição de gráficos integrados.

Como funciona o Picasso?

Picasso usa uma arquitetura baseada em RequestCreator e Dispatcher. Cada solicitação é criada através de Picasso.get().load() e executada em um pool de threads. O Dispatcher gerencia a fila de solicitações, prioridades e cancelamento quando um ImageView é reutilizado.

Arquitetura de solicitação

Ao chamar into(view), o Picasso cria um objeto Action que contém a URL, transformações, destino e callback. A Action é colocada na fila do Dispatcher. O mecanismo carrega a imagem através do Downloader (OkHttp por padrão), decodifica o Bitmap, aplica as transformações e entrega o resultado à thread da UI. Todas as imagens são automaticamente ajustadas ao tamanho do ImageView.

Picasso.get()
    .load("https://example.com/image.jpg")
    .placeholder(R.drawable.placeholder)
    .error(R.drawable.error)
    .resize(400, 300)
    .centerCrop()
    .into(imageView)

Instalação e configuração do Picasso

A instalação do Picasso é feita através do Gradle. A biblioteca é distribuída via Maven Central e não requer configuração complexa. A versão mínima da API Android é 21.

Adicionando a dependência

No arquivo build.gradle do módulo, adicione implementation ‘com.squareup.picasso:picasso:2.8’. Após a sincronização do Gradle, o Picasso está pronto para uso. Para operações de rede, o Picasso usa automaticamente o OkHttp se estiver presente no projeto, ou o HttpURLConnection integrado.

dependencies {
    implementation "com.squareup.picasso:picasso:2.8"
}

// Kafka para carregar do OkHttp (opcional)
implementation "com.squareup.okhttp3:okhttp:4.12.0"

Indicador de depuração e cache

O indicador de depuração do Picasso mostra um triângulo colorido no canto de cada imagem: vermelho para carregamento de rede, azul para cache em disco, verde para cache em memória. É ativado chamando setIndicatorsEnabled(true) na instância do Picasso. O tamanho padrão do cache é 15% da memória disponível do dispositivo.

Para configurar uma instância personalizada do Picasso, use Picasso.Builder. Ele permite definir um Executor para threads em segundo plano, um Downloader para solicitações de rede, MemoryCache e DiskCache. Uma instância personalizada é especialmente útil em testes, onde o Downloader pode ser substituído por um stub que retorna uma imagem sem solicitação de rede.

Exemplos de uso do Picasso

Os exemplos abaixo demonstram cenários típicos de trabalho com o Picasso: carregamento de uma imagem simples, uso de transformações e carregamento em RecyclerView.

Carregando uma imagem em ImageView

O carregamento básico em um ImageView é feito com uma única chamada. O Picasso ajusta automaticamente a imagem às dimensões da view levando em conta o scaleType. Um placeholder é exibido até que o carregamento seja concluído, e uma imagem de erro é mostrada quando ocorre um erro de conexão.

Picasso.get()
    .load("https://example.com/photo.jpg")
    .placeholder(R.drawable.loading)
    .error(R.drawable.broken_image)
    .fit()
    .centerCrop()
    .into(imageView)

Aplicando uma transformação personalizada

BlurTransformation desfoca a imagem com um raio determinado. Transformações personalizadas implementam a interface Transformation com o método transform. O cache armazena o resultado da transformação sob uma chave única para evitar reaplicá-la.

public class BlurTransformation implements Transformation {
    @Override
    public Bitmap transform(Bitmap source) {
        Bitmap blurred = Bitmap.createBitmap(source);
        RenderScript rs = RenderScript.create(context);
        // aplicação de desfoque
        source.recycle();
        return blurred;
    }

    @Override
    public String key() {
        return "blur";
    }
}

Carregando imagens em RecyclerView

Em RecyclerView, o Picasso cancela automaticamente as solicitações para ImageViews que saíram da tela e reutiliza imagens já carregadas. Isso evita vazamentos de memória e garante uma rolagem suave.

public void onBindViewHolder(ViewHolder holder, int position) {
    String url = items.get(position).getImageUrl();
    Picasso.get()
        .load(url)
        .fit()
        .centerCrop()
        .into(holder.imageView);
}

Picasso vs Glide: comparação de bibliotecas

A comparação entre Picasso e Glide é uma pergunta comum ao escolher uma biblioteca de carregamento de imagens para Android. Ambas as bibliotecas resolvem a mesma tarefa, mas têm prioridades e características de uso diferentes.

Picasso é mais adequado para projetos onde simplicidade e tamanho mínimo do APK são importantes. Glide é escolhido quando há necessidade de suporte a GIF, quadros de vídeo e máxima otimização de memória. Glide dimensiona automaticamente a imagem para o tamanho exato do ImageView, o que reduz o consumo de memória em até 50% em comparação com o Picasso em alguns cenários.

Em testes de desempenho, o Glide mostra melhores resultados ao trabalhar com RecyclerView graças ao seu mecanismo de pré-carregamento e cancelamento automático de solicitações durante a rolagem rápida. O Picasso usa uma estratégia mais simples, o que o torna previsível, mas menos eficiente em grandes volumes de dados.

Picasso foca na simplicidade da API e no tamanho mínimo. Glide oferece funcionalidade mais ampla: suporte a GIFs, imagens animadas, quadros de vídeo e integração com o ciclo de vida. Glide também gerencia a memória de forma mais eficiente graças ao dimensionamento automático para o tamanho do ImageView.

De acordo com o Android Developer Relations, o Google recomenda o Glide como a biblioteca preferida para carregamento de imagens em novos projetos. Picasso continua sendo uma excelente escolha para projetos simples onde GIFs e quadros de vídeo não são necessários.