Tutorial

Compartilhando arquivos no Android 7 (Nougat) e a exception FileUriExposedException

Posted by rlecheta on novembro 03, 2016
Android, Tutorial / 3 Comments

É raro termos algum erro de compatibilidade ao atualizar as versões do Android no aplicativo, mas no caso do Android 7 (Nougat) temos a exception FileUriExposedException.

Se você ainda não se deparou com ela, logo irá.

Digamos que você possui um aplicativo que tire fotos. Para exemplificar, temos este trecho de código que cria um arquivo e chama a Intent da câmera:

screen-shot-2016-11-02-at-19-26-24

Tudo normal com o código certo? Mas se você atualizar o seu projeto para compilar com a API 24/25 (Android 7) verá uma exception igual esta:

screen-shot-2016-11-02-at-19-14-35

Segundo a documentação do Android, esta exception é lançada ao expor um arquivo por uma Uri para outra aplicação. Neste caso, o erro é porque estamos expondo o arquivo que criamos para a aplicação nativa da câmera, pois a câmera precisa salvar a foto neste arquivo.

https://developer.android.com/reference/android/os/FileUriExposedException.html

Sem mais demoras, vamos logo a solução:

Edite o arquivo AndroidManifest.xml e adicione a tag <provider> dentro da tag <application> .

Exemplo: AndroidManifest.xml

screen-shot-2016-11-02-at-19-19-45

Veja que dentro de <meta-data> é referenciado um arquivo XML @xml/provider_paths com a configuração de compartilhamento para os arquivos da aplicação, neste caso vamos colocar o “.”, para compartilhar tudo desde a raiz.

Exemplo: provider_paths.xml

screen-shot-2016-11-02-at-19-20-46

Feito estas configurações no projeto, basta trocar a linha que cria a Uri do arquivo:

Uri uri = Uri.fromFile(file);

Por esta:

Uri uri = FileProvider.getUriForFile(context, context.getApplicationContext().getPackageName() + “.provider”, file);

Então, o código que chama a Intent da câmera que mostrei anteriormente fica assim:

screen-shot-2016-11-02-at-19-33-55

Exemplo: CameraUtil.java

Pronto! Agora podemos tirar fotos no Android 7 (Nougat). Espero que esta dica ajude alguém 🙂

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

device-2016-11-02-193556

Temas no Android: O que fazer se a Action Bar estiver nula.

Posted by rlecheta on outubro 07, 2016
Android, Livro Android, Tutorial / 2 Comments

Olá pessoal, recentemente um leitor da 4a edição do livro de Android veio tirar uma dúvida sobre um erro que acontecia com um exemplo do capítulo 4.

No caso a activity estava herdando de android.app.Activity.


public class AlgumaActivity extends Activity {

... código aqui

// dava erro nessa linha

getActionBar().setDisplayHomeAsUpEnabled(true);

}

O erro reportado foi que dava NullPointer ao acessar a action bar.

OK, mas porque isso acontece?

Na maioria das vezes, se a action bar está nula com certeza é a configuração do tema.

Olhando o styles.xml do meu colega, o tema do projeto estava configurado assim:

a

Vejam que está usando o tema AppCompat, que traz a compatibilidade para várias versões do Android. Este tema substitui os temas Holo, Material, etc e atualmente é recomendado pelo Google. Isso é o esperado mesmo e está correto, pois o Android Studio atualmente gera o projeto desta forma.

O problema é que na época que escrevi a 4a edição do livro, os exemplos eram gerados de outra forma pelo Android Studio, inclusive no github da 4ed está assim:

https://github.com/livroandroid/4ed/blob/master/capitulos/cap04-activity/HelloActivity/app/src/main/res/values/styles.xml

b

Veja que o tema que usei na época da 4ed foi o Holo, que é um específico para Android 3 (API Level 11). Enfim, mas isso está explicado no livro e não quero demorar aqui…

