Saber a localização do seu usuário é uma informação útil em muitos aplicativos nós desenvolvemos e usamos hoje. Existem muitos aplicativos populares baseados em localização que estão facilitando nossas vidas, bem como mudando a maneira como usamos esses serviços. Um exemplo é o aplicativo extremamente popular Foursquare, em que os usuários que frequentam um estabelecimento e “fazem check-in” geralmente ganham descontos. Uber, que ajuda você a pegar uma carona do seu celular a uma tarifa mais baixa do que um táxi normal. A lista é grande e continua crescendo.

Neste artigo, vamos construir um aplicativo Android simples para determinar a latitude e longitude do usuário usando a API de serviços de localização do Google do Android. Quando desenvolvendo aplicativos Android , existem algumas maneiras de obter a localização do usuário.

Pacote “android.location”

o pacote “android.location” está disponível desde o lançamento do Android e nos dá acesso a serviços de localização. Esses serviços permitem que os aplicativos obtenham atualizações periódicas da localização geográfica do dispositivo.

O pacote fornece dois meios de adquirir dados de localização:

• LocationManager.GPS_PROVIDER: determina a localização usando satélites. Dependendo das condições, este provedor pode demorar um pouco para retornar uma correção de local.

  
  
  

  por que json é melhor que xml

• LocationManager.NETWORK_PROVIDER: determina a localização com base na disponibilidade de torres de celular e pontos de acesso WiFi próximos. Isso é mais rápido do que GPS_PROVIDER.

Quando você está procurando a localização do usuário, tem que brincar com esses provedores e sua disponibilidade. O ideal é obter a primeira localização usando NETWORK_PROVIDER, que pode não ser tão preciso, mas é muito mais rápido. Você pode então fazer uma tentativa de aumentar a precisão ouvindo uma localização melhor usando o GPS_PROVIDER.

As APIs fornecidas por este pacote são de baixo nível e exigem que o desenvolvedor do aplicativo lide com os detalhes mais precisos para determinar quando solicitar dados de localização e agendar chamadas para a API de maneira otimizada. Para melhorar a experiência do desenvolvedor com serviços de sistema baseados em localização e facilitar o processo de desenvolvimento de aplicativos com reconhecimento de localização, o Google introduziu uma nova maneira de solicitar a localização de um usuário usando o Google Play Services. Ele oferece uma API mais simples com maior precisão, geofencing de baixo consumo de energia e muito mais.

API de serviços de localização do Google

A API de serviços de localização do Google, também conhecida como FusedLocationProviderApi, é a maneira recomendada pelo Google de obter a localização de um usuário. Ele fornece a melhor precisão com base em nossas necessidades. Algumas das vantagens de usar esta API em relação à anterior são:

• Simplicidade: ao contrário da API anterior, você não precisa mais lidar com vários provedores. Em vez disso, você especifica necessidades de alto nível, como “alta precisão” ou “baixo consumo de energia”, e será feita uma abordagem adequada.

• Disponibilidade: dá ao seu aplicativo acesso imediato ao melhor e mais recente local conhecido. Normalmente essa informação está disponível, basta solicitá-la.

  
  
  

• Eficiência energética: minimiza o uso de energia do seu aplicativo.

  quantos threads posso executar python

• Versatilidade: atende a uma ampla gama de necessidades, desde usos em primeiro plano - precisando de dados de localização altamente precisos até usos em segundo plano - exigindo apenas atualizações de localização periódicas com impacto insignificante de energia.

  
  
  

Vamos construir um aplicativo Android baseado em localização usando esta API. Para isso, usaremos o IDE sugerido pelo Google para o desenvolvimento de aplicativos Android - Android Studio . Começar com o Android Studio é bastante simples. O site deles descreve o procedimento que envolve a instalação e configuração do Android Studio detalhadamente, incluindo como inicializar seu primeiro aplicativo Android para desenvolvimento.

O Android Studio deve tornar as coisas muito fáceis para nós. No entanto, precisaremos começar configurando o script de construção e adicionando o Google Play Services como uma dependência para este aplicativo. Isso pode ser feito modificando o arquivo “build.gradle” da seguinte maneira:

introdução ao gerenciamento ágil de projetos

