Arquivo do autor:Wolfgang Marcos

Sobre Wolfgang Marcos

A forever learner.

Armazenando suas configurações com o Git

Quem usa Linux e é um tanto inquieto como eu conhece bem a rotina de, vez ou outra, instalar uma distro só pra ver o que mudou ou vive como um nômade de distribuição em distribuição.

Esse estilo de vida traz um problema bem cansativo de se resolver: a cada nova instalação todas as configurações se perdem e lá vai você passar alguns minutos ou horas deixando tudo mais ou menos como estava antes.

Isso acontece comigo desde sempre mas essa realidade passou a ser menos dura depois que aprendi a usar o Git [1].  O Git é um sistema de controle de versões desenvolvido pelo mesmo criador do Linux com o intuito de gerenciar as centenas de contribuições que o kernel recebe todos os dias. Com um problema em uma mão e o Git em outra resolvi tentar uma abordagem que funcionou muito bem e detalho logo a seguir.

Neste artigo vou mostrar como uso o Git para armazenar minhas configurações em nuvem e, quando instalo uma distro nova, as restauro em poucos minutos sem dor de cabeça. O processo está dividido em duas etapas: Salvar e Restaurar as configurações.

Salvando suas configurações

Arquitetura

Organizo meus arquivo de configuração da seguinte maneira para esta abordagem:

  • configuracoes (diretório)
    • localizações.txt
    • vim
    • terminator
    • i3wm
    • etc

O diretório Configurações, como o nome deixa bem claro, é onde centralizo os arquivos de configuração a serem gerenciados pelo Git. A seguir explico como o processo funciona.

Obtendo os arquivos de configuração

É bem provável que você já tenha deixado o seu sistema configurado do jeito que gosta: as cores do terminal, as teclas de atalho do teclado, a auto distribuição de janelas no i3wm, uma infinidade de plugins para o Vim, etc.

Primeiro você deve copiar os arquivos ou diretórios de configuração para dentro do diretório Configurações. Cada programa armazena suas configurações em locais diferentes, normalmente no seu diretório home em algum diretório oculto. Essa é a parte chata, prometo que é a única!

A cada arquivo de configuração que adiciono no diretório, crio uma nova entrada no arquivo localizações.txt para indicar o local de origem do arquivo que acabei de adicionar. O arquivo tem o seguinte layout por linha:

  • Nome – Esse é o nome do arquivo/diretório como ele aparece dentro do diretório de configurações.
  • Local – O path do local onde o arquivo estava originalmente.
  • Nome original – As vezes é necessário mudar o nome do arquivo/diretório porque no local original ele era oculto (o nome começava com um ponto). É necessário trocar o nome dentro do diretório de configurações para deixar mais fácil o manuseio via terminal e no Git. Neste campo coloco o nome do arquivo como ele era originalmente.

Salvando com o Git

Certifique-se de ter o Git instalado na sua distribuição e, no bom e velho terminal, digite:

$ cd configuracoes
$ git init
$ git add --all
$ git commit -m "Primeiro commit"

Esta série de comandos cria um repositório Git no diretório de configurações, marca todos os arquivos como prontos para serem versionados e por fim cria o primeiro registro de versão.  Para conhecer mais a fundo os comandos do Git consulte o Git Tutorial [2].

Usando as configurações armazenadas

Você já está usando o Git para controlar as versões dos seus arquivos de configuração mas ainda resta um detalhe: o seu sistema ainda está usando os arquivos de configuração não versionados! Chegou a hora de corrigir isso.

Através do terminal navegue até o diretório onde está um arquivo de configuração e, com atenção, execute os comandos a seguir para cada arquivo/diretório de configuração:

$ rm -r <nome do arquivo ou diretório de configuração>
$ ln -s ~/configuracoes/<nome arquivo> <nome correto arquivo>

Esta série de comandos apaga o arquivo ou diretório original de configuração e cria um link simbólico para a versão que está sendo controlada pelo Git. Um link simbólico é como um atalho turbinado: para qualquer programa é como se o arquivo realmente estivesse ali. Qualquer alteração no conteúdo do arquivo/diretório é refletida no original.