O livro 5a ed que está mais atualizado já traz os exemplos todos com o tema de compatibilidade, portanto este problema acontece apenas nos exemplos da 4 ed, pois o Android Studio mudou a forma de gerar o código dos projetos.

Bom, existem 2 formas de resolver este problema:

1) Caso você queira deixar o código das classes de Activity iguais estavam nos exemplos da 4ed, é preciso alterar o tema do projeto para Holo ou Material, conforme o github da 4ed. Isso é feito alterando o arquivo styles.xml conforme o exemplo que mostrei acima do github.

Basicamente, se o seu tema herda de Holo ou Material, você está usando um tema nativo. Então vc deve sempre usar a android.app.Activity como a activity mãe, e neste caso você pode utilizar o método getActionBar() que retorna a action bar nativa android.app.ActionBar.

Era dessa forma que era feito nos primeiros exemplos da 4 ed. Somente no capítulo de Action Bar que começo a explicar o tema AppCompat de compatibilidade.

2) A segunda forma de resolver, e talvez a recomendada é atualizar o código de todas as Activities para herdar de android.support.v7.app.AppCompatActivity, pois é a activity do tema de compatibilidade. Atualmente o Android Studio gera o projeto com o tema AppCompat, como vimos no styles.xml do meu colega logo no início deste post. Isto indica que o projeto usa o tema de compatibilidade.

Esta configuração de tema atualmente é a indicada. Porém como o fonte da 4ed está antigo, faça as seguintes alterações no código:

  • Altere todas as activities do projeto para herdar de AppCompatActivity.
  • Altere a chamada do método getActionBar() por getSupportActionBar(), pois este último vai retornar a action bar de compatibilidade, que é a classe android.support.v7.app.ActionBar.

Como o Android Studio atualmente gera o projeto com o tema de compatibilidade, na 5ed do livro todos os exemplos já estão assim.

É isso pessoal, este breve post foi só para explicar uma pequena diferença entre a 4ed e a 5ed. Como vimos o Android Studio mudou a forma de gerar os códigos do projeto e isso afetou um pouco, e essas coisas de tema e compatibilidade costumam ser complicadas para quem está estudando Android pela primeira vez :-).

Independente de como estão os códigos-fontes da 4ed e 5ed, estes conceitos é bom conhecer.

Qualquer dúvida perguntem, abs.

Tags:

Enviando mensagens de Push com o Firebase Cloud Messaging (FCM) – parte 2

Posted by rlecheta on julho 31, 2016
Android, Tutorial / 16 Comments

Olá pessoal, na Parte 1 deste tutorial aprendemos a criar um app Android para receber mensagens de Push utilizando o Firebase.

Se você ainda não leu, segue link da 1ª parte.

http://ricardolecheta.com.br/?p=862

Na 2ª parte do Tutorial vamos ver como fazer:

  1. Enviar mensagens de Push pelo web service do Firebase (sem utilizar o console);
  2. Exemplo de como ler mensagens do tipo chave=valor no Android.

Vimos que podemos usar o console do Firebase para enviar as mensagens de Push, mas muita gente tem me perguntado como que faz para enviar a mensagem manualmente no código.

Para enviar uma mensagem de Push, basta postar no web service do Firebase um JSON contendo as informações necessárias.

A figura abaixo mostra o endereço URL do endpoint do web service e os parâmetros que precisam ser enviados:

a

Veja que o endpoint do web service do Firebase é:

https://fcm.googleapis.com/fcm/send

Obs: se você não está acostumado com o termo, “endpoint” refere-se a URL de um web service.

Algo importante da requisição, é que ela deve ser feita via POST, e deve-se enviar no cabeçalho HTTP os parâmetros Content-TypeAuthorization.

O valor parâmetro Authorization é igual a “key=SUA_SERVER_KEY”.

A SERVER_KEY do FCM pode ser encontrada na página do Console, dentro das configurações do seu projeto.

Dentro da página do seu projeto, clique em Configurações conforme indicado na figura e depois no link Project Settings. Então entre na tab Cloud Messaging, onde você verá sua SERVER KEY.

b

