Category Archives: Uncategorized

Novidades do Java 8

Só alguns poucos (6) anos atrasado, venho publicar esse post com as principais novidades do Java 8 que foi lançado em Março de 2014 através da especificação JSR 337.

Esse post é o primeiro da série onde pretendo centralizar as melhorias de cada uma das versões que vieram após o Java 7.

Lambda Expression

Também conhecida como funções anônimas, acredito que essa seja maior mudança na versão 8, as expressões lambdas podem causar estranhesa a primeira vista por quem apenas programou utilizando Java. Mas elas já são bem comuns para programadores que tiveram contato com linguagens como C#, Clojure, Go, Groovy, Javascript, Kotlin, Ruby, Scala e muitas outras.

Essas expressões facilitam a implementação dos comportamentos de inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Como por exemplo a clássica interface java.util.Comparator, comumente utilizada para ordenar coleções. Anteriormente precisaríamos implementar essa interface em uma classe ou instância-la como classe anonima como no exemplo abaixo:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = new Comparator() {
	public int compare(String s1, String s2) {
		return Integer.compare(s1.length(), s2.length());
	}};

Collections.sort(linguagens, comparadorPorTamanho);

Agora abaixo um código equivalente ao de cima, substituindo a instanciação da classe anonima pela expressão lambda:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Comparator<String> comparadorPorTamanho = (s1, s2) -> Integer.compare(s1.length(), s2.length());

Collections.sort(linguagens, comparadorPorTamanho);

Podemos fazer uma versão mais enxuta ainda, passando a expressão lambda direto como argumento para o método sort:

List <String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

Collections.sort(linguagens, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Detalhando um pouco mais a sintaxe da expressão lambda apresentada:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

É iniciada com a declaração dos parametros do método que estamos implementando. O método da interface Comparator aguarda 2 parametros do tipo String, a tipagem dos parâmetros é opcional, já que temos apenas um único método na interface, o compilador ja sabe com quais tipos ele está lidando, por isso declaramos apenas o nome que desejamos para as variáveis:

(s1, s2) ...

Se o método aguardasse apenas 1 parametro, então declaramos somente o nome do parametro, sendo que neste cenário os parênteses passam a ser opcionais.

s1 ...

Caso o método não tivesse parametros, seria declarado com parenteses vazios:

() ...

Após a declaração dos parametros colocamos o arrow token, que é composto por um hífen, seguido por um sinal de maior (->):

(s1, s2) -> ...

Em seguida devemos colocar o conteúdo do nosso método, no exemplo que estamos utilizando é { return Integer.compare(s1.length(), s2.length()); }, como o nosso corpo é simples e tem apenas uma única linha (instrução), podemos suprimir as chaves, o return e o ponto e vírgula (;), pois nesse caso tornan-se opcionais:

(s1, s2) -> Integer.compare(s1.length(), s2.length())

Caso o nosso conteúdo fosse ‘mais complexo’, com mais de uma linha (instrução), necessitaríamos da utilização das chaves, do return (caso o método não seja void, claro :D) e do ponto e vírgula (;) no final de cada comando, como por exemplo:

(s1, s2) -> {
    // imagine qualquer comando aqui
    int resultado = Integer.compare(s1.length(), s2.length());
    // imagine qualquer comando aqui
    return resultado;
}

Ordenando Collections

Como vimos no exemplo acima, ordenavamos nossas coleções utilizando o método utiitário Collections.sort (Classe), agora no java 8 temos outra maneira mais simples de efetuar tal ação, temos o método Collection.sort (Interface), que espera como parâmetro apenas um Comparator compatível com o tipo da lista, o qual está disponível em todas as nossas coleções, como por exemplo na interface List.

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));

A interface Comparator ganhou um método estático (sim! agora é possível :D) Comparator.comparing, que facilitar a criação de uma instância de um comparador simples:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(s -> s.length()));

Podemos simplificar ainda mais com outra novidade, o Method Reference, que nos permite fazer referência a um método específico de uma classe:

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.sort(Comparator.comparing(String::length));

Novos métodos nas Collections

Nas nossas coleções tivemos algumas mudanças, ganhamos diversos métodos novos como o Collection.sort visto acima, muitos deles esperam com parâmetro implementações de interfaces funcionais (assunto que veremos a seguir), segue mais alguns:

Iterable.forEach(Consumer)
Iterator.forEachRemaining(Consumer)
Collection.removeIf(Predicate)
Collection.spliterator()
Collection.stream()
Collection.parallelStream()
List.sort(Comparator)
List.replaceAll(UnaryOperator)
Map.forEach(BiConsumer)
Map.replaceAll(BiFunction)
Map.putIfAbsent(K, V)
Map.remove(Object, Object)
Map.replace(K, V, V)
Map.replace(K, V)
Map.computeIfAbsent(K, Function)
Map.computeIfPresent(K, BiFunction)
Map.compute(K, BiFunction)
Map.merge(K, V, BiFunction)
Map.getOrDefault(Object, V)

Interface

Ocorreram melhorias também nas interfaces, como a possibilidade de declarar métodos concretos, chamados de Default Method, fazendo com que as interfaces tenham uma grande similaridade com as classes abstratas, que até então eram um meio termo entre interfaces e classes concretas. Esse tipo de método necessita do operador default em sua declaração.

Solução criada para possibilitar a evolução das interfaces já existentes, assim quando criarmos novos métodos em interfaces que já estão em uso, essas alterações não irão causar erros de compilação nas outras interfaces e/ou classes que as implementam.

Por exemplo, o novo método sort da interface List:

default void sort(Comparator<? super E> c) {
    Collections.sort(this, c);
}

Outra novidade também, como vimos na interface Comparator.comparing, agora podemos declarar métodos estáticos, o que não era possível anteriormente:

Interfaces funcionais

Como ja vimos no começo do post, inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.

Antes dessa nova versão ja tinhamos outras interfaces funcionais, é isso mesmo! Um exemplo seria a interface Runnable, que é implementada pela famosa classe Thread.

Agora as interfaces funcionais ganharam mais destaque, e também novas interfaces localizadas no pacote java.util.function:

Function<T, R> − recebe T como entrada, retorna R como saída;
Predicate<T> − recebe T como entrada, retorna um valor booleano como saída;
Consumer<T> − recebe T como entrada, não retorna nada como saída;
Supplier<T> − não recebe entrada, retorna T como saída;
BinaryOperator<T> − recebe duas entradas T, retorna um T como saída.

Também temos uma nova anotação @FunctionalInterface, que deve ser utilizada para indicar que uma interface é funcional. O que obriga o compilador a verificar se existe apenas um método declarado na interface. Em caso negativo, ocorrerá um erro de compilação. Todas as antigas interfaces que são consideradas funcionais, receberam essa anotação.

Optional

Nova classe que nos ajuda a evitar a má prática de retornar null em nosso métodos, e espalhar comparações do tipo if (resultado != null), deixando o nosso código muito mais elegante. Estamos falando da classe java.util.Optional que usufrui de Generics, possibilitando uma codificação tipada. Segue algumas maneira de aplica-la:

Retornando resutado não-nulo:

public Optional<String> buscar() {
    String resultado = "XPTO";
    return Optional.of(resultado);
}

Retornando resutado que é vazio, antigo return null:

public Optional<String> buscar() {
    return Optional.empty();
}

Retornando resultado que tem a possibilidade de ser nulo:

public Optional<String> buscar() {
    String resultado = null;
    return Optional.ofNullable(resultado);
}

Internamente o método acima verifica o parametro passado e decide se prossegue com o método of ou empty.

Agora segue alguns exemplos do lado de quem recebeu o Optional como retorno, como o utilizamos:

Verificando se temos um resultado preenchido:

Optional<String> opt = buscar();
boolean preenchido = opt.isPresent();

Obtendo o resultado encapsulado, devemos verificar com o método isPresent para evitar receber uma exceção:

Optional<String> opt = buscar();
String resultadoEsperado = opt.get();

Se o resultado estiver presente, você pode ja passar uma função para consumi-lo:

Optional<String> opt = buscar();
opt.ifPresent(r -> System.out.println(r));

Você ja pode deixar seu código preparado para receber outro valor caso o resutado não esteja presente:

Optional<String> opt = buscar();
String outroResultado = opt.orElse("Vazio!");

Lançando exceção caso o resutado não esteja presente:

Optional<String> opt = buscar();
opt.orElseThrow(IllegalStateException::new);

Stream

Uma grande novidade que nos ajuda muito no dia a dia, é o pacote java.util.stream, que nos possibilita uma programação no estilo funcional. Simplificando a forma de iterar, filtrar, transformar, consolidar e coletar os dados.

A forma mais comum de ter acesso a uma instância de Stream é através de collections já populadas, através do método Collection.stream, que nos devolve uma instância de java.util.stream.Stream, possibilitando o uso de uma infinidade de métodos que esperam como parâmetro a implementação de diversas interfaces funcionais (ex.: as que mostramos acima) de acordo com o tipo de operação.

Iterando (ex.: Imprimindo as linguagens):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

linguagens.stream()
    .forEach( l -> System.out.println("Imprimindo linguagem "+l ));

Obs.: Também podemos ter acesso a esse método de forma mais prática, diretamente na coleção com Iterable.forEach.

Transformando (ex.: Obtendo as iniciais de cada linguagem):

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<Character> iniciais = linguagens.stream()
    .map(l -> l.charAt(0))
    .collect(Collectors.toList());

Nesse exemplo fizemos chamadas sequenciais/encadeadas de 2 métodos, o map e o collect, onde um faz a transformação de cada objeto e o outro é responsável por obter o resultado da operação anterior.

Ordenando (ex.: Ordem alfabetica)

List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");

List<String> novaListaOrdenada = linguagens.stream()
    .sorted(Comparator.comparing(String::toString))
    .collect(Collectors.toList());

Nesse exemplo ordenamos com sorted e em seguida obtivemos a lista ordenada com o collect.

Removendo duplicados

List<Integer> numeros = Arrays.asList(1, 1, 2, 3, 4, 4, 5);

numeros.stream()
    .distinct()
    .forEach(n -> System.out.println(n));

Removemos os duplicados através do distinct, o qual se utiliza do método equals do objeto para distinguir os valores, e para variar, não coletamos o resutado, e sim, imprimimos cada um deles com o forEach.

Filtrando (ex.: Linguagens que começam com “J”)

List<String> linguagens = Arrays.asList("Java", "C#", "JavaScript", "Html");

linguagens.stream()
    .filter(l -> l.startsWith("J"))
    .forEach(l -> System.out.println(l));

Filtramos utilizando o filter e imprimimos utilizando forEach.

Temos muitas outras possibilidades para trabalhar com Stream, para descobrir todas elas, basta dar uma olhada na documentação oficinal 😀

Também temos Streams para trabalhar com tipos primitivos, como IntStream, LongStream e DouleStream, que nos oferecem métodos específicos para trabalhar com números, como average, sum, reduce e muito mais.

Além de tudo isso, podemos efetuar esses processamentos de forma paralela de maneira bem simples, com o uso do método Collection.parallelStream ao invés de Collection.stream, possibilitando um possível ganho de performance.

Datas e horas

Finalmente ganhamos uma nova API para trabalhar com data e hora, baseada no JodaTime, o JodaTime ja era uma biblioteca bastante utilizada pelos desenvolvedores, agora nossa vida será muito mais fácil quando o assunto for lidar com data e hora.

As antigas classes java.util.Date, java.sql.Date, java.util.GregorianCalendar e cia, dão espaço para as classes dos pacotes java.time, como por exemplo LocalDate para trabalhar apenas com data, LocalTime para trabalhar apenas com horas, LocalDateTime para trabalhar com data e hora. Também temos a classe java.time.format.DateTimeFormatter para ajudar na formatação e muitas outras.

Segue um breve exemplo do uso das classes citadas:

System.out.println("Hoje: " + LocalDate.now());

System.out.println("Agora: " + LocalTime.now());

LocalDate nascimento = LocalDate.of(1989, Month.MAY, 22);
System.out.println("Nascimento: " + nascimento);

String nascimentoFormatado = nascimento.format(DateTimeFormatter.ofPattern("dd/MM/yy"));
System.out.println("Nascimento formatado: " + nascimentoFormatado);

A nova API tem muitas classes e muitos métodos, não irei abordar tudo aqui pois não é o intuito desse post. Para ver todas as funcionalidades dê uma olhadinha nesse post da oracle!

Essas classes ja são suportadas pelo JDBC e JPA, então você pode mapear seu modelo utilizando-as sem medo! 😀

Outras mudanças

Melhorias na própria JVM relacionado ao uso da memória disponível (Metaspace);
Melhorias na API de Concorrência;
Melhorias na API de IO/NIO;
Melhorias para trabalhar com Reflection;
Nova implementação para utilizar JavaScript dentro do Java: Nashhorn;
Nova implementações para unir Strings como o método String.join e a classe java.util.StringJoiner;
Conexão com Banco de dados via JDBC-ODBC foi removida;
Não roda no Windows XP;

Fontes:
Caelum, Matera, Feltex, Infoq, Oracle – Docs, Oracle – Specs, Wikipedia

