Android Drawable Importer Plugin

O plugin Android Drawable Importer adiciona uma opção ao IntelliJ para importar drawables em diferentes resoluções do AndroidIcons, possui repositórios ​​drawable e muda a escala de uma determinada imagem para baixo ou para cima de acordo com as resoluções definidas.

Esse plugin pode ser encontrado neste link:

https://github.com/winterDroid/android-drawable-importer-intellij-plugin

Ou pode ser instalado por meio do próprio Android Studio, basta ir em:

File > Settings > Plugins

Pesquise por "Android Drawable Importer". Aparecerá a mensagem "No plugins found". Então clique em "Search in repositories" e depois em "Install". Depois da instalação dê um "Restart" no Android Studio.

Este plugin consiste em três características principais. Você pode acessá-los clicando com o botão direito do mouse em qualquer lugar, mas não em um arquivo, dentro de um módulo Android (biblioteca) em "New". Por exemplo, vá em "res", "drawable", clique com o botão direito do mouse e vá em "New". Então você encontrará as opções "Icon Pack Drawable Importer", "Batch Drawable Import" e "Multisource-Drawable".

Em "Icon Pack Drawable Importer", você pode selecionar o recurso, especificar sua cor, alterar o nome do recurso de destino e selecionar todas as resoluções que deseja importar. Todas as pastas em falta serão criadas automaticamente. Se já houver drawables com o mesmo nome, você será avisado. Você também pode importar Vector Drawables do pacote "Material Icons".

Em "Batch Drawable Import", selecione arquivos (ou uma pasta inteira) e especifique as resoluções de origem. Você também pode alterar o tamanho da fonte de cada imagem. Especifique todas as resoluções, para as quais ele deve ser redimensionado. Isso também funciona com 9-Patch-Images. Mas tenha cuidado: às vezes é necessário remover / adicionar um ou outro "pixel" no Editor de 9-Patch.

Caso você tenha recebido drawables para o seu projeto Android de seu designer com a seguinte estrutura:

root/
     ./drawable_ldpi.png
     ./drawable_mdpi.png
     ./drawable_hdpi.png
     ./drawable_xhdpi.png

Em "Multisource-Drawable", você pode apenas selecionar para cada resolução um recurso diferente, especificar um nome para eles, e o resto é feito pelo plugin. Ou mesmo mais fácil, você pode selecionar o zip inteiro, e este plugin extrairá automaticamente o recurso à melhor pasta.

Solicitar e Tratar Permissões para API 23 ou superior

A partir da API 23 (Android Marshmallow), o usuário tem o controle de aceitar individualmente as permissões que o aplicativo solicita. Portanto, além de colocar as uses-permission no manifest, é necessário solicitar todas as permissões individualmente ao usuário. Para isso, temos que criar um código parecido com o que está abaixo:

//Crie um array com as permissões necessárias
private String[] permissoesNecessarias = new String[] {
            android.Manifest.permission.SEND_SMS,
            android.Manifest.permission.INTERNET
};

//Crie uma classe para checar se as permissões foram aceitas
public class Permissao {

    public static boolean validaPermissoes(int requestCode, Activity activity, String[] permissoes) {

        if(Build.VERSION.SDK_INT >= 23) {
            List<String> listaPermissoes = new ArrayList<>();

            //Percorre as permissões passadas, verificando uma a uma se já tem a permissão liberada
            for (String permissao : permissoes) {
                Boolean validaPermissao = ContextCompat.checkSelfPermission(activity, permissao) == PackageManager.PERMISSION_GRANTED;
                if(!validaPermissao) listaPermissoes.add(permissao);
            }

            if(listaPermissoes.isEmpty()) return true;

            //Solicita permissão
            ActivityCompat.requestPermissions(activity, listaPermissoes.toArray(new String[0]), requestCode);
        }

        return true;
    }
}


//Gera AlertDialog para avisar que o Usuário só pode usar o App se aceitar as permissões
private void alertaValidacaoPermissao() {

    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("Permissões negadas");
    builder.setMessage("Para utilizar este app, é necessário aceitar as permissões");

    builder.setPositiveButton("CONFIRMAR", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            finish();
        }
    });

    AlertDialog dialog = builder.create();
    dialog.show();
}
 
//Tratar Negação de Permissão
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResult) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResult);
    for(int resultado : grantResult) {
        if(resultado == PackageManager.PERMISSION_DENIED) {
            alertaValidacaoPermissao();
        }
    }
}

MaskFormatter: biblioteca Android para formatar Strings usando Máscaras

Para formatar e limitar uma entrada em um EditText, como datas e números de telefone, basta usar a classe MaskTextWatcher e SimpleMaskFormatter. Mas, antes de usá-las, é necessário adicionar a biblioteca colando o código a seguir em seu build.gradle (Module: app):

compile 'com.github.rtoshiro.mflibrary:mflibrary:1.0.0'

Exemplo de uso:

private EditText telefone;
telefone = (EditText) findViewById(R.id.edit_telefone);

// Crie uma máscara de formatação de string, 'N' para representar apenas números
SimpleMaskFormatter simpleMaskTelefone = new SimpleMaskFormatter("(NN) NNNN-NNNN");
MaskTextWatcher maskTelefone = new MaskTextWatcher(telefone, simpleMaskTelefone);
telefone.addTextChangedListener(maskTelefone);

Dessa maneira o telefone será formato como, por exemplo: (88) 9956-1517

A classe SimpleMaskFormatter vem com 5 padrões pré-definidos:
N - para números.
L - para letras.
L - para números e letras.
l - para letras minúsculas.
U - para letras maiúsculas.

Também é possível customizar os nossos próprios formatos. Veja o exemplo abaixo:

// permite apenas os números 0, 1, 2 e 3.
MaskPattern mp03 = new MaskPattern("[0-3]");
// permite os números de 0 a 9.
MaskPattern mp09 = new MaskPattern("[0-9]");
// permite apenas os números 0 e 1.
MaskPattern mp01 = new MaskPattern("[0-1]");

// Cria-se então uma nova máscara
MaskFormatter mf = new MaskFormatter("[0-1][0-9]/[0-3][0-9]/[0-9][0-9][0-9][0-9]");

// Registra-se os padrões no objeto MaskFormatter
mf.registerPattern(mp01);
mf.registerPattern(mp03);
mf.registerPattern(mp09);

Para maiores informações, basta acessar o link dessa biblioteca no GitHub:
https://github.com/rtoshiro/MaskFormatter

Espero ter ajudado! =)

Atalhos do Eclipse no Android Studio

Você já programou muito pelo Eclipse, memorizou todos os seus atalhos e, por causa disso, gostaria de continuar utilizando esses mesmos atalhos no Android Studio? Pois seus problemas acabaram! Para que você possa realizar essa mudança de atalhos, basta ir na parte de Keymaps do Android Studio. Apresento-lhe abaixo duas formas de realizar essa alteração:

1ª Forma: 

File → Settings → Keymap → Troque "Default" por "Eclipse"

2ª Forma:
Crtl + Shift + A → digite "keymap" → tecle enter → escolha "Eclipse" 

Existem outras opções de mudança de atalhos, como Netbeans, entre outros.




Como integrar o Android Studio ao GitHub

Segue o passo a passo para fazer a interligação de um repositório no GitHub com um projeto no Android Studio:

1) Vá ao site do GitHub e crie um novo repositório. NÃO inicialize o repositório com um README!
2) Crie o seu projeto no Android Studio.
3) No Android Studio, vá em:

VCS > Import into Version Control > Create Git Repository

4) Vá até a pasta do seu projeto por meio do Git bash e digite:

git remote add origin https://github.com/[username]/[project_name].git

Esse endereço https é encontrado em seu repositório criado no GitHub.

5) Vá ao Android Studio, clique com o botão direito do mouse sobre a pasta do projeto e vá em:

Git > Add

Isso fará com que todos os arquivos do seu projeto sejam enviados para o repositório do Git. (também é possível digitar "git add ." no git bash)

6) No Android Studio, clique novamente com o botão direito do mouse sobre a pasta do projeto e vá em:

Git > Commit Directory

7) Digite uma "Commit Message" e clique em "Commit".

8) No Android Studio, clique novamente com o botão direito do mouse sobre a pasta do projeto e vá em:

Git > Repository > Push

Pronto. O seu projeto será enviado para o GitHub!

Como integrar GitHub ao Git para Controle de Versões

Para integrar o Git a sua conta no GitHub, basta seguir os seguintes passos:

1) Criar uma conta do GitHub;

2) Criar chave SSH de autenticação para dar acesso ao seu computador local para que ele consiga interagir com a sua conta no GitHub:

2.1) Abrir git bash;
2.2) Para gerar um par de chaves SSH, digite no git bash: "ssh-keygen" (sem aspas) em seguida será pedido um nome para o arquivo e uma senha. Caso não queira escolher um nome e uma senha basta teclar enter.
2.3) No bash, será apresentado o local em que o seu arquivo foi salvo (geralmente dentro da pasta do perfil de usuário);

3) Ir no local em que os arquivos foram salvos;
4) Abrir o arquivo que contém a chave pública por meio do bloco de notas;
5) Copiar todo o código contido no arquivo para levá-lo ao GitHub;
6) Vá na parte de configurações de sua conta no GitHub e procure por "SSH Keys", onde você poderá adicionar uma nova chave;
7) Crie um novo repositório pelo GitHub;

8) Faça um clone do repositório no GitHub em sua máquina local. O clone poderá ser por meio do HTTPS, SSH ou Subversion. Neste caso, iremos fazer via SSH:

8.1) Copie o código SSH que aparece na página principal de seu repositório do GitHub. O meu SSH, por exemplo é "git@github.com:raulfmiranda/Catalog.git";
8.2) Faça o clone em seu git bash. Veja um exemplo de código a seguir:

$ git clone git@github.com:raulfmiranda/Catalog.git github1

Dessa maneira será criada uma pasta chamada "github1" no local em que você está, e todo o conteúdo do repositório do GitHub será clonado nessa nova pasta.

9) Pronto! Foi criada a conexão entre o seu repositório local e o GitHub. Basta usá-lo normalmente, dando "push" pra enviar as atualizações e "pull" para baixá-las do servidor.

Para aprender a colaborar com projetos open source criados através do GitHub veja o vídeo abaixo:

Como criar um arquivo .gitignore pelo Windows Explorer

Eu estava tentando criar um arquivo .gitignore dentro de meu repositório para poder ignorar alguns arquivos que eu não gostaria de controlar sua versão. Acontece que o Windows Explorer não estava deixando de forma alguma que eu criasse um arquivo sem nome e com apenas uma extensão, que é o caso do .gitignore. Até que eu encontrei uma dica brilhante no blog do Caio Proiete (PT) que se encontrava na postagem Criar ficheiro .gitignore a partir do Windows Explorer. 

Em resumo, basta criar um arquivo de texto com o seguinte nome:

.gitignore.

Isso mesmo: com um ponto antes e um ponto depois. Surgirá então uma caixa de diálogo com a seguinte pergunta: Se a extensão de um nome de arquivo for alterada, o arquivo poderá se tornar inutilizável. Tem certeza de que deseja alterá-la? Clique em Sim. Pronto. Só isso mesmo.

Aproveito o espaço também para compartilhar um site que gera o gitignore automaticamente para você: https://www.gitignore.io/

Espero ter ajudado! ;)