No meu caso, o valor do parâmetro Authorization ficou assim:

key=AIzaSyBwaM5NAiGSGoft1gIESiuRaVcQTlxHe8E

Se você é novo em programação, procure sobre como fazer requisições HTTP na linguagem que você está programando, seja PHP, Java, Python, etc.. todas tem uma forma de fazer esta requisição.

Eu gosto de testar web services utilizando o plugin Postman do Chrome, pois é simples e prático. Para brincar vamos fazer um teste rápido 🙂

No Postman, siga os seguintes passos:

1) Configure o modo de envio para POST e digite a URL do endpoint do Firebase: https://fcm.googleapis.com/fcm/send

c

2) Clique em Headers e adicione os cabeçalhos Content-TypeAuthorization

Content-Type = application/json

Authorization = key=AIzaSyBwaM5NAiGSGoft1gIESiuRaVcQTlxHe8E

Lembre-se de colocar a sua SERVER_KEY.

d

3) Clique em Body e selecione a opção raw

Digite o seguinte JSON para enviar uma notificação:

{
 "to" : "Digite o Token (registration id) do dispositivo aqui",
 "notification" : {
 "title" : "Mensagem para o Firebase",
 "body" : "Teste firebase"
 }, 
 "data" : {
 "nome" : "Ricardo",
 "sobrenome" : "Lecheta"
 }
}

A figura a seguir mostra como fiz no Postman. Depois de preencher tudo corretamente, é só clicar no botão Send e pronto! Você verá lá em baixo o JSON de resposta do servidor do Google.

g

Veja que no JSON que enviei, mandei tanto o campo “notification” que possui os dados para mostrar o alerta de notificação no dispositivo (title e body), assim como foi enviado a estrutura “data” com os parâmetros com chave e valor.

Neste caso enviei os seguintes parâmetros:

nome=Ricardo

sobrenome=Lecheta

No código, basta ler estes parâmetros conforme mostra a figura abaixo.

Tinham me perguntado como fazer para ler os dados enviados, então é exatamente desta forma que deve-se fazer 🙂

f

Vale lembrar que o Firebase vai mostrar a notificação somente se o aplicativo estiver em background. Caso ele esteja aberto, você deverá ler a mensagem e mostrar a notificação/alerta manualmente.

É isso pessoal, espero que este tutorial tenha ajudado e qualquer dúvida é só perguntar 🙂 , abs.

Enviando mensagens de Push com o Firebase Cloud Messaging (FCM)

Posted by rlecheta on julho 25, 2016
Android, Tutorial / 40 Comments

Olá pessoal.

Esta é a 1ª parte do Tutorial. A 2ª parte está aqui.

No Google I/O 2016 o Google anunciou o Firebase, uma plataforma completa com diversos serviços comuns a aplicativos móveis como analytics, crash reports, notificações push, dentre outros.

firebase

Muito tem se falado do Firebase nos últimos meses, portanto serei rápido neste post. O mais importante que você precisa saber para seguir este tutorial é que ele deve levar no máximo 10 a 15 minutos, e as mensagens de Push do Firebase são gratuitas 🙂

No livro Google Android 5a ed, explico como enviar mensagens de Push no Android com o GCM (Google Cloud Message).

Capa_AndroidLecheta4ed_FINAL

Porém como o GCM foi migrado para o FCM (Firebase Cloud Messaging), é justo atualizar os leitores do meu livro com as novidades 🙂

Neste rápido tutorial vamos aprender a enviar mensagens de Push com a nova plataforma do Firebase, e o projeto que vamos fazer é baseado na documentação do Firebase, disponível neste link:

Set Up a Firebase Cloud Messaging Client App on Android

No github do Firebase você poderá encontrar diversos exemplos, inclusive o quickstart sobre o FCM. Os códigos deste tutorial, serão baseados neste quickstart.

https://github.com/firebase/quickstart-android/tree/master/messaging

Partiu pro código!

1) Passo 1 – Criar o projeto.

Crie um projeto no Android Studio conforme a figura abaixo. Eu escolhi o template Empty Activity.

Tenha atenção no nome do pacote que você vai escolher para o projeto, pois essa informação será necessária depois para configurar o Firebase.

001

2) Configurar o Firebase no Console.

Acesse a página do console do Firebase com sua conta do Google e clique no botão Create New Project.

https://console.firebase.google.com/

002

Escolha um nome para seu projeto, selecione o Brasil como país e prossiga.

Depois de criar seu projeto, você verá a página de administração do Firebase.

003

O Firebase possui APIs para Android, iOS e Web. Neste tutorial estamos criando um app Android, portanto clique no botão Add Firebase to your Android app para configurar o projeto.

No wizard insira o nome do seu pacote, o SHA1 do seu certificado e clique em Add App.

004

Siga o wizard, e no passo 2 faça o download do arquivo google-services.json conforme indicado na figura. Este arquivo contem as configurações da sua conta do Firebase e deve ficar dentro do módulo app do projeto, conforme indicado na figura.

005

No último passo do wizard, temos as instruções de como configurar o gradle. É só copiar o código e colar no local indicado. Veja que devemos alterar o arquivo build.gradle da raiz do projeto, e depois o arquivo app/build.gradle do módulo app.
006

Pronto! Agora vamos voltar ao projeto Android.

3) Configuração do projeto Android.

Crie a classe MyFirebaseInstanceIDService conforme o código deste link:

https://github.com/firebase/quickstart-android/blob/master/messaging/app/src/main/java/com/google/firebase/quickstart/fcm/MyFirebaseInstanceIDService.java

Veja que vamos usar o próprio exemplo de quickstart do Firebase, assim não temos como errar :-).

Nesta classe, o método onTokenRefresh() é chamado quando o aplicativo receber um token (registration id). Como você aprendeu no livro Google Android 5ed, este token representa o identificador do dispositivo e precisa ser enviado ao seu servidor, pois com ele é possível enviar uma mensagem para este dispositivo.

 

@Override
 public void onTokenRefresh() {
 // Get updated InstanceID token.
 String refreshedToken = FirebaseInstanceId.getInstance().getToken();
 Log.d(TAG, "Refreshed token: " + refreshedToken);

// TODO: Implement this method to send any registration to your app's servers.
 sendRegistrationToServer(refreshedToken);
 }

Feito isso, crie a classe MyFirebaseMessagingService. Ela será responsável por receber as mensagens de push e criar notificações para avisar ao usuário.

Novamente, vamos copiar a classe de exemplo do quickstart do Firebase.

https://github.com/firebase/quickstart-android/blob/master/messaging/app/src/main/java/com/google/firebase/quickstart/fcm/MyFirebaseMessagingService.java

O método onMessageReceived(msg) é chamado quando uma notificação de Push é recebida, simples assim 🙂


@Override
 public void onMessageReceived(RemoteMessage remoteMessage) {
 // Faça algo aqui como mostrar uma notificação.
 }

Depois de criar estes 2 serviços  do Firebase, é preciso cadastrá-los no AndroidManifest.xml, conforme mostra a figura abaixo.

b

c

Para ajudar, copie o trecho de código do manifest dos exemplos do Firebase.

https://github.com/firebase/quickstart-android/blob/master/messaging/app/src/main/AndroidManifest.xml

Ao rodar o aplicativo você verá a mensagem que o token deste dispositivo foi gerado com sucesso. Funciona mesmo no emulador do Android SDK.


I/FirebaseInitProvider: FirebaseApp initialization successful
07-23 21:04:53.633 16360-16514/br.com.livroandroid.hellofirebasemessaging D/MyFirebaseIIDService: &amp;amp;amp;amp;lt;strong&amp;amp;amp;amp;gt;Refreshed token&amp;amp;amp;amp;lt;/strong&amp;amp;amp;amp;gt;: cJmLLI-dIR0:APA91bGtuSyWqc-T7kBx_eeC2ANJbBmyl2v1zlZ74afrRiqyJOC0Y7apmfdcDuuKL0JX2_gDpGW-xzROEQS3qKYRXNTfMOloSYoE8o3dqOJobeXTsLHG4jbSU1lQ5JV2-LEM9jN5B_BI

