Android - serviços baseados em localização

As APIs de localização do Android facilitam a criação de aplicativos com reconhecimento de localização, sem a necessidade de se concentrar nos detalhes da tecnologia de localização subjacente.

Isso se torna possível com a ajuda de Google Play services, que facilita a adição de reconhecimento de localização ao seu aplicativo com rastreamento automatizado de localização, delimitação geográfica e reconhecimento de atividades

Este tutorial mostra como usar os Serviços de Localização em seu APP para obter a localização atual, obter atualizações periódicas de localização, procurar endereços etc.

O objeto de localização

o Locationobjeto representa uma localização geográfica que pode consistir em uma latitude, longitude, carimbo de hora e outras informações, como rumo, altitude e velocidade. Existem métodos importantes a seguir que você pode usar com o objeto Location para obter informações específicas do local -

Sr. Não. Método e Descrição
1

float distanceTo(Location dest)

Retorna a distância aproximada em metros entre este local e o local fornecido.
2

float getAccuracy()

Obtenha a precisão estimada deste local, em metros.
3

double getAltitude()

Obtenha a altitude, se disponível, em metros acima do nível do mar.
4

float getBearing()

Obtenha o rumo, em graus.
5

double getLatitude()

Obtenha a latitude, em graus.
6

double getLongitude()

Obtenha a longitude, em graus.
7

float getSpeed()

Obtenha a velocidade, se disponível, em metros / segundo sobre o solo.
8

boolean hasAccuracy()

Verdadeiro se este local tiver uma precisão.
9

boolean hasAltitude()

Verdadeiro se este local tiver altitude.
10

boolean hasBearing()

Verdadeiro se este local tiver uma orientação.
11

boolean hasSpeed()

Verdadeiro se este local tiver velocidade.
12

void reset()

Limpa o conteúdo do local.
13

void setAccuracy(float accuracy)

Defina a precisão estimada deste local, metros.
14

void setAltitude(double altitude)

Defina a altitude, em metros acima do nível do mar.
15

void setBearing(float bearing)

Defina o rumo, em graus.
16

void setLatitude(double latitude)

Defina a latitude, em graus.
17

void setLongitude(double longitude)

Defina a longitude, em graus.
18

void setSpeed(float speed)

Defina a velocidade, em metros / segundo sobre o solo.
19

String toString()

Retorna uma string contendo uma descrição concisa e legível deste objeto.

Obtenha a localização atual

Para obter a localização atual, crie um cliente de localização que seja LocationClient objeto, conecte-o aos Serviços de Localização usando connect() método e, em seguida, chame-o getLastLocation()método. Este método retorna o local mais recente na forma deLocationobjeto que contém coordenadas de latitude e longitude e outras informações conforme explicado acima. Para ter funcionalidade baseada em localização em sua atividade, você terá que implementar duas interfaces -

  • GooglePlayServicesClient.ConnectionCallbacks
  • GooglePlayServicesClient.OnConnectionFailedListener

Essas interfaces fornecem os seguintes métodos de retorno de chamada importantes, que você precisa implementar em sua classe de atividade -

Sr. Não. Métodos de retorno de chamada e descrição
1

abstract void onConnected(Bundle connectionHint)

Este método de retorno de chamada é chamado quando o serviço de localização é conectado ao cliente de localização com sucesso. Você vai usarconnect() método para se conectar ao cliente local.
2

abstract void onDisconnected()

Este método de retorno de chamada é chamado quando o cliente é desconectado. Você vai usardisconnect() método para se desconectar do cliente local.
3

abstract void onConnectionFailed(ConnectionResult result)

Este método de retorno de chamada é chamado quando ocorre um erro ao conectar o cliente ao serviço.
Você deve criar o cliente de localização em onCreate() método de sua classe de atividade, em seguida, conecte-o em onStart(), para que os Serviços de localização mantenham a localização atual enquanto sua atividade estiver totalmente visível. Você deve desconectar o cliente emonStop()método, para que, quando seu aplicativo não estiver visível, os Serviços de localização não mantenham a localização atual. Isso ajuda a economizar bateria em grande medida.