dependencies { compile 'com.android.support:appcompat-v7:21.0.3' compile 'com.google.android.gms:play-services:6.5.87' // Add this line }

No momento em que estou escrevendo este artigo, a versão mais recente do Google Play Services disponível é 6.5.87. Certifique-se de sempre verificar a versão mais recente disponível antes de começar. No caso de versões mais novas serem lançadas posteriormente e você decidir atualizá-las para seus próprios projetos, teste todos os recursos relacionados à localização em todas as versões do Android que você oferece suporte.

Neste ponto, devemos ser capazes de começar a fazer o trabalho real para nosso aplicativo.

Solicitando permissão, configurando AndroidManifest.xml

Os Androids têm recursos de segurança específicos que impediriam qualquer aplicativo arbitrário de solicitar a localização precisa do usuário. Para resolver isso, precisamos editar “AndroidManifest.xml” e adicionar o permissão que exigimos para este aplicativo:

private boolean checkGooglePlayServices(){ int checkGooglePlayServices = GooglePlayServicesUtil .isGooglePlayServicesAvailable(mContext); if (checkGooglePlayServices != ConnectionResult.SUCCESS) { /* * Google Play Services is missing or update is required * return code could be * SUCCESS, * SERVICE_MISSING, SERVICE_VERSION_UPDATE_REQUIRED, * SERVICE_DISABLED, SERVICE_INVALID. */ GooglePlayServicesUtil.getErrorDialog(checkGooglePlayServices, mContext, REQUEST_CODE_RECOVER_PLAY_SERVICES).show(); return false; } return true; }

Enquanto estamos nisso, também devemos definir a versão do Google Play Services que estamos usando para este aplicativo:

@Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_CODE_RECOVER_PLAY_SERVICES) { if (resultCode == RESULT_OK) { // Make sure the app is not already connected or attempting to connect if (!mGoogleApiClient.isConnecting() && !mGoogleApiClient.isConnected()) { mGoogleApiClient.connect(); } } else if (resultCode == RESULT_CANCELED) { Toast.makeText(mContext, 'Google Play Services must be installed.', Toast.LENGTH_SHORT).show(); finish(); } } }

Verificando a disponibilidade do Google Play Services

Antes de acessar os recursos fornecidos pelo Google Play Services, devemos verificar se o dispositivo tem o Google Play Services instalado e se a versão que pretendemos usar (6.5.87).

protected synchronized void buildGoogleApiClient() { mGoogleApiClient = new GoogleApiClient.Builder(this) .addConnectionCallbacks(this) .addOnConnectionFailedListener(this) .addApi(LocationServices.API) .build(); }

Este método verificará o Google Play Services e, caso o dispositivo não o tenha instalado (é raro, mas já vi casos), abrirá uma caixa de diálogo com o erro correspondente e convidará o usuário a instalar / atualizar Serviços do Google Play na Google Play Store.

Depois que o usuário conclui a resolução fornecida por “GooglePlayServicesUtil.getErrorDialog ()”, um método de retorno de chamada “onActivityResult ()” é disparado, então temos que implementar alguma lógica para lidar com essa chamada:

guia de estudo do arquiteto de soluções certificadas aws

package com.bitwoo.userlocation; import android.content.Intent; import android.location.Location; import android.os.Bundle; import android.support.v7.app.ActionBarActivity; import android.view.Menu; import android.view.MenuItem; import android.widget.Toast; import com.google.android.gms.common.ConnectionResult; import com.google.android.gms.common.GooglePlayServicesUtil; import com.google.android.gms.common.api.GoogleApiClient; import com.google.android.gms.location.LocationServices; public class MainActivity extends ActionBarActivity implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener { private static int REQUEST_CODE_RECOVER_PLAY_SERVICES = 200; private GoogleApiClient mGoogleApiClient; private Location mLastLocation; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (checkGooglePlayServices()) { buildGoogleApiClient(); } } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.menu_main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { // Handle action bar item clicks here. The action bar will // automatically handle clicks on the Home/Up button, so long // as you specify a parent activity in AndroidManifest.xml. int id = item.getItemId(); //noinspection SimplifiableIfStatement if (id == R.id.action_settings) { return true; } return super.onOptionsItemSelected(item); } private boolean checkGooglePlayServices() { int checkGooglePlayServices = GooglePlayServicesUtil .isGooglePlayServicesAvailable(this); if (checkGooglePlayServices != ConnectionResult.SUCCESS) { /* * google play services is missing or update is required * return code could be * SUCCESS, * SERVICE_MISSING, SERVICE_VERSION_UPDATE_REQUIRED, * SERVICE_DISABLED, SERVICE_INVALID. */ GooglePlayServicesUtil.getErrorDialog(checkGooglePlayServices, this, REQUEST_CODE_RECOVER_PLAY_SERVICES).show(); return false; } return true; } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_CODE_RECOVER_PLAY_SERVICES) { if (resultCode == RESULT_OK) { // Make sure the app is not already connected or attempting to connect if (!mGoogleApiClient.isConnecting() && !mGoogleApiClient.isConnected()) { mGoogleApiClient.connect(); } } else if (resultCode == RESULT_CANCELED) { Toast.makeText(this, 'Google Play Services must be installed.', Toast.LENGTH_SHORT).show(); finish(); } } } protected synchronized void buildGoogleApiClient() { mGoogleApiClient = new GoogleApiClient.Builder(this) .addConnectionCallbacks(this) .addOnConnectionFailedListener(this) .addApi(LocationServices.API) .build(); } @Override public void onConnected(Bundle bundle) { } @Override public void onConnectionSuspended(int i) { } @Override public void onConnectionFailed(ConnectionResult connectionResult) { } }

Acessando APIs do Google

Para acessar as APIs do Google, só precisamos realizar mais uma etapa: criar uma instância de GoogleApiClient. O cliente da API do Google fornece um ponto de entrada comum para todos os serviços do Google Play e gerencia a conexão de rede entre o dispositivo do usuário e cada serviço do Google. Nosso primeiro passo aqui é iniciar a conexão. Normalmente chamo este código do método “onCreate” da atividade:

@Override protected void onStart() { super.onStart(); if (mGoogleApiClient != null) { mGoogleApiClient.connect(); } }

Ao encadear uma série de chamadas de método, estamos especificando a implementação da interface de retorno de chamada e a API do serviço de localização que desejamos usar. A implementação da interface, neste caso “this”, receberá resposta ao método “connect ()” assíncrono quando a conexão com o Google Play Services for bem-sucedida, falhar ou for suspensa. Depois de adicionar este código, nossa “MainActivity” deve ficar assim:

@Override public void onConnected(Bundle bundle) { mLastLocation = LocationServices.FusedLocationApi.getLastLocation( mGoogleApiClient); if (mLastLocation != null) { Toast.makeText(this, 'Latitude:' + mLastLocation.getLatitude()+', Longitude:'+mLastLocation.getLongitude(),Toast.LENGTH_LONG).show(); } }

Então, em nosso método “onStart”, chamamos o método “connect” e esperamos que o método de retorno de chamada “onConnected” seja invocado:

protected void createLocationRequest() { mLocationRequest = new LocationRequest(); mLocationRequest.setInterval(20000); mLocationRequest.setFastestInterval(5000); mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); }

O método “onConnected” será semelhante a este:

protected void startLocationUpdates() { LocationServices.FusedLocationApi.requestLocationUpdates( mGoogleApiClient, mLocationRequest, this); }

Este retorno de chamada é disparado quando o Google Play Services está conectado, o que significa que, nessa altura, devemos ter a última localização conhecida. No entanto, este local pode ser nulo (é raro, mas não impossível). Nesse caso, o que eu recomendo é ouvir as atualizações de localização que serão abordadas a seguir.

guia para c ++

Ouvindo atualizações de localização

Depois de invocar “getLastLocation”, você pode solicitar atualizações periódicas do Fused Location Provider. Dependendo da sua aplicação, este período pode ser curto ou longo. Por exemplo, se você estiver criando um aplicativo que rastreia a localização de um usuário enquanto ele dirige, você precisará ouvir atualizações em intervalos curtos. Por outro lado, se o seu aplicativo é para compartilhar a localização do usuário com o amigo, talvez você só precise solicitar a localização de vez em quando.

Criar uma solicitação é muito fácil - você pode chamar este método dentro do método “onCreate”:

public class MainActivity extends ActionBarActivity implements ConnectionCallbacks, OnConnectionFailedListener, LocationListener { // ... @Override public void onLocationChanged(Location location) { mLastLocation = location; Toast.makeText(this, 'Latitude:' + mLastLocation.getLatitude()+', Longitude:'+mLastLocation.getLongitude(),Toast.LENGTH_LONG).show(); } }

Nós instanciamos um novo LocationRequest objeto. Defina o intervalo para 20 segundos (20000 milissegundos). Além disso, definimos uma taxa de atualização limitada para 5 segundos. Isso informa à API para fornecer atualizações a cada 20 segundos (de preferência), mas se houver uma alteração disponível em um período de 5 segundos, ela também deve fornecer. Finalmente, definimos a prioridade para “ PRIORITY_HIGH_ACCURACY ”, Entre as outras opções de prioridade disponíveis: PRIORITY_BALANCED_POWER_ACCURACY , PRIORITY_LOW_POWER , PRIORITY_NO_POWER .

Depois de criar a solicitação, você está pronto para começar a ouvir as atualizações de localização após o método “onConnected ()” ter sido disparado:

protected void stopLocationUpdates() { if (mGoogleApiClient != null) { LocationServices.FusedLocationApi.removeLocationUpdates( mGoogleApiClient, this); } }

Tudo o que resta agora é implementar o método de retorno de chamada para satisfazer o LocationListener interface:

@Override protected void onStop() { super.onStop(); if (mGoogleApiClient != null) { mGoogleApiClient.disconnect(); } }

Pare de escutar atualizações

É importante parar explicitamente de ouvir as atualizações quando não precisar mais delas ou se o usuário sair do aplicativo. O método a seguir deve ser invocado a partir do retorno de chamada “onPause”:

|_+_|

… E desconectando a API do Google:

Empacotando

Como você pode ver, as idéias fundamentais por trás da implementação de aplicativos com reconhecimento de localização no Android são muito simples. Além disso, com as APIs disponíveis que são simples de usar e de entender, não deve ser difícil criar aplicativos básicos baseados em localização para Android. O pequeno aplicativo de amostra que construímos aqui tem o objetivo de demonstrar exatamente isso. Você pode encontrar o completo código-fonte para isso no GitHub . Observe que, para manter as coisas simples, o aplicativo não está lidando com o método de retorno de chamada “onConnectionFailed”.

Esperamos que este tutorial ajude você a começar a usar a API de serviços de localização do Google.