4) Enviando uma mensagem pelo console do Firebase.

Já temos tudo configurado, e só falta enviarmos uma mensagem para testar o Push. O legal do Firebase é que isso pode ser feito pela sua própria página de console.

No console do Firebase, acesse o menu Notifications e envie uma notificação. Basta preencher o campo Message text e selecionar o aplicativo com o seu pacote no campo Target.

d

Ao enviar uma mensagem com o aplicativo aberto, você verá no LogCat conforme indicado na figura abaixo 🙂

MyFirebaseMsgService: Message Notification Body: Hello Firebase!

e

Agora pressione o botão Home do Android e deixe o aplicativo em background. Neste caso ao enviar a mensagem o Firebase vai mostrar uma notificação automaticamente, conforme este print.

f

Veja que a notificação só foi exibida com o app em background, e este é o comportamento padrão do firebase.

Basicamente, existem 2 tipos de mensagens: data messages (pares de chave=valor) e notification messages.

1) As mensagens do tipo data messages são sempre recebidas no método onMessageReceived(removeMessage), independente se o app está aberto ou em background.

Para identificar se a mensagem é do tipo data message, basta verificar se o método getData() retorna um Map com registros (chave=valor).

if (remoteMessage.getData().size() &gt; 0) {
&nbsp; &nbsp;Log.d(TAG, "Message data payload: " + remoteMessage.getData());
}

Neste caso o desenvolvedor é sempre responsável por mostrar uma notificação para o usuário, ou seja, é preciso programar para mostrar a notificação. No código de exemplo do firebase tem até um exemplo disso basta descomentar o código.

Para enviar uma mensagem do tipo data message pelo console do Firebase, entre em opções avançadas e preencha a estrutura de chave=valor, é bem simples. Depois no app você poderá ler os valores.

2) As mensagens do tipo notification messages possuem um comportamento um pouco diferente, e foi esta mensagem que enviamos, pois ela não continha nenhum parâmetro do tipo (chave=valor).

Neste tipo de mensagem, se o app está aberto o método onMessageReceived(removeMessage) é executado. Neste caso, o desenvolvedor é responsável por programar a leitura da mensagem e mostrar a notificação para o usuário. Porém, caso o app esteja em background o Firebase vai mostrar uma notificação automaticamente para o usuário. Ao clicar na notificação os dados da mensagem de push serão enviados para a activity principal do aplicativo, então é só fazer o tratamento ao abrir o app e pronto 🙂

Para maiores detalhes sobre os tipos de notificações veja esse link:

https://firebase.google.com/docs/cloud-messaging/concept-options

É isso pessoal 🙂 Espero que este breve tutorial tenha ajudado a entender um pouco sobre como enviar mensagens de Push com o Firebase. Vale lembrar que o Google ainda vai dar suporte para o GCM um bom tempo, até porque existem muitas aplicações que estão utilizando este serviço em produção. Mas para novos apps, recomenda-se utilizar o Firebase.

Uma dica é usar o Firebase também para aplicativos iOS, pois o serviço de Push do Google é bem mais simples que o serviço da APNS (Apple Push Notification Service) da Apple.

Se você gostou, confira a 2ª parte do tutorial aqui.

Abs

 

Paginação com web services

Posted by rlecheta on junho 27, 2016
Tutorial, Web Services / 4 Comments

Olá pessoal

Sempre recebo perguntas de como fazer paginação ao fazer um web service, pois no meu livro de Web Services os exemplos sempre retornam todos os registros do banco de dados.

rest

Por exemplo, neste web service é retornado todos os carros do servidor:

http://livrowebservices.com.br/rest/carros

E para quem leu o livro de REST, sabe que podemos buscar os carros por tipo, dentre outras buscas, exemplo:

http://livrowebservices.com.br/rest/carros/tipo/classicos

http://livrowebservices.com.br/rest/carros/tipo/esportivos

http://livrowebservices.com.br/rest/carros/tipo/luxo

Mas e se existir 1 milhão de registros no banco de dados? Neste caso o recomendado é retornar os registros paginados, por exemplo de 10 em 10, ou 20 em 20, conforme a necessidade.

Fazer isso é simples, então se você tem o código-fonte do projeto RESTful dos carros, é só fazer 2 pequenas alterações:

Na classe CarrosResource, tem um exemplo do tipo GET configurado, o qual retorna todos os carros no formato JSON, lembra-se?

@GET
public List<Carro> get() {
	List<Carro> carros = carroService.getCarros();
	return carros;
}

O que podemos fazer é adicionar 2 parâmetros. Um deles para indicar a página que você está solicitando e outro para indicar a quantidade de registros que devem ser retornados.

Exemplo:

@GET
@Path("/page/{page}/max/{max}")
public List<Carro> get(@PathParam("page") int page,@PathParam("max") int max) {
	List<Carro> carros = carroService.getCarros(page,max);
	return carros;
}

Isso vai criar os seguintes links do web service:

1ª página: http://livrowebservices.com.br/rest/carros/page/0/max/5

2ª página: http://livrowebservices.com.br/rest/carros/page/1/max/5

3ª página: http://livrowebservices.com.br/rest/carros/page/2/max/5

Veja que a 1ª página começa em zero (0) e neste exemplo solicitei que o servidor retorne sempre 5 carros.

E por aí vai…

Para o exemplo compilar, crie o seguinte método na classe CarroDAO.

public List<Carro> getCarros(int page, int max) {
	Query q = getSession().createQuery("from Carro");
	setPage(q, page, max);
	List<Carro> carros = q.list();
	return carros;
}

O framework Hibernate que estudamos no livro nos ajuda a fazer a paginação. Eu gosto de criar um método setPage(…) como esse:

protected void setPage(Query q, int page, int max) {
	// Paginação
	int firstResult = 0;
	if (page != 0) {
		firstResult = page * max;
	}
	q.setFirstResult(firstResult);
	q.setMaxResults(max);
}

Bom é isso 🙂 Se alguém tiver alguma dúvida avisa, pois o conceito é bem simples.

Com web services paginados, o correto seria alterar os aplicativos mobile para buscar sempre de 10 em 10 registros, por exemplo. Oas isso fica para uma próxima vez 🙂

abraço

 

Sistema de permissões do Android 6.0

Posted by rlecheta on outubro 02, 2015
Android, Tutorial / 10 Comments

Olá pessoal, este post visa explicar um recurso importante do Android 6.0 (Marshmallow) que se você não conhecer pode quebrar seu aplicativo.

A partir do Android 6.0 (API 23) os aplicativos precisam pedir permissões em tempo de execução para utilizar determinadas APIs, como por exemplo: escrever no sdcard, câmera, localização, etc.

Farei um resumo aqui, mas recomendo que você leia a documentação oficial para pegar todos os detalhes:

http://developer.android.com/guide/topics/security/permissions.html

http://developer.android.com/training/permissions/index.html

  • Caso o código seja compilado com a API 22 (targetSdkVersion 22), o comportamento antigo ainda se aplica, ou seja, o usuário precisará aceitar todas as permissões no momento da instalação do aplicativo.
  • Caso o código seja compilado com a API 23 (targetSdkVersion 23), o aplicativo será instalado diretamente sem confirmar as permissões. Porém, em tempo de execução o aplicativo deverá solicitar a permissão do usuário para utilizar as funcionalidades restritas. Somente quando o usuário aceitar a permissão, o aplicativo pode usar a funcionalidade desejada.

As permissões são divididas entre normais e perigosas (dangerous). As permissões normais, exemplo: acessar a internet, bluetooth, etc, podem ser acessadas diretamente sem a confirmação do usuário. Já as permissões perigosas, como escrever no sdcard, acessar a localização, utilizar a câmera, etc, precisam da aprovação do usuário.