Obtenha a localização atualizada

Se você deseja ter atualizações de localização, além das interfaces mencionadas acima, você precisará implementar LocationListenerinterface também. Esta interface fornece o seguinte método de retorno de chamada, que você precisa implementar em sua classe de atividade -

Sr. Não. Método de retorno de chamada e descrição
1

abstract void onLocationChanged(Location location)

Este método de retorno de chamada é usado para receber notificações do LocationClient quando o local é alterado.

Qualidade do serviço de localização

o LocationRequest objeto é usado para solicitar uma qualidade de serviço (QoS) para atualizações de localização do LocationClient. Existem métodos configuradores úteis a seguir que você pode usar para lidar com QoS. Existem métodos getter equivalentes disponíveis que você pode verificar na documentação oficial do Android.

Sr. Não. Método e Descrição
1

setExpirationDuration(long millis)

Defina a duração desta solicitação, em milissegundos.
2

setExpirationTime(long millis)

Defina o tempo de expiração da solicitação, em milissegundos, desde a inicialização.
3

setFastestInterval(long millis)

Defina explicitamente o intervalo mais rápido para atualizações de localização, em milissegundos.
4

setInterval(long millis)

Defina o intervalo desejado para atualizações de local ativo, em milissegundos.
5

setNumUpdates(int numUpdates)

Defina o número de atualizações de localização.
6

setPriority(int priority)

Defina a prioridade da solicitação.

Agora, por exemplo, se seu aplicativo deseja localização de alta precisão, deve criar uma solicitação de localização com setPriority(int) definido para PRIORITY_HIGH_ACCURACY e setInterval(long)a 5 segundos. Você também pode usar um intervalo maior e / ou outras prioridades como PRIORITY_LOW_POWER para solicitar precisão de nível de "cidade" ou PRIORITY_BALANCED_POWER_ACCURACY para precisão de nível de "bloco".

As atividades devem considerar fortemente a remoção de todas as solicitações de localização ao entrar em segundo plano (por exemplo, em onPause ()), ou pelo menos trocar a solicitação para um intervalo maior e com qualidade inferior para economizar o consumo de energia.

Exibindo um endereço de localização

Uma vez que você tenha Location objeto, você pode usar Geocoder.getFromLocation()método para obter um endereço para uma determinada latitude e longitude. Este método é síncrono e pode levar muito tempo para fazer seu trabalho, então você deve chamar o método a partir dodoInBackground() método de um AsyncTask classe.

o AsyncTask deve ser uma subclasse para ser usada e a subclasse irá sobrescrever doInBackground(Params...) método para realizar uma tarefa em segundo plano e onPostExecute(Result)método é chamado no thread de interface do usuário após o término do cálculo em segundo plano e no momento de exibir o resultado. Há mais um método importante disponível em AyncTask que éexecute(Params... params), este método executa a tarefa com os parâmetros especificados.

Exemplo

O exemplo a seguir mostra de forma prática como usar os Serviços de Localização em seu aplicativo para obter a localização atual e seus endereços equivalentes, etc.

Para experimentar este exemplo, você precisará de um dispositivo móvel real equipado com o sistema operacional Android mais recente, caso contrário, terá que lutar com o emulador, que pode não funcionar.

Criar aplicativo Android

Degrau Descrição
1 Você usará o IDE do Android Studio para criar um aplicativo Android e nomeá-lo como Tutorialspoint no pacote com.example.tutorialspoint7.myapplication .
2 adicione o arquivo src / GPSTracker.java e adicione o código necessário.
3 Modifique o arquivo src / MainActivity.java e adicione o código necessário conforme mostrado abaixo para cuidar de obter a localização atual e seu endereço equivalente.
4 Modifique o arquivo XML de layout res / layout / activity_main.xml para adicionar todos os componentes GUI que incluem três botões e duas visualizações de texto para mostrar a localização / endereço.
5 Modifique res / values ​​/ strings.xml para definir os valores constantes necessários
6 Modifique AndroidManifest.xml conforme mostrado abaixo
7 Execute o aplicativo para iniciar o emulador Android e verifique o resultado das alterações feitas no aplicativo.