Armazenando suas configurações em nuvem

Existem vários serviços gratuitos de hospedagem de repositórios Git. O mais conhecido deles é o GitHub [3] que é gratuito para repositórios públicos. Como sou um pouco mais sensível em relação às minhas configurações utilizo o BitBucket [4] que permite a criação de repositórios privados gratuitos.

No serviço que preferir, crie um repositório e copie o endereço utilizado para acessá-lo (normalmente o serviço deixa bem destacado esse endereço). No terminal digite:

$ cd configuracoes
$ git remote add origin <endereço do repositório>
$ git push origin master

Esta sequência de comandos indica para o Git que o seu repositório local deve se conectar ao endereço que você digitou e envia uma cópia dos commits locais para o remoto. Aguarde alguns segundos e pronto! Suas configurações já estão salvas na nuvem e sempre disponíveis para serem restauradas quando necessário.

Mantendo suas configurações atualizadas

Um processo natural é ao longo do tempo ajustar suas configurações para atender melhor suas necessidades. Neste caso é necessário manter atualizados os arquivos de configuração não apenas no seu sistema local, mas também no repositório remoto. Se você não fizer isso pode ter a desagradável surpresa de restaurar suas configurações após uma reinstalação e descobrir que seus ajustes mais finos se perderam e você voltou à idade da pedra.

Para registrar qualquer modificação nas suas configurações digite no terminal:

$ cd configuracoes
$ git add --all
$ git commit -m "Descrição da modificação"
$ git push

Esta série de comandos marca todas as modificações como aptas a serem registradas, cria uma nova versão registrando suas modificações e por fim as envia para o repositório remoto.

Restaurando suas configurações salvas

Instalou uma distro nova e precisa restaurar suas antigas configurações? Chegou a hora de aprender como fazer isso.

Clonando o repositório de configurações

Vá até o serviço que você usou para criar um repositório e copie o endereço do repositório referente às suas configurações. Certifique-se de instalar o Git na sua distribuição e digite estes comandos no terminal:

$ cd ~
$ git clone <endereço do repositório>

Esta sequência de comandos irá criar uma cópia do repositório remoto no seu diretório home.

Usando as configurações restauradas

Consulte o arquivo localizações.txt para lembrar onde cada arquivo gerenciado com o Git é armazenado no seu computador (na coluna Local). Não custa nada lembrar: muito cuidado ao executar o comando rm -r, certifique-se de passar o nome do arquivo/diretório correto! No terminal digite os seguintes comandos para cada arquivo de configuração a ser restaurado:

$ rm -r <nome do arquivo ou diretório de configuração>
$ ln -s ~/configuracoes/<nome arquivo> <nome correto arquivo>

Pronto! Configurações restauradas. Lembre-se de reiniciar os programas aos quais as configurações pertencem para que elas tomem efeito de imediato.

Nota final

Esta é a abordagem que eu me identifico melhor, você é livre para fazer do jeito que quiser =). Uma próxima etapa para facilitar ainda mais o processo de restauração é criar um shell script para automatizar a criação de links simbólicos, mãos à obra!

Recursos

  1. Git resources – http://www.git-scm.com/
  2. Git tutorial – http://www.git-scm.com/docs/gittutorial
  3. GitHub – https://github.com/
  4. BitBucket – https://bitbucket.org/

Carregando imagens no Android

Lidar com imagens no Android pode ser uma dor de cabeça para programadores iniciantes, há muitos conceitos a serem aprendidos e certamente muitas surpresas no meio do caminho.

Quando comecei a exibir imagens nos meus apps logo percebi que obter o resource (tanto do SD card quanto da Web) é algo lento que normalmente faz o aplicativo ficar vários segundos travado, principalmente se forem muitas imagens. Isso me levou a pesquisar mais a respeito e descobri algo mágico: AsyncTasks!

AsyncTasks[0] permitem que você execute tarefas pesadas em uma thread separada e, quando ela for concluída, você pode fazer o que quiser com o resultado. Como o processamento é feito em background a thread principal fica livre e não causa as travadas que todo usuário odeia.