Para maiores detalhes sobre a lista de permissões, recomendo ler a documentação oficial:

http://developer.android.com/guide/topics/security/permissions.html#normal-dangerous

Dito isso, vamos partir para a prática. Sempre que precisar utilizar alguma funcionalidade restrita precisamos verificar se o usuário já autorizou o acesso. O código a seguir mostra como validar se o usuário permitiu o aplicativo escrever no cartão de memória.

boolean ok = ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;

Caso o retorno seja verdadeiro, podemos escrever um arquivo no cartão de memória, caso contrário precisamos pedir a permissão com o método requestPermissions(activity,permissoes,requestCode). Isso é feito com o seguinte template de código:

 
// Se não possui permissão
if (ContextCompat.checkSelfPermission(thisActivity,WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
      // Verifica se já mostramos o alerta e o usuário negou na 1ª vez.
      if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
           // Caso o usuário tenha negado a permissão anteriormente, e não tenha marcado o check "nunca mais mostre este alerta"
           // Podemos mostrar um alerta explicando para o usuário porque a permissão é importante.
      } else {
          // Solicita a permissão
          ActivityCompat.requestPermissions(thisActivity,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},0);
      }
} else {
      // Tudo OK, podemos prosseguir.
}

Note que este código utiliza as classes ContextCompat e ActivityCompat para manter a compatibilidade, pois estes métodos de solicitar permissões somente existem no Android 6.0.

Depois de solicitar a permissão com o método requestPermissions(activity,permissoes,requestCode), o usuário verá um alerta para aceitar ou não a permissão, conforme a figura abaixo.

18.004

O resultado da decisão do usuário será entregue via o método onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults), que recebe como parâmetro o código da chamada (requestCode), a lista de permissões e a lista de respostas do usuário.

@Override
public void onRequestPermissionsResult(int requestCode,String permissions[], int[] grantResults) {
 switch (requestCode) {
      case 0: {
      if (grantResults.length &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; 0 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; grantResults[0] == PackageManager.PERMISSION_GRANTED)      {
           // Usuário aceitou a permissão!
      } else {
           // Usuário negou a permissão.
           // Não podemos utilizar esta funcionalidade.
      }
      return;
     }
   }
}

Basicamente é isso!

Entenda que estas solicitações devem ser feitas a medida que você for usando o aplicativo. Por exemplo, somente quando for necessário obter a localização (GPS) você deverá fazer todo esta verificação. E lembre-se que caso o usuário negue a permissão, você deverá desabilitar as funcionalidades, pois qualquer tentativa de utilizar a API neste caso resultaria em uma SecurityException.

Dadas estas explicações, vamos fazer um exemplo prático.

Se você possui o livro Google Android 4ª edição poderá ver que alguns exemplos podem não funcionar no Android 6.0. Na verdade se você compilar o projeto com targetSdkVersion 22 não teremos problemas, pois neste caso, o controle de permissões será feito no momento da instalação, como era antes. Mas às vezes, ao pegar os exemplos do livro, você pode alterar o código para targetSdkVersion 23 (Android 6.0), e neste caso alguns exemplos podem parar de funcionar devido ao erro de permissão SecurityException .

Para brincar um pouco, abra o projeto HelloContatos do capítulo 23 (Agenda e Contatos) dos exemplos do livro Google Android 4ª edição. Como você deve saber, este exemplo lista os contatos da agenda. Este app inclusive mostra como adicionar alguns contatos na agenda (Donald, Mickey e Pateta).

contatos

Mas agora altere o arquivo app/build.gradle para compilar o projeto com API 23.

Ao executar o projeto em um dispositivo com Android 6.0, o aplicativo vai travar, mostrando a famosa mensagem Force Close.

b

Como de costume, sempre que o aplicativo trava devemos olhar os logs no LogCat.

Neste caso o erro foi uma SecurityException (permissão negada).

Screen Shot 10-02-15 at 12.07 AM