Axis 2 – org.apache.axis2.AxisFault: The given SOAPAction … does not match an operation.

E ai pessoal beleza? bom venho aqui para postar a solução de um problema que tive aqui no trabalho, que me custou alguns dias de pesquisa…

Eu estava tentando consumir um webservice de um cliente e estava tomando o seguinte erro:
org.apache.axis2.AxisFault: The given SOAPAction … does not match an operation.

porém pelo soapUI funciona perfeitamente… entao, eu tinha riscado a hipótese de ser algo com o WSDL

tentei gerar o client do axis2 com ADB e com XMLBEANS porém ambos caíram no mesmo erro…
ai finalmente descobri o motivo, o WSDL do cliente realmente tinha algo errado…
os campos soapAction estavam vazios:

<soap:operation soapAction="" style="document" /> 

então  vi que existem 3 maneiras de resolver esse problema… 1ª o cliente arrumar o WSDL dele,
o que vai depender da boa vontade dele… 2ª setar o valor da action em tempo de execução e a 3ª e ultima que é desabilitar essa soap action…

a 2ª opção é fazendo o seguinte:
AlgumaCoisaServiceStub stub = new AlgumaCoisaServiceStub(); //é gerado pelo axis2
stub._getServiceClient().getOptions().setAction(“http://suaaction&#8221;);

eu acho que a action é manipulada diferentemente para cada versão do soap, para especificar a versão utilize:
stub._getServiceClient().getOptions().setSoapVersionURI(org.apache.axiom.soap.SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
(ou a versão SOAP12 da constante).

e a 3º opção é fazer o seguinte:
AlgumaCoisaServiceStub stub = new AlgumaCoisaServiceStub(); //é gerado pelo axis2
stub._getServiceClient().getOptions().setProperty(org.apache.axis2.Constants.Configuration.DISABLE_SOAP_ACTION, true);

Bom… espero que esse post tenha ajudado vocês 😀
se resolver, irá poupar algumas boas horas de pesquisa 😀

Fonte: StackOverflow – Michael Sharek / mstewart

Como atribuir valor para o atributo ‘android:drawable …’ via ‘HardCode’

Como atribuir valor para os atributos android:drawableRight, android:drawableLeft e etc via ‘HardCode’???

Apenas use o método:

public void setCompoundDrawables (Drawable left, Drawable top, Drawable right, 
 Drawable bottom)

Deixe null os parâmetros que você não irá utilizar!!! 😀 simples assim…

caso esse primeiro método não resolva, utilize:

public void setCompoundDrawablesWithIntrinsicBounds (Drawable left, Drawable top, Drawable right, 
 Drawable bottom)

Fonte: stackoverflow – eyespyus / stackoverflow – hunterp

Tutorial Google Maps Android API v2

Antes de começar a trabalhar com a API, você vai precisar baixar a API  e obter a chave. Tanto a API quanto a chave estão disponíveis gratuitamente.

Configurando o ambiente

O Google Maps API Android V2 é distribuído como parte do Google Play services SDK . Siga os passos abaixo para instalar o Google Play Services SDK para o desenvolvimento com o Eclipse:

1. Selecione no menu do ecplise Window > Android SDK Manager

2. Vá até a parte inferior da lista de pacotes, selecione Extras> Google Play Services, e instale-o;

3. Copie o <android-sdk-folder>/extras/google/google_play_services/libproject/google-play-services_lib  library project para a pasta onde você criou seu projeto android;

4. Usando o Eclipse, importe o projeto de biblioteca em sua workspace. Clique em File> Import, selecione Android > Existing Android Code into Workspace  e vá para a cópia do projeto de biblioteca Google Play Service para importá-lo;

5. Vá em Properties do seu projeto (Clique com o botão direito no seu projeto) e selecione o menu “Android“;

6. Clique no botão [Add…] e na caixa de diálogo “Project Selection” selecione o projeto google-play-services-lib que foi importado anteriormente;

Tutorial Google Maps para Android

Nota: O Google Play Services não é compatível com o emulador Android

 

Obtendo a chave Map Api Key

O Google Maps API v2 Android usa um novo sistema de gerenciamento de chaves. Chaves existentes de um aplicativo Android Google Maps v1 não vão funcionar com a API v2.

Obter uma chave para a sua aplicação requer várias etapas. Estes passos são descritos aqui, e descritos em detalhe nas seções seguintes.

1. Recuperar informações sobre o certificado de sua aplicação (SHA-1 fingerprint).

A chave do Google Maps API é baseada em um pequeno formulário de certificado digital do seu aplicativo, conhecido como SHA-1 fingerprint. A fingerprint é uma seqüência de texto único, gerado a partir do algoritmo comumente usado SHA-1 hashing. Porque a fingerprint é única, o Google Maps pode usa-lo como uma forma de identificar a sua aplicação.

Você pode gerar a chave a partir de dois tipos de certificados:

Debug certificate: 

O certificado é apenas para uso de um aplicativo que você está testando, você não pode publicar um aplicativo que está assinado com um certificado de depuração. O certificado de depuração é descrito com mais detalhes na seção Signing in Debug Mode da Documentação de desenvolvedor Android. Você pode gerar uma chave de API a partir deste certificado, mas apenas usar a chave para o teste, nunca para a produção.

Exibindo o fingerprint para chave de debug:
1.1 Localize o arquivo de debug keystore. O nome do arquivo é debug.keystore, e é criado a primeira vez que você cria seu projeto. Por padrão, ele é armazenado no mesmo diretório do seu dispositivo AVD:
Usando o Eclipse selcione Windows > Prefs > Android > Build  para verificar o caminho completo (Default debug keystore);
1.2 Usando o Terminal do windows (cmd) navegue até a pasta bin do jdk da sua máquina para ter acesso aos comandos Keytool
1.3 Execute a seguinte linha de comando subistituindo o caminho do arquivo debug.keystore pelo seu visualizado anteriormente:
keytool -list -v -keystore "C:\Users\your_user_name\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android
Caso você tenha ma exceção de formato no keystore, você deve alterar as configurações regionais do seu Windows colocando Formato e Local para Estados Unidos

1.4 Você deverá ver uma saída semelhante a esta e dentre as informações você já pode ver seu SHA-1 fingerprint

 Alias name: androiddebugkey  Creation date: Jan 01, 2013  Entry type: PrivateKeyEntry  Certificate chain length: 1  Certificate[1]:  Owner: CN=Android Debug, O=Android, C=US  Issuer: CN=Android Debug, O=Android, C=US  Serial number: 4aa9b300  Valid from: Mon Jan 01 08:04:04 UTC 2013 until: Mon Jan 01 18:04:04 PST 2033  Certificate fingerprints:       MD5:  AE:9F:95:D0:A6:86:89:BC:A8:70:BA:34:FF:6A:AC:F9       SHA1: BB:0D:AC:74:D3:21:E1:43:07:71:9B:62:90:AF:A1:66:6E:44:5D:75       Signature algorithm name: SHA1withRSA       Version: 3

Release certificate:

  •  Este certificado pode ser usado com o aplicativo que você queira publicar em produção.

Depois de decidir qual o certificado correto para suas necessidades, você pode obter a chave seguindo este outro tutorial…
2. Registrar um projeto no Google APIs Console e adicionar a API do Google Maps como um serviço para o projeto.

2.1 Acesse Google APIs Console

2.3 Se você não usou o Google APIs Console antes, você será solicitado a criar um projeto que você usará para controlar o uso do Google Maps API Android. Clique em Create Project e crie um novo projeto chamado Projeto API. Na próxima página, este nome aparece no canto superior esquerdo. Para renomear ou gerenciar o projeto, clique em seu nome.
Se você já está usando o Google APIs Console, você vai ver imediatamente uma lista de seus projetos existentes e os serviços disponíveis. Ainda é uma boa ideia usar um novo projeto para o Google Maps API Android, portanto, selecione o nome do projeto no canto superior esquerdo e, em seguida, clique em Create.

3. Uma vez que você tem um projeto definido, você pode solicitar uma ou mais chaves.

3.1Você deverá ver uma lista de APIs e serviços na janela principal. Se você não estiver vendo isso, selecione Services da barra de navegação à esquerda.

3.2 Na lista de serviços exibidos no centro da página, role para baixo até ver o Google Maps API v2 Android. Clique no indicador de “interruptor”, de modo que ele está ligado.

3.3 Aceite os termos de Serviços e estará pronto para ter uma Maps API Key.

3.4 Na barra de navegação à esquerda, clique em API Access.

3.5 Clique no botão [Create New Android Key…]

3.6 Na caixa de diálogo, digite o  SHA-1 fingerprint, em seguida, um ponto e vírgula, em seguida, o nome do pacote do aplicativo. Por exemplo:

BB:0D:AC:74:D3:21:E1:43:67:71:9B:62:91:AF:A1:66:6E:44:5D:75;com.frameworksystem.android.mapexample

O Google APIs Console responde exibindo-chave para aplicativos Android (com certificados), seguido por uma chave, por exemplo:

AIzaSyBdVl-cTICSwYKrZ95SuvNw7dbMuDt1KG0

4. Finalmente, você pode adicionar a sua chave para a sua aplicação e iniciar o desenvolvimento.

 

Adicionando a API Key em sua aplicação

O passo final é adicionar a chave da API para a sua aplicação.

1. Em AndroidManifest.xml, adicione o seguinte elemento como um filho do elemento <application>, inserindo-lo antes da tag de fechamento </ application>:

<meta-data android:name="com.google.android.maps.v2.API_KEY" android:value="your_api_key"/>

2. substitua “your_api_key” Pela sua chave API Key obtida anteriormente.

3. Adicione os seguintes elementos para o seu AndroidManifest.xml. Substitua com.frameworksystem.android.mapexample com o nome do pacote da sua aplicação.

<permission
        android:name="com.example.mapdemo.permission.MAPS_RECEIVE"
        android:protectionLevel="signature"/>
<uses-permission android:name="com.frameworksystem.android.mapexample.permission.MAPS_RECEIVE"/>

4. Especifique as seguintes permissões no AndroidManifest.xml substituindo com.frameworksystem.android.mapexample pelo pacote da sua aplicação:

 

<uses-permission android:name=”android.permission.INTERNET” />
<uses-permission android:name=”android.permission.ACCESS_COARSE_LOCATION” />
<uses-permission android:name=”android.permission.ACCESS_FINE_LOCATION” />
<uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE” />
<uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE”/>
<uses-permission android:name=”com.google.android.providers.gsf.permission.READ_GSERVICES”/>

<permission
android:name=”br.com.cadastroindustrial.permission.MAPS_RECEIVE”
android:protectionLevel=”signature”/>
<uses-permission android:name=”com.frameworksystem.android.mapexample.permission.MAPS_RECEIVE”/>

<uses-feature
android:glEsVersion=”0x00020000″
android:required=”true”/>

Desenvolvendo um Mapa

 

1.  Implement a seguinte Activity:

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;

import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapFragment;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.Marker;
import com.google.android.gms.maps.model.MarkerOptions;

public class MainActivity extends Activity {
  private LatLng frameworkSystemLocation = new LatLng(-19.92550, -43.64058);
  private GoogleMap map;

  @Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    map = ((MapFragment) getFragmentManager().findFragmentById(R.id.map))
        .getMap();
    Marker frameworkSystem = map.addMarker(new MarkerOptions()
                                               .position(frameworkSystemLocation)
                                               .title("Framework System"));
 // Move a câmera para Framework System com zoom 15.
    map.moveCamera(CameraUpdateFactory.newLatLngZoom(frameworkSystemLocation , 15));
    map.animateCamera(CameraUpdateFactory.zoomTo(10), 2000, null);
  }

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.activity_main, menu);
    return true;
  }

}

 