Eu achava que era mágico até encontrar outra multitude de problemas e depois de dias enfrentando problemas por utilizar AsyncTasks para carregar imagens concluí que esse recurso simplesmente não foi feito para este fim. Foi aí então que resolvi pesquisar como os desenvolvedores mais experientes fazem isso e encontrei duas bibliotecas realmente incríveis: Picasso[1] e o Glide[2].

Carregando uma imagem

Tanto o Picasso quanto o Glide são gratuitos e têm o código disponível para quem quiser dar uma olhada no GitHub. Mas o que elas têm de especial? Elas são extremamente simples de usar, olha só:

Picasso

Picasso.with(contexto).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Glide

Glide.with(contexto).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Em apenas uma linha de código tanto o Picasso quanto o Glide são capazes de carregar uma imagem e exibi-la em um imageView, permitindo que você não se preocupe com threads, AsyncTasks, etc.  Para a operação de carregamento de imagem os dois são idênticos, mas em operações mais complexas eles são diferentes.

Como parâmetros de carregamento podem ser utilizados:

Redimensionando uma imagem

Em quase todos os casos a imagem carregada não é do mesmo tamanho do imageView que a exibirá e é sua responsabilidade redimensionar a imagem – afinal, cada pixel ocupa preciosos kilobytes de memória e é sempre bom economizar. O Picasso e o Glide disponibilizam métodos simples de redimensionamento.

Picasso

Picasso.with(contexto).load("http://i.imgur.com/DvpvklR.png").resize(200,200).into(imageView);

Glide

Glide.with(contexto).load("http://i.imgur.com/DvpvklR.png").override(200,200).into(imageView);

Os métodos de redimensionamento recebem tamanhos em pixels. Neste momento o Glide e o Picasso se distinguem internamente:

O Picasso irá armazenar a imagem original em cache exibirá no imageView uma cópia redimensionada. Desta forma se futuramente você carregar a mesma imagem em um imageView de tamanho diferente o carregamento será muito mais rápido porque não será necessário recuperar a imagem do armazenamento novamente (de um servidor remoto, por exemplo).

Já o Glide não armazenará a imagem original em cache, ele irá redimensioná-la, carregá-la no ImageView e descartar a imagem original. Isso faz com que o Glide economize memória mas faz com que a imagem seja recuperada novamente caso vocẽ queira carregá-la com uma resolução diferente.

Usando placeholders

Um placeholder é um elemento simples exibido no lugar que será ocupado por outro – mais pesado – quando este terminar de carregar. É comum que requisições através da internet demorem alguns segundos para serem concluídas e é importante deixar o usuário ciente de que algo está acontecendo.

Existem dois tipos de placeholders:

  • Carregamento: São exibidos enquanto a imagem principal não é carregada, são importantes principalmente quando imagens são carregadas através da rede.
  • Erro: São exibidos quando o carregamento da imagem falha por algum motivo.

O Picasso e o Glide suportam o carregamento e remoção de placeholders de maneira automática, bastando defini-los durante o carregamento da imagem como demonstrado:

Picasso

Picasso.with(contexto)
.load("http://i.imgur.com/DvpvklR.png")
.resize(200,200)
.placeholder(R.drawable.placeholder)
.error(R.drawable.error)
.into(imageView);

Glide

Glide.with(contexto)
.load("http://i.imgur.com/DvpvklR.png")
.override(200,200)
.placeholder(R.drawable.placeholder)
.error(R.drawable.error)
.into(imageView);

Conclusão

Qual dos dois é o melhor? Não existe uma resposta definitiva basicamente porque em informática não existe o conceito de X é melhor que Y e sim que X é melhor que Y na situação Z. Em casos gerais tanto o Picasso quanto o Glide têm a mesma performance e consumo de memória semelhantes, já em situações específicas… experimente os dois pra descobrir qual se adéqua melhor às necessidades da sua aplicação.

Para saber mais

Se quiser se aprofundar mais sobre os assuntos tratados nesse artigo consulte as referências abaixo:

[0] AsyncTasks – Android Developers
https://developer.android.com/reference/android/os/AsyncTask.html

[1] Picasso – GitHub
https://github.com/square/picasso

[2] Glide – GitHub
https://github.com/bumptech/glide