Este erro já era esperado, então vamos corrigí-lo.

Como o projeto que lista os contatos utiliza as permissões READ_CONTACTS e WRITE_CONTACTS, precisamos pedir a permissão do usuário para utilizar a agenda de contatos.

Para facilitar a codificação, criei a classe PermissionUtils (use ela como quiser, é apenas uma sugestão). A formatação do código ficou meio zoada, então faça o download do código-fonte do arquivo aqui. PermissionUtils


&amp;amp;amp;amp;amp;amp;lt;pre&amp;amp;amp;amp;amp;amp;gt;package br.com.livroandroid.contatos;

import android.app.Activity;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;

import java.util.ArrayList;
import java.util.List;

/**
 * Sistemas de permissão do Android 6.0
 * &amp;amp;amp;amp;amp;amp;lt;p/&amp;amp;amp;amp;amp;amp;gt;
 * http://developer.android.com/preview/features/runtime-permissions.html
 */
public class PermissionUtils {

    /**
     * Solicita as permissões
     */
    public static boolean validate(Activity activity, int requestCode, String... permissions) {
        List&amp;amp;amp;amp;amp;amp;lt;String&amp;amp;amp;amp;amp;amp;gt; list = new ArrayList&amp;amp;amp;amp;amp;amp;lt;String&amp;amp;amp;amp;amp;amp;gt;();
        for (String permission : permissions) {
            // Valida permissão
            boolean ok = ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED;
            if (! ok ) {
                list.add(permission);
            }
        }
        if (list.isEmpty()) {
            // Tudo ok, retorna true
            return true;
        }

        // Lista de permissões que falta acesso.
        String[] newPermissions = new String[list.size()];
        list.toArray(newPermissions);

        // Solicita permissão
        ActivityCompat.requestPermissions(activity, newPermissions, 1);

        return false;
    }
}&amp;amp;amp;amp;amp;amp;lt;/pre&amp;amp;amp;amp;amp;amp;gt;

O método validate(…) recebe uma lista de permissões e valida se o usuário já concedeu o acesso. Caso o app ainda não tenha perguntado ao usuário, a acesso é solicitado pelo método requestPermissions(…).

Na MainActivity do projeto HelloContatos, basta adicionar estas linhas de código para validar a permissão e solicitá-la caso necessário:


// Solicita as permissões
 String[] permissoes = new String[]{
 Manifest.permission.READ_CONTACTS,
 Manifest.permission.WRITE_CONTACTS,
 };
 PermissionUtils.validate(this, 0, permissoes);

O código-fonte completo pode ser visto a seguir. Download do fonte: MainActivity

Bom, é isso :-). Se fizermos essa chamada no código vai dar boa. Ao executar o projeto no emulador do Android 6.0, vereremos o seguinte alerta solicitando a permissão do usuário para utilizar a API da agenda de contatos.

alerta

Se o usuário aceitar as permissões, tudo continuará bem e o aplicativo poderá ler os contatos.

Caso contrário, você terá que fazer algumas validações no código (if) para não utilizar as APIs que o usuário não aprovou.

Neste exemplo que fiz, caso o usuário negue a permissão, o aplicativo vai mostrar uma mensagem e sair.

nao

É isso pessoal!

Espero que este post tenha ajudado a entender um pouco sobre a nova API de permissões do Android 6.0.

Lembre-se de atualizar os seus aplicativos e validar no código se as permissões foram concedidas.

E por último, tenha atenção, pois o usuário pode revogar as permissões a qualquer momento, ou seja, ele pode alterar as configurações para permitir ou não o acesso a determinada API.

A figura abaixo mostra as configurações de um aplicativo, mostrando as opções para o usuário revogar as permissões. Portanto, lembre-se de sempre validar se a permissão foi concedida ou não antes de usar as APIs restritas, pois o usuário pode mudar as configurações a qualquer momento.

permi

Links oficiais, recomendado o estudo (leia sobre as boas práticas).

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 / No Comments

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