Evitar downloads não otimizados

Alguns usuários do seu app têm acesso intermitente à Internet ou têm limites na quantidade de informações que podem ser transferidas por download para os dispositivos deles. Você pode incentivar os usuários a interagir com seu app com mais frequência reduzindo a quantidade de dados que ele precisa fazer o download.

A maneira mais simples de reduzir seus downloads é transferir apenas o que você precisa. Em termos de dados, isso significa implementar APIs REST que permitem especificar critérios de consulta que limitam os dados retornados usando parâmetros como o horário da última atualização.

Da mesma forma, ao fazer o download de imagens, é recomendado reduzir o tamanho delas no servidor, em vez de fazer o download de imagens no tamanho original que são reduzidas no cliente.

Armazenar respostas HTTP em cache

Outra técnica importante é evitar o download de dados duplicados. Você pode reduzir a probabilidade de fazer o download dos mesmos dados repetidamente usando o cache. Ao armazenar em cache os dados e recursos do seu app, você cria uma cópia local das informações que o app precisa referenciar. Se o app precisar acessar as mesmas informações várias vezes em um curto período, você terá que fazer o download dele no cache uma vez.

É importante armazenar em cache o mais agressivamente possível para reduzir a quantidade total de dados que você transfere por download. Sempre armazene recursos estáticos em cache, incluindo downloads sob demanda, como imagens em tamanho original, pelo maior tempo possível. Os recursos on demand precisam ser armazenados separadamente para permitir que você faça o flush do cache on demand regularmente e gerencie o tamanho dele.

Para garantir que o armazenamento em cache não resulte no app exibindo dados desatualizados, use os códigos e cabeçalhos de status HTTP adequados, como ETag e Last-Modified. Isso permite que você determine quando o conteúdo associado precisa ser atualizado. Exemplo:

// url represents the website containing the content to place into the cache.
val conn: HttpsURLConnection = url.openConnection() as HttpsURLConnection
val currentTime: Long = System.currentTimeMillis()
val lastModified: Long = conn.getHeaderFieldDate("Last-Modified", currentTime)

// lastUpdateTime represents when the cache was last updated.
if (lastModified < lastUpdateTime) {
    // Skip update
} else {
    // Parse update
    lastUpdateTime = lastModified
}

// url represents the website containing the content to place into the cache.
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
long currentTime = System.currentTimeMillis();
long lastModified = conn.getHeaderFieldDate("Last-Modified", currentTime);

// lastUpdateTime represents when the cache was last updated.
if (lastModified < lastUpdateTime) {
    // Skip update
} else {
    // Parse update
    lastUpdateTime = lastModified;
}

É possível configurar algumas bibliotecas de rede para respeitar esses códigos de status e cabeçalhos automaticamente. Ao usar o OkHttp, por exemplo, a configuração de um diretório de cache e do tamanho do cache para o cliente permite que a biblioteca use o armazenamento em cache HTTP, conforme mostrado no exemplo de código abaixo:

val cacheDir = Context.getCacheDir()
val cacheSize = 10L * 1024L * 1024L // 10 MiB
val client: OkHttpClient = OkHttpClient.Builder()
    .cache(Cache(cacheDir, cacheSize))
    .build()

File cacheDir = Context.getCacheDir();
long cacheSize = 10L * 1024L * 1024L; // 10 MiB
OkHttpClient client = new OkHttpClient.Builder()
    .cache(new Cache(cacheDir, cacheSize))
    .build();

Com o cache configurado, é possível atender solicitações HTTP totalmente em cache diretamente do armazenamento local, eliminando a necessidade de abrir uma conexão de rede. As respostas armazenadas em cache condicionalmente podem validar o próprio nível de atualização no servidor, eliminando o custo de largura de banda associado ao download. As respostas não armazenadas em cache são armazenadas no cache de resposta para solicitações futuras.

Você pode armazenar dados não sensíveis no diretório de cache externo não gerenciado usando Context.getExternalCacheDir(). Como alternativa, é possível armazenar dados em cache no cache gerenciado e seguro do aplicativo usando Context.getCacheDir(). Esse cache interno pode ser liberado quando o sistema está com pouco armazenamento disponível.

Usar um repositório

Para uma abordagem mais sofisticada de armazenamento em cache, considere o padrão de design do repositório. Isso envolve a criação de uma classe personalizada, conhecida como repositório, que oferece uma abstração de API sobre alguns dados ou recursos específicos. O repositório pode inicialmente buscar dados de várias fontes, como um serviço da Web remoto, mas fornece aos autores de chamadas uma versão em cache dos dados em chamadas subsequentes. Essa camada de indirecionamento permite que você forneça uma estratégia de armazenamento em cache robusta específica para seu app. Para mais informações sobre como usar o padrão de repositório no app, consulte o Guia para a arquitetura do app.