2. Implemente o seguinte layout para a Activity

<RelativeLayout 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"
    tools:context=".MainActivity" >

    <fragment
        android:id="@+id/map"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

</RelativeLayout>

 

Observações !!!!! :

Pessoal, as estruturas de Fragment do android foram criadas na versão 3.0.
Para aplicações feitas com versões anteriores do android existe a biblioteca android-support-v4.jar que oferece suporte a estrutura de Fragment e outras novas implementações para as versões anteriores do android.

Para adicionar a biblioteca de suporte em sua aplicação, usando o eclipse vá em Properties do seu projeto (Clique com o botão direito no seu projeto) e selecione Android Tools > Add Support Library… marque Accept All e clique no botão [ Install ]

Feito isso sua Activity agora deve estender de FragmentActivity e para instanciar o objeto map (private GoogleMap map) deverá ser feito as seguintes alterações:

map = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();

———————————————————————————————————-

fonte: Framework System – Geraldo Marcelo

Gerador de Dados Pessoais Fictícios

E ai galera beleza?

Achei um site muito interessante que gera dados pessoais fictícios:

http://pt.fakenamegenerator.com/

se você na hora de testar seu sistema sempre acaba colocando nomes
bizarros ou “asdfasdfasdf” no lugar dos dados acredito que esse site
será de grande proveito !!! 😀

Abraços