Monthly Archives: janeiro 2015

Brincando com Material Design

Posted by rlecheta on janeiro 16, 2015
Android, Notícias / 6 Comments

Brincando com o app dos carros e Material Design para o livro Google Android 4ª edição.

Continuo brincando, agora com a toolbar rsrs

Criando libs no Gradle com Android – Parte 3

Posted by rlecheta on janeiro 15, 2015
Android, Tutorial / 4 Comments

No terceiro e último post sobre como fazer libs com gradle e Android Studio, vamos aprender a publicar um projeto no servidor do Maven Central.

1) O que é o Maven Central?

O Maven Central é um repositório de código utilizado por diversos projetos mundialmente, e foi criado pelo pessoal da Sonatype.

Ao desenvolver um projeto Android as dependências são declaradas no arquivo build.gradle. Um exemplo disso é a declaração da biblioteca de compatibilidade v7 do Google.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'
}

Mas ao declarar esta dependência de qual repositório ela é buscada?

Por padrão todas as bibliotecas são buscadas no Maven Central. Se você quiser é possível declarar o repositório mavenCentral(), mas não é preciso, pois por padrão o Gradle já o utiliza.

repositories {
    mavenCentral();
}

Então se você precisa disponibilizar uma biblioteca open-source para a comunidade você precisa disponibilizá-la no Mavel Central.

2) O site http://search.maven.org

O repositório do Maven Central está nesse link:

https://repo1.maven.org/maven2/

Mas para visualizar o conteúdo você deve buscar a biblioteca no site http://search.maven.org/.

Screenshot from 2015-01-15 14:06:37

3) Criando uma conta no JIRA da Sonatype

Chega de teoria, vamos para a parte prática. Para publicar um projeto no Maven Central você vai precisar de um login e senha que precisa ser criado no servidor Nexus da Sonatype.

Para fazer o registro é utilizado o JIRA.

1) Acesse esse link e crie uma Issue para configurar o seu projeto.

Essa Issue serve para solicitar ao pessoal do Sonatype para criar o projeto no Maven Central.

https://issues.sonatype.org/secure/CreateIssue.jspa?issuetype=21&pid=10134

Para criar uma Issue antes você precisará fazer um cadastro e obter seu login.

Na Issue você deve descrever o seu projeto, e preencher os campos como o groupId, project URL, SCM URL (ex: URL do github), etc.

Depois de criar a Issue aguarde, pois pode levar 2 dias úteis para ela ser aprovada. Você receberá as respostas pelo próprio sistema do JIRA, basta acompanhar a issue que você criou.

4) Fazendo o deploy no Nexus da Sonatype

Uma vez que a issue com a solicitação para criar o projeto foi aprovada, você receberá um e-mail com várias informações, portanto leia tudo.

Agora estamos prontos para fazer o deploy no Maven Central, mas não podemos fazer isso diretamente. É necessário antes fazer o deploy no repositório staging do Nexus da Sonatype, pois eles vão validar se o pacote está OK antes de fazer o deploy no Maven Central.

A URL deste repositório é:

https://oss.sonatype.org/service/local/staging/deploy/maven2/

E a URL para enviar snapshots é:

https://oss.sonatype.org/content/repositories/snapshots/

Para fazer o deploy no repositório do Sonatype é preciso informar alguns parâmetros sobre o controle de versão SCM, licença do código, nome do desenvolvedor, etc, e portanto eu gosto de utilizar um script criado por Chris Banes do Google.

Segue o script que faz o deploy no Maven Central.

https://raw.github.com/chrisbanes/gradle-mvn-push/master/gradle-mvn-push.gradle

Para utilizar este script basta adicioná-lo na última linha do seu arquivo build.gradle.

 

apply from: 'https://raw.github.com/chrisbanes/gradle-mvn-push/master/gradle-mvn-push.gradle'

task install(dependsOn: uploadArchives)

 

O script vai fazer o deploy no Repositório do Nexus da Sonatype, você só precisa informar alguns parâmetros. Para isso preencha o arquivo app/gradle.properties com as variáveis que o script precisa.

POM_NAME=LivroAndroidUtils
POM_PACKAGING=aar

VERSION_NAME=0.0.4
VERSION_CODE=1
GROUP=br.com.livroandroid
POM_ARTIFACT_ID=android-utils

POM_DESCRIPTION=Library used in the samples of Livro Android Book
POM_URL=https://github.com/rlecheta/LivroAndroidUtils
POM_SCM_URL=https://github.com/rlecheta/LivroAndroidUtils
POM_SCM_CONNECTION=scm:git@github.com:rlecheta/LivroAndroidUtils.git
POM_SCM_DEV_CONNECTION=scm:git@github.com:rlecheta/LivroAndroidUtils.git
POM_LICENCE_NAME=The Apache Software License, Version 2.0
POM_LICENCE_URL=http://www.apache.org/licenses/LICENSE-2.0.txt
POM_LICENCE_DIST=repo
POM_DEVELOPER_ID=rlecheta
POM_DEVELOPER_NAME=Ricardo Lecheta

Pronto está quase, agora você só precisa informar seu usuário e senha para fazer o deploy no Nexus da Sonatype, e também o arquivo gpg para assinar o build.

Screenshot from 2015-01-15 14:39:41

Este arquivo gradle.properties deve ser criado na pasta do usuário, portanto no meu caso o caminho é: /home/ricardo/.gradle/gradle.properties.

NEXUS_USERNAME=your_sonatype_nexus_user
NEXUS_PASSWORD=your_sonatype_nexus_password

signing.keyId=your_gpg_key
signing.password=your_gpg_password
signing.secretKeyRingFile=/home/ricardo/.gradle/your_gpg_file.gpg

Este arquivo não precisa ser colocado no controle de versão, e justamente por isso ele deve ficar na pasta do seu usuário. O gradle vai automaticamente ler esse arquivo ao fazer o build.

Note que você precisa preencher o usuário e senha do Nexus, e também precisa criar o arquivo gpg.

5) Criando o arquivo gpg para assinar o build

Para criar suas chaves abra um terminal e digite:

 gpg –gen-key

Screenshot from 2015-01-15 14:50:16

Depois execute o seguinte comando para listar suas chave:
gpg --list-keys

A primeira parte da linha da sua chave possui o padrão “pub XXXXX/YYYYYYYY <date>”.

O que você precisa é a parte YYYYYYYY, pois essa é a sua chave do arquivo gpg.

Screenshot from 2015-01-15 14:51:08

Por último você precisa enviar suas chaves para o servidor, portanto utilize o seguinte comando.

 gpg --keyserver hkp://keyserver.ubuntu.com --send-keys YYYYYYYY
 $ gpg --keyserver hkp://pgp.mit.edu --send-keys YYYYYYYY
 

6) Criando o arquivo gpg (No Windows)

Caso você utilize o Windows, você pode criar as chaves gpg utilizando o software Kleopatra (https://www.kde.org/applications/utilities/kleopatra/).

Ele é fácil de utilizar, basta ir no menu File > New Certificate. Depois de criar o certificado você pode exportá-lo para os servidores clicando na chave com o botão direito e utilizando a opção > Export Certificates to Server.

kleopatra

7) Executando o gradle install para publicar o build

Uma vez que tudo está configurado, execute o gradle install pelo Android Studio.

Lembre-se que fiz o gradle install depender do uploadArchives.

“task install(dependsOn: uploadArchives)”

Screenshot from 2015-01-15 14:54:31

Resultado.

Screenshot from 2015-01-15 14:54:42

8) Fazendo Close e Release do artefato

Depois de publicar seu artefato no Nexus, você precisa ir até o repositório staging e clicar em Close ou em Drop.

https://oss.sonatype.org/#stagingRepositories

O Drop é utilizado caso você viu que tem algo errado com um build e queira descartá-lo.

Ao fazer Close o servidor vai validar se você informou todos os parâmetros corretamente, mas se você seguiu este tutorial e utilizou o script do Chris Banes não deve ter problema.

Então selecione o seu projeto na lista e clique em Close. Depois de clicar em Close a validação vai começar, e se tudo estiver Ok, você verá na tab Activity a mensagem Repository Closed.

Screenshot from 2015-01-15 14:56:56

Depois de fechar o projeto ele está validado e pronto para ser publicado no Maven Central. Para isso selecione seu artefato e clique em Release.

Screenshot from 2015-01-15 14:57:22

Depois de alguns minutos você receberá um e-mail falando que o release foi efetuado, e agora seu projeto encontra-se disponível no repositório de release da Sonatype.

https://oss.sonatype.org/content/repositories/releases/

Mas para aparecer no site http://search.maven.org/ leva geralmente 1 dia útil.

Pronto, chegamos ao fim.

Agora que publiquei uma nova versão posso declarar a dependência no arquivo build.gradle de qualquer projeto, e pronto!

dependencies {

    . . .
    compile 'br.com.livroandroid:android-utils:0.0.4'
}

Obs: A biblioteca “br.com.livroandroid:android-utils” é simples e o objetivo é apenas auxiliar nas explicações do livro Google Android 4ª edição.

E para mostrar que a biblioteca está mesmo instalada no Maven Central, basta uma busca no site http://search.maven.org/. A biblioteca pode levar até 1 dia para aparecer ser encontrada aqui.

Screenshot from 2015-01-15 14:06:59

Atenção: Se for o seu primeiro release, você precisar entrar na Issue do Jira que você criou, e fazer um comentário indicando que você fez a release. Assim o time da Sonatype vai validar e habilitar o release automático para o Maven Central. Você só precisa fazer isso na primeira vez.

Para maiores informações, segue a documentação oficial.

Criando libs no Gradle com Android – Parte 2

Posted by rlecheta on janeiro 15, 2015
Android, Tutorial / 8 Comments

Na primeira parte do tutorial vimos como criar uma lib e fazer o deploy em uma pasta local do computador.

Mas provavelmente você precisa compartilhar suas libs com todo o seu time, portanto podemos instalar um servidor de repositório, que é o Nexus Sonatype.

Faça o download do Nexus Sonatype aqui.

Este é um servidor de Maven que atua como repositório de projetos. O legal é que ele possui o servidor web Jetty embutido, então basta um comando para subir o servidor do Sonatype.

1) Instalando o servidor Nexus

Download aqui.

Ao descompactar o Nexus você verá a seguinte pasta. No meu caso estou testando no Ubuntu.

Screenshot from 2015-01-15 09:36:09

Entre dentro da pasta do nexus até a pasta bin, e digite o seguinte comando para iniciar o servidor.

./nexus start

Screenshot from 2015-01-15 09:38:21

Por padrão o Nexus vai executar na pasta 8081, faça o teste: http://localhost:8081/nexus/

Screenshot from 2015-01-15 09:39:25

Ao clicar nos repositórios você verá a seguinte página. Para entender a estrutura de repositórios do Nexus veja a documentação oficial se precisar.

Screenshot from 2015-01-15 09:39:59

2) Fazendo deploy da lib no Nexus

Na parte 1 do tutorial fizemos o deploy em uma pasta local com a seguinte configuração.

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file:///home/ricardo/gradle/rep")

            pom.groupId = GROUP
            pom.artifactId = POM_ARTIFACT_ID
            pom.version = VERSION_NAME
        }
    }
}

Então basta substituir a URL do repositório para a URL do Nexus.

http://localhost:8081/nexus/content/repositories/releases/

O resultado fica assim:

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "http://localhost:8081/nexus/content/repositories/releases/"){
                authentication(userName: "admin", password: "admin123")
            }

            pom.groupId = GROUP
            pom.artifactId = POM_ARTIFACT_ID
            pom.version = VERSION_NAME
        }
    }
}
task install(dependsOn: uploadArchives)

Por padrão o usuário do Nexus é “admin”, senha “admin123”.

 

Feito isso execute a task install conforme fizemos na parte 1 do tutorial.
Screenshot from 2015-01-15 10:15:33
O resultado podemos ver no console do Android Studio. Eu acabei de fazer o deploy da versão 0.0.3 da lib de teste.

Screenshot from 2015-01-15 10:21:31

Depois de ter feito o deploy, abra o browser e veja o conteúdo do repositório. Você verá a pasta com o nome do pacote da sua lib.

http://localhost:8081/nexus/content/repositories/releases/

Screenshot from 2015-01-15 10:21:43

Então basta navegar dentro das pastas até chegar na lib.

Screenshot from 2015-01-15 10:21:58

3) Utilizando a lib em outro projeto

Na parte 1 do tutorial, o projeto que deseja utilizar a lib configurou o repositório para buscar a dependência assim:

repositories {
    maven {
        url "file:///home/ricardo/gradle/rep"
    }
}

Então basta alterar para buscar da URL do Nexus e pronto.

repositories {
    maven {
        url "http://localhost:8081/nexus/content/repositories/releases/"
    }
}

Aqui na Livetouch temos um servidor privado que somente os developers tem acesso, e o Nexus Sonatype ajuda muito neste controle.

Bom, é claro que no projeto você precisa declarar a dependência para a lib, então não esqueça.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'

    compile 'br.com.livroandroid:mylib:0.0.3'
}

Criando libs no Gradle com Android – Parte 1

Posted by rlecheta on janeiro 14, 2015
Android, Tutorial / 12 Comments

Parte 2

Parte 3

Se você está trabalhando com Android, provavelmente precise criar sua própria lib para usar internamente em seus projetos e empresa, ou até você gostaria de criar uma lib e disponibilizar para a comunidade utilizar.

Mas então, como criar uma lib? Como disponibilizá-la?

Nesta primeira parte do tutorial, vou criar uma lib que você fará o deploy localmente em seu computador.

O 1º passo é criar um projeto normal no Android Studio (não precisa nem de activity launcher). Eu criei um projeto chamado MyLib. Neste projeto você deve colocar suas classes utilitárias, recursos, etc. Enfim tudo o que você deseja reutilizar nos outros projetos.

No arquivo app/build.gradle você precisa indicar ao build do gradle que este projeto é uma lib, então adicione as seguintes linhas no início do arquivo.

apply plugin: 'com.android.library'
apply plugin: 'maven'

Depois você vai precisar adicionar no arquivo app/build.gradle as configurações sobre sua biblioteca e o local onde ela deve ser instalada, ou seja, o local onde fica o seu repositório. O repositório pode ser uma URL da internet (se existir um servidor), ou até mesmo uma pasta local do computador, que será o que vamos fazer agora.

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file:///home/ricardo/gradle/rep")

            pom.groupId = GROUP
            pom.artifactId = POM_ARTIFACT_ID
            pom.version = VERSION_NAME
        }
    }
}
task install(dependsOn: uploadArchives)

Nesta caso foi criada a task  uploadArchives que define o repositório onde a lib deve ser instalada.

A última linha desta configuração indica que a task install depende da task uploadArchives. Portanto se você executar a task install será feito também o upload da lib para o repositório.

Para que você não tenha dúvidas, segue o arquivo app/build.gradle completo.

Atenção: Veja que uma lib não tem as configurações do applicationId como um projeto normal. Veja o arquivo exemplo abaixo e deixe igual.


apply plugin: 'com.android.library'
apply plugin: 'maven'

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 21
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

uploadArchives {
    repositories {
        mavenDeployer {
            //repository(url: "file:///C:/gradle/rep/")
            repository(url: "file:///home/ricardo/gradle/rep")

            pom.groupId = GROUP
            pom.artifactId = POM_ARTIFACT_ID
            pom.version = VERSION_NAME
        }
    }
}
task install(dependsOn: uploadArchives)

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'
}

Atenção: Altere a pasta do repositório deste exemplo para uma pasta que exista em seu computador!

No arquivo app/build.gradle foi referenciado 3 propriedades importantes do build de sua lib, que é o Group, ArtifactId e Version.

pom.groupId = GROUP

pom.artifactId = POM_ARTIFACT_ID

pom.version = VERSION_NAME

Neste caso as informações podem ficar fixas no projeto, mas por questões de boas práticas são criadas estas variáveis no arquivo app/gradle.properties (se não existir crie esse arquivo).

// arquivo app/gradle.properties
POM_ARTIFACT_ID=mylib
VERSION_NAME=0.0.1
GROUP=br.com.livroandroid

O artefato id é o nome de sua lib propriamente dita, e o grupo é seu pacote. Você pode ter mais de um artefato publicado no mesmo pacote. E a versão não preciso nem explicar.

Sendo assim quando eu for utilizar essa lib em outro projeto, basta utilizar a seguinte dependência:

compile 'br.com.livroandroid:mylib:0.0.1'

Onde o formato é:

compile 'groupId:artifactId:version'

Certo mas como faço o deploy da lib?

Basicamente nesse caso posso executar a task install, pois ela depende da task uploadArchives que foi configurada no build.

Existem 3 formas simples de fazer isso:

1) Abrir um terminal no seu computador, navegar até a pasta do projeto e digitar.

gradle install

Para isso você precisa instalar o gradle no seu computador e configurá-lo no PATH para encontrar o executável. Lembre-se de instalar a versão correta que o projeto do Android Studio utiliza. Por exemplo no arquivo gradle/wrapper/gradle-wrapper.properties que está no projeto, posso ver que o Android Studio está utilizando a versão 2.2.1 do Gradle (na época deste tutorial).

// gradle/wrapper/gradle-wrapper.properties
. . .
distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip

Então neste caso no meu computador eu preciso garantir que estou utilizando esta mesma versão para fazer o build.

2) Outra maneira simples de executar e que não precisa instalar o gradle no computador é utilizar o gradle que está embutido no Studio.

Para isso abra a janela > Tools > Open Terminal do Studio.

b

O resultado é a janela terminal.

terminalb

Depois digite o seguinte comando. Note que usei a notação ./ pois estou no Linux.

./gradlew install

Obs: O arquivo gradlew é gerado pelo studio e está na pasta raiz do projeto. Tenha certeza de que ao abrir o terminal você vai estar na raiz, e não dentro da pasta app.

Ao executar este comando podemos ver o seguinte resultado na janela Terminal. Veja que o arquivo foi publicado no repositório local que configurei.

terminal3

Feito isso basta você olhar no seu computador nesta pasta que a lib foi publicada.

terminal4

Sobre o formato da lib não vou explicar pois você pode dar uma procurara no Google Estou citando apenas as partes mais importantes.

3) A 3ª maneira de fazer o deploy é executar a task install visualmente pelo Android Studio.

Basta abrir a janela Gradle Tasks que fica no canto direito superior do Studio, procurar a task intsall e executar com um clique.

Feito isso bingo! A lib será publicada.

terminal5

4) Utilizando a LIB.

OK mas e agora como faço para utilizar a lib?

Neste caso como criamos um repositório local, basta configurar este repositório no seu outro projeto e declarar a dependência.

No meu caso criei outro projeto com o nome HelloLib. Para sua conferência segue o arquivo app/build.gradle deste projeto.

 

apply plugin: 'com.android.application'

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    defaultConfig {
        applicationId "br.com.livroandroid.hellolib"
        minSdkVersion 9
        targetSdkVersion 21
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

repositories {
    maven {
        url "file:///home/ricardo/gradle/rep"
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'

    compile 'br.com.livroandroid:mylib:0.0.1'
}

É isso aí pessoal, espero que tenham gostado do tutorial. Ainda tem as partes 2 e 3.
Parte 2

Parte 3