A seguir está o conteúdo do arquivo de atividade principal modificado MainActivity.java.

package com.example.tutorialspoint7.myapplication;

import android.Manifest;
import android.app.Activity;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.test.mock.MockPackageManager;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {

   Button btnShowLocation;
   private static final int REQUEST_CODE_PERMISSION = 2;
   String mPermission = Manifest.permission.ACCESS_FINE_LOCATION;

   // GPSTracker class
   GPSTracker gps;

   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
		
      try {
         if (ActivityCompat.checkSelfPermission(this, mPermission)
            != MockPackageManager.PERMISSION_GRANTED) {

            ActivityCompat.requestPermissions(this, new String[]{mPermission}, 
               REQUEST_CODE_PERMISSION);

            // If any permission above not allowed by user, this condition will
               execute every time, else your else part will work
         }
      } catch (Exception e) {
         e.printStackTrace();
      }

      btnShowLocation = (Button) findViewById(R.id.button);

      // show location button click event
      btnShowLocation.setOnClickListener(new View.OnClickListener() {

         @Override
         public void onClick(View arg0) {
            // create class object
            gps = new GPSTracker(MainActivity.this);

            // check if GPS enabled
            if(gps.canGetLocation()){

               double latitude = gps.getLatitude();
               double longitude = gps.getLongitude();

               // \n is for new line
               Toast.makeText(getApplicationContext(), "Your Location is - \nLat: "
                  + latitude + "\nLong: " + longitude, Toast.LENGTH_LONG).show();
            }else{
               // can't get location
               // GPS or Network is not enabled
               // Ask user to enable GPS/network in settings
               gps.showSettingsAlert();
            }

         }
      });
   }
}

A seguir está o conteúdo do arquivo de atividade principal modificado GPSTracker.java.

package com.example.tutorialspoint7.myapplication;

import android.app.AlertDialog;
import android.app.Service;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.IBinder;
import android.provider.Settings;
import android.util.Log;

public class GPSTracker extends Service implements LocationListener {

   private final Context mContext;

   // flag for GPS status
   boolean isGPSEnabled = false;

   // flag for network status
   boolean isNetworkEnabled = false;

   // flag for GPS status
   boolean canGetLocation = false;

   Location location; // location
   double latitude; // latitude
   double longitude; // longitude

   // The minimum distance to change Updates in meters
   private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters

   // The minimum time between updates in milliseconds
   private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute

   // Declaring a Location Manager
   protected LocationManager locationManager;

   public GPSTracker(Context context) {
      this.mContext = context;
      getLocation();
   }

