Tutorial

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

Novo Console do Google APIs

Posted by rlecheta on dezembro 07, 2013
Android, Tutorial / Comentários desativados em Novo Console do Google APIs

Olá pessoal,

O Google recentemente mudou a interface o console do Google APIs.

https://cloud.google.com/console

Como você já sabe esta página é utilizada para obter as chaves de acesso para as APIs do Google.

Na nova interface no menu > APIs & auth > API você pode ativar os serviços que deseja utilizar, como por exemplo: Mapas ou GCM.

img1

Depois de ativar os serviços basta criar um projeto para salvar suas configurações.

Entre no menu > APIs & auth > Registered apps e clique em Register App.

No formulário digite o nome do projeto, selecione Android, digite o pacote do projeto e a chave SHA1 fingerprint. Lembrando que o SHA1 fingerprint você pode obter facilmente pelo Eclipse em > Window > Preferences > Android > Build.

Isso vai criar uma chave válida para o seu projeto/pacote e certificado que você está utilizando para fazer o build.

img2

Depois de registrar sua app você tem acesso a API Key, que deve ser inserida no AndroidManifest.xml onde precisar. Isso é utilizado nos Mapas e Push.

img3

Todos os projetos criados,  ficam armazenadas na sua conta do Google. No menu > APIs & auth > Registered apps você pode ver todos os seus projetos , caso precise consultar alguma chave.

img4

Acessando um web service SOAP no Android

Posted by rlecheta on outubro 23, 2013
Android, Tutorial / Comentários desativados em Acessando um web service SOAP no Android

Olá,

No livro Google Android 3ª edição, aliás, desde a 1ª edição, foi explicado como utilizar o ksoap2 para acessar um web service.

O fato é que muitas vezes pode ser complicado acessar um web service com SOAP, por muitas razões, e tudo depende de como o web service foi criado.

Em um projeto, precisei acessar um web service SOAP, porém ele tinha regras específicas, e o ksoap não conseguia gerar o XML SOAP correto para enviar os dados.

A solução foi fazer um HTTP POST manual no web service. A única coisa que você precisa saber, é como enviar um XML SOAP no corpo da requisição.

Se você não conhece SOAP, obter esse XML é fácil, e uma das ferramentas mais úteis é o SOAP UI.

http://www.soapui.org/

O SOAP UI permite você configurar a URL do web service , os parâmetros e disparar a requisição para obter a resposta. E o melhor de tudo é que ele vai te mostrar exatamente a entrada que é o XML do SOAP, e o retorno, que também é um XML SOAP.

Para exemplificar vamos dar um exemplo, com este web service de tempo global.

http://www.webservicex.net/globalweather.asmx?WSDL
http://www.webservicex.net/globalweather.asmx

Web Services feitos em .Net são legais, pois já mostram o XML SOAP que você deve enviar.

6.003

E se você souber o XML do SOAP de entrada, basta utilizar uma simples classe para fazer o HTTP POST.

Mas para realmente testar o Web Service e ter certeza de que ele funciona, crie um projeto no SOAP UI.

6.001

O próprio SOAP UI vai exibir os serviços disponíveis e quando você clicar, ele mostra o XML de SOAP que você deve enviar.

Neste caso eu alterei para informar Brazil e Sao Paulo para receber as informações do tempo, e cliquei no botão Enviar.

Nos logs abaixo você pode verificar o XML SOAP correto. É este o cara que você precisa enviar!. Na direita está a resposta.

6.002

Note que nos logs também é possível visualizar o header http, e tem o parâmetro Content-type=Content-Type: application/soap+xml;charset=UTF-8;action=”http://www.webserviceX.NET/GetWeather.

Neste caso a Action é http://www.webserviceX.NET/GetWeather. Note que na figura 1 na descrição do web service ele já mostrava a Action.

Isso significa que ao fazer o POST é necessário enviar exatamente este cabeçalho no header.

6.004

Para testar a teoria, copie o XML do SOAP e a Action, e crie uma activity.

Deixei o XML de forma fixa para simplificar. Mas faça como achar melhor no seu projeto.

Exemplo:

————————————————————————

public class MainActivity extends Activity {

private static final String URL = "http://www.webservicex.net/globalweather.asmx";
protected static final String TAG = MainActivity.class.getSimpleName();

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

String xmlSoapEntrada =
"<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:web=\"http://www.webserviceX.NET\">"+
" <soap:Header/>"+
" <soap:Body>"+
" <web:GetWeather>"+
" <web:CityName>Sao Paulo</web:CityName>"+
" <web:CountryName>Brazil</web:CountryName>"+
" </web:GetWeather>"+
" </soap:Body>"+
"</soap:Envelope>";

String action = "http://www.webserviceX.NET/GetWeather";

AsyncTask<String, Void, String> task = new AsyncTask<String, Void, String>() {
@Override
protected String doInBackground(String... params) {
try {
String xmlSoapEntrada = params[0];
String action = params[1];
final String soapXMLRetorno = HttpSoap.doPost(URL, xmlSoapEntrada,action);
return soapXMLRetorno;
} catch (Exception e) {
Log.e(TAG,e.getMessage(), e);
}
return null;
}

@Override
protected void onPostExecute(String xmlSoapRetorno) {
// fazer o parser aqui
Toast.makeText(getApplicationContext(), "OK ["+xmlSoapRetorno+"]", Toast.LENGTH_LONG).show();
}
};
task.execute(xmlSoapEntrada, action);
}
}

————————————————————————

E a classe que faz o POST é simples assim:

————————————————————————

public class HttpSoap {

/**
* @param url URL do web service
* @param soapXml XML SOAP de entrad
* @return XML soap de retorno
*
* @throws Exception
*/
public static String doPost(String url, String soapXml, String action) throws Exception {

// SOAP request send
HttpPost post = new HttpPost(url);
post.setEntity(new StringEntity(soapXml));
post.setHeader("Content-type", "application/soap+xml;charset=utf-8;action="+action);

HttpClient client = new DefaultHttpClient();
HttpResponse response = client.execute(post);

// SOAP response(xml) get
String res_xml = EntityUtils.toString(response.getEntity());
return res_xml;
}
}

O resultado neste exemplo simples, é que o XML do SOAP de resposta será exibido na tela com um Toast.

print

Lembre-se. É isso que o ksoap faz por debaixo dos panos. Mas nada impede que você faça isso na mão.

Agora sempre que puder utilizar um framework e automatizar essa geração e parser do XML SOAP melhor.

abraços

 

Plugin Keytool para o Eclipse

Posted by rlecheta on março 06, 2013
Android, Tutorial / Comentários desativados em Plugin Keytool para o Eclipse

Desenvolvedores Android estão acostumados a gerar as chaves MD5 a partir do certificado que é utilizado para assinar a aplicação. Esta chave pode ser utilizada para várias coisas, como por exemplo, para utilizar os Mapas.

Pela tradição, esta chave é extraída pela linha de comando. Mas se você preferir é só utilizar o plugin Keytool (http://keytool.sourceforge.net) para o Eclipse.

Com este plugin, basta escolher o arquivo .keystore que todos os dados serão exibidos visualmente.

É uma mão na roda. Vejam o resultado nesta figura.

cap16-img012

Android, iOS, Windows Phone? Como você organiza seu código mobile?

Posted by rlecheta on fevereiro 23, 2013
Tutorial / 2 Comments

Olá Pessoal,

Na Livetouch  temos muitos projetos mobile, e desenvolvemos para todas as plataformas.

Consequentemente temos que organizar nossos projetos, padronizar o código, e principalmente criar um padrão para facilitar com que os novos desenvolvedores, as vezes não acostumados com uma ou outra plataforma, consigam aprender tudo rapidamente.

Para exemplificar, vamos imaginar que precisamos salvar nas preferências do usuário algum valor simples (aquela classe simples de chave/valor que armazena no banco de dados).

No Android é utilizado a classe SharedPreferences, no iOS é a classe NSUserDefaults e no Windows Phone a IsolatedStorageSettings. Essas classes são simples, mas você precisa conhecer a API nativa para utilizá-las.

Então se um desenvolver Android X for lá no código e utilizar diretamente a classe SharedPreferences, como ele fará quando tiver que fazer o mesmo para iOS ou Windows Phone?

Ou se você é responsável por uma equipe mobile, como você garante que todos os desenvolvedores, ou as vezes aqueles que entraram para aprender, estagiários, etc, vão aprender o mais rápido possível? Como você garante que a produtividade será sempre alta, mesmo em uma nova plataforma?

Por isso eu gosto de padronizar algumas coisas, principalmente tarefas repetidas e comuns que sempre vai existir, independente da plataforma.

Para solucionar o problema das classes SharedPreferencesNSUserDefaults e IsolatedStorageSettings, vamos pensar que existe uma classe Prefs que encapsula este acesso, escondendo a API nativa do desenvolvedor.

No Android (java), essa classe poderia ser utilizada da seguinte forma.

// Salvar
Pref.setString(getContext(), “chave”, “valor”);

// Ler
String valor = Pref.getString(getContext(), “chave”);

No iOS (objective-C), se essa classe também existir, a tarefa continua simples:

// Salvar
[Prefs setString:@”chave” valor:@”valor”];

// Ler
NSString *valor = [Prefs getString:@”chave”];

E no Windows Phone (C#), qual classe vamos utilizar? Advinha:

// Salvar
Prefs.setString(“chave”, “valor”);

// Ler
String s = Prefs.getString(“nome”);

A vantagem é que não preciso conhecer a API nativa, ou me lembrar de cabeça como é que chama o método X ou Y. Basta lembrar que existe essa classe utilitária.

Este conceito de encapsulamento para esconder o código nativo facilita muito o trabalho. Você pode criar muitos padrões legais, principalmente utilizando interfaces/protocolos.

Acho que deu para entender a ideia, e na prática funciona assim:

1) Um cara novo de mobile entra na equipe e aprende Android, ou outra coisa.

2) Junto com a arquitetura do Android e coisas específicas, ele aprende a utilizar diversas classes prontas, que facilitam determinado trabalho.

3) Depois ele precisa aprender outra plataforma.

4) Ok, coisas específicas ele precisa aprender, mas as mesmas classes padronizadas estarão lá, a sua disposição.

Então se você precisar enviar um email, como fazer? O pessoal sabe que basta procurar uma classe EmailUtils, que costumamos dizer, (*)Utils.

Essa organização acredito ser uma tendência natural, a medida que a empresa começa a fazer aplicativos para diversas plataformas.

Não estou dizendo que tudo precisa ser encapsulado aqui, não vamos ser muito rigorosos :-), até porque cada plataforma possui suas peculiaridades e recomendações, mas para muitas tarefas este conceito pode ser utilizado, e pelo menos aqui tem dado certo.

E lembre-se, isso que estou falando vale para código, regras de negócio, tarefas comuns, etc, e não para a interface/design das telas. Sobre UI Guidelines, cada plataforma possui a sua, e é aquela que os usuários estão acostumados… Mas isso é uma outra conversa já muito batida.

O que vocês acham, alguém costuma fazer assim?

abraços

Instalando uma versão do Android com o fastboot

Posted by rlecheta on fevereiro 04, 2013
Android, Tutorial / 4 Comments

Olá,

Uma vez eu estava brincando com meu Android, para deixar ele com acesso root. Na época fiz uma besteira e acabei apagando completamente o sistema operacional. E no final da brincadeira, meu Android não ligava mais. Foi quando aprendi sobre uma ferramenta utilitária chamada fastboot, utilizada para enviar uma versão do sistema operacional pela USB, e formatar seu Android.

Neste tutorial vou formatar um Nexus S e instalar o Android 4.1.2 nele, mas isso vai apagar todos os dados do aparelho.

Lembre-se, se você prosseguir é por sua conta e risco, e faça um backup, pois todos os seus dados serão apagados.

Outra coisa, este tutorial foi baseado na linha Google Nexus, e testado especificamente para o Nexus S. A vantagem dos devices da linha Nexus é que é fácil encontrar as imagens do sistema operacional compilada para estes devices, pois são disponibilizadas pelo Google neste link:

https://developers.google.com/android/nexus/images

Vamos seguir os seguintes passos.

1) Baixe a imagem correta para seu device. Neste tutorial estou utilizando o Nexus S.

Então eu procurei esta versão: “Factory Images “soju” for Nexus S (worldwide version, i9020t and i9023)”

Baixe q versão que quiser, por exemplo a 2.3.6 ou 4.1.2.

img001

2) Instale o Android SDK

Para prosseguir com este tutorial, você precisa instalar o Android SDK.

Vamos utilizar as ferramentas adb e fastboot localizadas na pasta /android-sdk/platform-tools.

3) Instale o Driver

Este tutorial é para desenvolvedores, então você já sabe que precisa instalar o driver. O driver da linha Nexus é inclusive disponibilizado pelo SDK Manager.

Como eu sei que você já está com o driver instalado, conecte seu device na USB e digite o comando “adb devices”. O resultado deve ser o seguinte.

C:\android-sdk-windows\platform-tools>adb devices
List of devices attached
3334F3D59BBD00EC device

Lembre-se de ativar o modo USB no menu de desenvolvedores. Se seu device não for listado aqui, revise a instalação do driver.

4) Entre no bootloader

Todo Android possui um bootloader, que é um conjunto de instruções que executa antes do sistema operacional. Você pode entrar no bootloader se deseja brincar com coisas avançadas, como instalar uma nova versão do Android no seu apaelho, que é o que vamos fazer aqui.

Para entrar no bootloader podemos fazer de duas formas. Recomendo testar as duas.

A primeira é deixar seu Android ligado e conectado na USB. Depois digite este comando no prompt:

adb reboot bootloader

A segunda é desligar seu Android (power off). Depois pressione o botão do Volume + e logo depois o Power. E mantenha pressionado os dois por alguns segundos, tipo 1 ou 2.

Ao entrar no bootloader você verá uma tela como esta:

Repare no texto LOCK STATE – LOCKED.

02-bootloader

5) Desbloqueando o bootloader

No bootloader repare na mensagem: LOCK STATE – LOCKED

Isto indica que o bootloader está travado por motivos de segurança, e para formatar o Android precisamos destravá-lo.

Este passo muda de fabricante e fabricante, e por isso eu prefiro a linha Nexus, pois o suporte do Google para desenvolvedores é melhor.

O problema de destravar o bootloader é que todos os dados serão apagados, e portanto, faça backup e somente prossiga se você tiver certeza do que está fazendo.

Digite este comando no prompt:

C:\android-sdk-windows\platform-tools>fastboot devices
3334F3D59BBD00EC fastboot

Se você conseguir visualizar seu device novamente conectado na USB, ótimo. No Linux e Mac você não vai ter problemas. Mas no Windows é necessário instalar o driver, e o driver utilizado para desenvolvimento não e compatível com este do bootloader. Você pode baixar e instalar o famoso PDANET http://www.junefabrics.com/android/download.php

Depois de instalar o driver digite novamente o comando “fastsboot devices” e somente prossiga se você conseguir visualizar seu Android conectado na USB.

Para desbloquear o bootloader digite este comando:

fastboot oem unlock

Feito isso você deverá ver na tela do seu Android uma mensagem alertando que todos os dados serão apagados, e se você deseja prosseguir.

03-bootloader-unlock

Leia cuidadosamente a mensagem, e se tem certeza que deseja continuar, utilize o botão do Volume + para selecionar a opção Yes. Depois pressione o botão Power para confirmar.

Isto vai desbloquear o bootloader e agora você verá a mesma tela do bootloader, mas com a mensagem LOCK STATE – UNLOCKED, indicando que ele foi destravado.

Neste momento não instalamos nenhuma versão do Android, mas lembre-se que seus dados foram apagado e portanot se você reiniciar o device agora, será como se fosse a primeira vez que está ligando seu Android.

04-bootloader-unlock-ok

6) Preparando o ambiente

Eu baixei as imagens do Android Nexus S, versão 2.3.6 e 4.1.2.

Primeiro eu instalei a versão 2.3.6 nele, e podemos ver no menu > Settings > About que está com a versão 2.3.6 agora:

05-2.3.6

Ok, esta foto é para comprovar que a atualização vai funcionar, pois vamos atualizar para o Android 4.1.2.

Lembre-se que agora você deve estar no bootloader e o comando “fastboot devices” deve reconhecer seu Android normalmente.

Depois de baixar o arquivo soju-jzo54k-factory-36602333.tgz, que é do Nexus S Android 4.1.2, descompacte o zip em algum lugar. O resultado deve ser estes arquivos.

img002

Basicamente aqui temos os seguintes arquivos:

  • flash-all.sh: é o script que você vai executar.
  • bootloader-**.img: é a nova imagem do bootloader que será formatada
  • radio-crespo-***: é a nova imagem de radio que será formatada
  • image-soju-jzo54k: é a imagem do Android 4.1.2 que vamos instalar agora

Basta executar o comando flash-all.sh que ele vai executar diversos comandos, que vão instalar estas imagens no seu aparelho!

O arquivo flash-all.sh possui o seguinte conteúdo:

fastboot flash bootloader bootloader-crespo-i9020xxlc2.img
fastboot reboot-bootloader
sleep 5
fastboot flash radio radio-crespo-i9020xxki1.img
fastboot reboot-bootloader
sleep 5
fastboot -w update image-soju-jzo54k.zip

Note que para estes comandos funcionarem a ferramenta fastboot precisa estar no path, e lembre-se ela se encontra na pasta /android-sdk/platform-tools:

Eu gosto por motivos de praticidade, copiar todos estes arquivos par a pasta /android-sdk/platform-tools.

Assim o problema está resolvido e todos os arquivos estão no mesmo lugar.

Agora execute o arquivo flash-all.sh ou flash-all.bat e BOOM!

Ao executar você verá os seguintes logs no prompt, enquanto a instalação é efetuada. O processo deve demorar uns 2 ou 3 minutos.

C:\android-sdk-windows\platform-tools>flash-all.bat
sending ‘bootloader’ (1536 KB)…
OKAY [ 0.205s]
writing ‘bootloader’…
OKAY [ 0.351s]
finished. total time: 0.565s
rebooting into bootloader…
OKAY [ 0.009s]
finished. total time: 0.012s
< waiting for device >
sending ‘radio’ (12288 KB)…
OKAY [ 1.550s]
writing ‘radio’…
OKAY [ 1.684s]
finished. total time: 3.243s
rebooting into bootloader…
OKAY [ 0.009s]
finished. total time: 0.012s
< waiting for device >
archive does not contain ‘boot.sig’
archive does not contain ‘recovery.sig’
archive does not contain ‘system.sig’
——————————————–
Bootloader Version…: I9020XXLC2
Baseband Version…..: I9020XXKI1
Serial Number……..: 3334F3D59BBD00EC
——————————————–
checking product…
OKAY [ 0.002s]
checking version-bootloader…
OKAY [ 0.002s]
checking version-baseband…
OKAY [ 0.003s]
sending ‘boot’ (3964 KB)…
OKAY [ 0.499s]
writing ‘boot’…
OKAY [ 0.507s]
sending ‘recovery’ (4308 KB)…
OKAY [ 0.549s]
writing ‘recovery’…
OKAY [ 0.549s]
sending ‘system’ (337443 KB)…
OKAY [ 42.392s]
writing ‘system’…
OKAY [ 40.266s]
erasing ‘userdata’…
OKAY [ 0.429s]
formatting ‘userdata’ partition…
Erase successful, but not automatically formatting.
Can’t determine partition type.
OKAY [ 0.057s]
erasing ‘cache’…
OKAY [ 2.004s]
formatting ‘cache’ partition…
Erase successful, but not automatically formatting.
Can’t determine partition type.
OKAY [ 0.009s]
rebooting…

finished. total time: 87.316s

Logo depois de instalar a nova imagem do sistema operacional, seu Android vai reiniciar e você verá a tela de Boas Vindas para que você configure o Android, como se acabasse de ter comprado um aparelho novo. Agora siga os passos normalmente, como entrar com seu login do Gmail e pronto.

06-ok

Se você quiser ver na prática resultado do comando flash-all.sh eu filmei este vídeo enquanto fiz este procedimento, confira abaixo.

Este tutorial mostrou como atualizar a imagem do sistema operacional em um Nexus S. Lembre-se que dependendo do fabricante estes passos podem ser outros.

O principal objetivo deste tutorial foi demonstrar a ferramenta fastboot, que faz um excelente trabalho.

API de Vídeos do Youtube – exemplo de código

Posted by rlecheta on janeiro 23, 2013
Android, Tutorial / 3 Comments

A pedidos, segue exemplo de código de como reproduzir um vídeo do Youtube no Android, utilizando a API.

1) Primeiramente baixe a  YouTube Android Player API e descompacte o arquivo zip.

2) No Eclipse, crie um projeto chamado YoutubeDemo.

3) Copie o arquivo YouTubeAndroidPlayerApi.jar que você baixou, para a pasta “libs” do projeto.

E no seu projeto, adicione a permissão para utilizar a internet.

<uses-permission android:name=”android.permission.INTERNET”/>

4) Agora vamos criar um simples arquivo de layout no arquivo /res/layoutactivity_main.xml

Note que a view do player do Youtube é adicionada no layout

<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
xmlns:tools=”http://schemas.android.com/tools”
android:layout_width=”match_parent”
android:layout_height=”match_parent”
android:orientation=”vertical” >

<com.google.android.youtube.player.YouTubePlayerView
android:id=”@+id/youtube_view”
android:layout_width=”match_parent”
android:layout_height=”match_parent” />

</LinearLayout>

5) Sua activity precisa herdade de YouTubeBaseActivity, e para facilitar vamos criar uma activity simples que vai iniciar o player e verificar os resultados.


public abstract class YouTubeFailureRecoveryActivity extends YouTubeBaseActivity implements YouTubePlayer.OnInitializedListener {

private static final int RECOVERY_DIALOG_REQUEST = 1;

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult errorReason) {
if (errorReason.isUserRecoverableError()) {
errorReason.getErrorDialog(this, RECOVERY_DIALOG_REQUEST).show();
} else {
String errorMessage = String.format(getString(R.string.error_player), errorReason.toString());
Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
}
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == RECOVERY_DIALOG_REQUEST) {
// Retry initialization if user performed a recovery action
getYouTubePlayerProvider().initialize(DeveloperKey.DEVELOPER_KEY, this);
}
}

protected abstract YouTubePlayer.Provider getYouTubePlayerProvider();

}

Esta classe é abstrata e cuida da inicialização do player e do tratamento de erros.

6) Crie a activity final da seguinte forma.

Note que basicamente a view do player é recuperada do layout e inicializada.

Depois basta chamar o método player.cueVideo(“video_id”) informando o id do vídeo para iniciar a reprodução.


public class MainActivity extends YouTubeFailureRecoveryActivity {
<blockquote>@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

YouTubePlayerView youtubeView = (YouTubePlayerView) findViewById(R.id.youtube_view);
youtubeView.initialize(DeveloperKey.DEVELOPER_KEY, this);
}

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player, boolean wasRestored) {
if (!wasRestored) {
player.cueVideo("33NOE1XhXBM");
}
}

@Override
protected YouTubePlayer.Provider getYouTubePlayerProvider() {
return (YouTubePlayerView) findViewById(R.id.youtube_view);
}
}

7) Crie um projeto no Console APIs para criar a chave de desenvolvedor para a API do Youtube

Note que o código utiliza a constante DeveloperKey.DEVELOPER_KEY, e você precisa preencher esta constante com sua chave de desenvolvedor.

Entre no console e crie um projeto.

https://code.google.com/apis/console/

O processo para gerar a chave é simples e você pode ver neste link.

https://developers.google.com/youtube/android/player/register

Apenas para ajudar, lembre-se de no menu Services, habilitar o serviço do Youtube conforme a figura abaixo.

img004

Depois entre no menu API Access clique no botão Create new Android Key.

A entrada deve ser o SHAI fingerprint de seu certificado de desenvolvimento + “;” + o seu pacote.

img005

Depois de gerar a chave ela estará disponível no console, portanto copie-a.

img006

Esta chave é justamente a constante DeveloperKey.DEVELOPER_KEY que é utilizada no código.


public class DeveloperKey {

public static final String DEVELOPER_KEY = "AIzaSyAZkytO4O8J5ZoMD-CgYZ-Z83HlOhOB-Z8";

}

8) Parabéns, agora execute o código e veja o vídeo do Youtube executando em seu Android!

youtube_demo

API de Vídeos do Youtube no Android

Posted by rlecheta on janeiro 22, 2013
Android, Tutorial / Comentários desativados em API de Vídeos do Youtube no Android

Sua app Android precisa exibir um vídeo do Youtube com alta qualidade?

O Google lançou uma API experta para reproduzir vídeos do Youtube no Android, com os seguintes benefícios:

* Suporte à reprodução de alta qualidade em Android 2.2 (Froyo) ou mais recentes
* Fácil integração com a sua aplicação (não requer o uso de WebView)
* Suporte à tela cheia e mudança de orientação
* Exibição de legendas
* Suporte aos anúncios do YouTube (YouTube ads)
* Acesso programático, similar ao já existente para a Player APIs, para a maioria dos aspectos da experiência de reprodução de vídeos no YouTube.
* Integração com a aplicação nativa do YouTube usando o conjunto padrão de Intents do YouTube.

youtube

Basicamente você vai adicionar a biblioteca no seu projeto e utilizar os componentes YouTubePlayerView ou YouTubePlayerFragment.

O projeto de exemplo pode se encontrado aqui:

http://code.google.com/p/youtube-api-samples/

Confira mais detalhes no blog do Youtube!

http://apiblog.youtube.com/2012/12/no-webview-required-with-native-youtube.html