   public Location getLocation() {
      try {
         locationManager = (LocationManager) mContext.getSystemService(LOCATION_SERVICE);

         // getting GPS status
         isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);

         // getting network status
         isNetworkEnabled = locationManager
            .isProviderEnabled(LocationManager.NETWORK_PROVIDER);

         if (!isGPSEnabled && !isNetworkEnabled) {
            // no network provider is enabled
         } else {
            this.canGetLocation = true;
            // First get location from Network Provider
            if (isNetworkEnabled) {
               locationManager.requestLocationUpdates(
                  LocationManager.NETWORK_PROVIDER,
                  MIN_TIME_BW_UPDATES,
                  MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
						
               Log.d("Network", "Network");
               if (locationManager != null) {
                  location = locationManager
                     .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
							
                  if (location != null) {
                     latitude = location.getLatitude();
                     longitude = location.getLongitude();
                  }
               }
            }
				
            // if GPS Enabled get lat/long using GPS Services
            if (isGPSEnabled) {
               if (location == null) {
                  locationManager.requestLocationUpdates(
                     LocationManager.GPS_PROVIDER,
                     MIN_TIME_BW_UPDATES,
                     MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
							
                  Log.d("GPS Enabled", "GPS Enabled");
                  if (locationManager != null) {
                     location = locationManager
                        .getLastKnownLocation(LocationManager.GPS_PROVIDER);
								
                     if (location != null) {
                        latitude = location.getLatitude();
                        longitude = location.getLongitude();
                     }
                  }
               }
            }
         }

      } catch (Exception e) {
         e.printStackTrace();
      }

      return location;
   }

   /**
      * Stop using GPS listener
      * Calling this function will stop using GPS in your app
   * */
	
   public void stopUsingGPS(){
      if(locationManager != null){
         locationManager.removeUpdates(GPSTracker.this);
      }
   }

   /**
      * Function to get latitude
   * */
	
   public double getLatitude(){
      if(location != null){
         latitude = location.getLatitude();
      }

      // return latitude
      return latitude;
   }

   /**
      * Function to get longitude
   * */
	
   public double getLongitude(){
      if(location != null){
         longitude = location.getLongitude();
      }

      // return longitude
      return longitude;
   }

   /**
      * Function to check GPS/wifi enabled
      * @return boolean
   * */
	
   public boolean canGetLocation() {
      return this.canGetLocation;
   }

   /**
      * Function to show settings alert dialog
      * On pressing Settings button will lauch Settings Options
   * */
	
   public void showSettingsAlert(){
      AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);

      // Setting Dialog Title
      alertDialog.setTitle("GPS is settings");

      // Setting Dialog Message
      alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu?");

      // On pressing Settings button
      alertDialog.setPositiveButton("Settings", new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog,int which) {
            Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
            mContext.startActivity(intent);
         }
      });

      // on pressing cancel button
      alertDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int which) {
            dialog.cancel();
         }
      });

      // Showing Alert Message
      alertDialog.show();
   }

   @Override
   public void onLocationChanged(Location location) {
   }

   @Override
   public void onProviderDisabled(String provider) {
   }

   @Override
   public void onProviderEnabled(String provider) {
   }

   @Override
   public void onStatusChanged(String provider, int status, Bundle extras) {
   }

   @Override
   public IBinder onBind(Intent arg0) {
      return null;
   }
}

A seguir estará o conteúdo de res/layout/activity_main.xml arquivo -

<?xml version = "1.0" encoding = "utf-8"?>
<LinearLayout xmlns:android = "http://schemas.android.com/apk/res/android"
   android:layout_width = "fill_parent"
   android:layout_height = "fill_parent"
   android:orientation = "vertical" >


   <Button
      android:id = "@+id/button"
      android:layout_width = "fill_parent"
      android:layout_height = "wrap_content"
      android:text = "getlocation"/>

</LinearLayout>

A seguir estará o conteúdo de res/values/strings.xml para definir duas novas constantes -

<?xml version = "1.0" encoding = "utf-8"?>
<resources>
   <string name = "app_name">Tutorialspoint</string>
</resources>

A seguir está o conteúdo padrão de AndroidManifest.xml -

<?xml version = "1.0" encoding = "utf-8"?>
<manifest xmlns:android = "http://schemas.android.com/apk/res/android"
   package = "com.example.tutorialspoint7.myapplication">
   <uses-permission android:name = "android.permission.ACCESS_FINE_LOCATION" />
   <uses-permission android:name = "android.permission.INTERNET" />
   <application
      android:allowBackup = "true"
      android:icon = "@mipmap/ic_launcher"
      android:label = "@string/app_name"
      android:supportsRtl = "true"
      android:theme = "@style/AppTheme">
		
      <activity android:name = ".MainActivity">
         <intent-filter>
            <action android:name = "android.intent.action.MAIN" />

            <category android:name = "android.intent.category.LAUNCHER" />
         </intent-filter>
      </activity>
   </application>

</manifest>

Vamos tentar executar o seu Tutorialspointinscrição. Presumo que você conectou seu dispositivo Android real com o computador. Para executar o aplicativo no Android Studio, abra um dos arquivos de atividade do seu projeto e clique no

ícone Executar na barra de ferramentas. Antes de iniciar seu aplicativo, o instalador do Android Studio exibirá a janela a seguir para selecionar uma opção onde você deseja executar seu aplicativo Android.

Agora, para ver a localização, selecione o botão Obter localização, que exibirá as informações de localização da seguinte forma -

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved