Localização + Distancia

MainActivity.java

 /**
  *   compile 'com.google.android.gms:play-services-maps:9.6.1'
  *   compile 'com.google.android.gms:play-services-location:9.6.1'
 **/

import android.Manifest;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationManager;
import android.os.AsyncTask;
import android.os.Handler;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationListener;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.model.LatLng;
import com.google.maps.android.SphericalUtil;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.ExecutionException;

public class MainActivity extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {
    /**
     * Código da solcitação de permissão. <br/>
     * Usado para saber quando a solictação voltar a tela.
     */
    private static final int CODE_PERMISSION_LOCATION = 9001;


    /**
     * {@link GoogleApiClient} : fornece a localização através do {@link LocationServices#API}
     */
    private GoogleApiClient mGoogleApiClient;




    private final LatLng torrePanoramica = new LatLng(-25.424298, -49.294457);
    private final LatLng pracaDoJapao = new LatLng(-25.446037, -49.287517);
    private final LatLng zooLogico = new LatLng(-25.559541, -49.231263);
    private final LatLng jardimBotanico = new LatLng(-25.443126, -49.238238);

    private Location mLocation;

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

        /**
         * Intancia o GoogleApiClient
         */
        mGoogleApiClient = new GoogleApiClient.Builder(this).
                addConnectionCallbacks(this).
                addOnConnectionFailedListener(this).
                addApi(LocationServices.API).
                build();

    }


    /**
     * Verifica se há permissão de ACCESS_FINE_LOCATION.
     */
    private void checkPermission() {
        // Verifica necessidade de verificacao de permissão
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // Verifica necessidade de explicar necessidade da permissão
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
                Toast.makeText(this, "É necessário permissão de localização", Toast.LENGTH_SHORT).show();
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        CODE_PERMISSION_LOCATION);
            } else {
                // Solicita permissão
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        CODE_PERMISSION_LOCATION);
            }
        }
    }


    /**
     * OnStart
     * Ao inciar, conecta o GoogleApi
     */
    @Override
    protected void onStart() {
        super.onStart();

        //Verifica se já possui a permissão
        if(!(ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED)){

            connectGoogleAPI();
        }else{
            //Chama o pop up solicitando a permissão
            checkPermission();
        }

    }



    /**
     * Connecta o googleAPI
     */
    private void connectGoogleAPI() {

        if(isGpsOn()){
            if (null != mGoogleApiClient) {
                Log.i("DISTANCE", "connect.....");
                mGoogleApiClient.connect();
            }
        }else{
            AlertDialog.Builder builderDialog = new AlertDialog.Builder(this);
            builderDialog.setTitle("GPS").setMessage("Por favor, \nPara que possamos proporcionar uma melhor experiência, Ative seu GPS!").setCancelable(false).
                    setPositiveButton("ATIVAR", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            //Chamamos a tela de Configuração do GPS
                            MainActivity.this.startActivityForResult(new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS), 1233);
                            dialogInterface.dismiss();
                        }
                    }).create().show();

        }



    }

    /**
     * OnStop
     * Ao sair da tela, disconecta da API
     */
    @Override
    protected void onStop() {
        super.onStop();
        if (null != mGoogleApiClient) {
            mGoogleApiClient.disconnect();
        }
    }


    /**
     * Verifica se o Gps está ativo
     *
     * @return GPS ativo
     */
    private boolean isGpsOn() {
        return LocationManager.class.cast(getSystemService(Context.LOCATION_SERVICE)).isProviderEnabled(LocationManager.GPS_PROVIDER);
    }


    /**
     * Implementação de GoogleApiClient.ConnectionCallbacks
     * @param bundle
     */
    @Override
    public void onConnected(@Nullable Bundle bundle) {

        /**
         * Verificamos se há a permissão
         */
        if (!(ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED)) {

            /**
             * Pegamos a última posição, esta pode ser nula (se o gps estiver deligado por exemplo!)
             */
            mLocation  = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
            if (mLocation != null) {
                Toast.makeText(this, "Latitude:" + mLocation.getLatitude()+", Longitude:"+mLocation.getLongitude(),Toast.LENGTH_LONG).show();
                new LoadAddress().execute(mLocation);

                final LatLng me = new LatLng(mLocation.getLatitude(), mLocation.getLongitude());

                 final Double d1 =  SphericalUtil.computeDistanceBetween(me, torrePanoramica);
                 final Double d2 =  SphericalUtil.computeDistanceBetween(me, pracaDoJapao);
                 final Double d3 =  SphericalUtil.computeDistanceBetween(me, zooLogico);
                 final Double d4 =  SphericalUtil.computeDistanceBetween(me, jardimBotanico);
                Log.d("DISTANCE", "torrePanoramica : "+formatDistance(d1)+"  " );
                Log.d("DISTANCE", "pracaDoJapao : "+formatDistance(d2)+"  " );
                Log.d("DISTANCE", "zooLogico : "+formatDistance(d3)+"  " );
                Log.d("DISTANCE", "jardimBotanico : "+formatDistance(d4)+"  " );

            }

        }
    }

    /**
     * Responásel por formatar a distância
     * @param distance
     * @return
     */
    private String formatDistance(final Double distance){
        if(null == distance){
            return "";
        }

        /**
         * Formato em que vamos exbir a distância,
         */
        DecimalFormat decimalFormat = (DecimalFormat) NumberFormat.getNumberInstance(Locale.getDefault());
        decimalFormat.applyPattern("#.#");

        // Se é menor que 1000 então usamos metros
        if(distance< 1000){
           return String.format(Locale.getDefault(), "%sm", distance.intValue());
        }else{
            final String value = decimalFormat.format(  distance / 1000 );
            return String.format(Locale.getDefault(), "%skm", value);
        }
    }

    /**
     * Retorno de chamada para o resultado de solicitação de permissões.
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        // Verifica resultado
        if (requestCode == CODE_PERMISSION_LOCATION) {
            if (grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this, "É necessário permitir a localização, para melhor experiência do app", Toast.LENGTH_SHORT).show();
            }else{
                connectGoogleAPI();
            }
        }
    }




    /**
     * Implementação de GoogleApiClient.ConnectionCallbacks
     * @param i
     */
    @Override
    public void onConnectionSuspended(int i) {}


    /**
     * GoogleApiClient.OnConnectionFailedListener
     * @param connectionResult
     */
    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {}

    /**
     * LocationListener
     * @param location
     */
    @Override
    public void onLocationChanged(Location location) {}


    /**
     * AsyncTask que através do Location pega o nome da Cidade
     */
    class LoadAddress extends AsyncTask<Location, Void, String>{


        private Geocoder mGeoCoder;

        @Override
        protected void onPreExecute() {
            mGeoCoder = new Geocoder(getApplicationContext(), Locale.getDefault());
        }

        @Override
        protected String doInBackground(Location... locations) {
            final Location l = locations[0];
            if(null == l){
                return null;
            }
            List<Address> addresses = null;
            try{
                // vamos pegar apenas 1 endereço
                addresses = mGeoCoder.getFromLocation(l.getLatitude(), l.getLongitude(), 1);

                if(null == addresses || addresses.size() == 0){
                    return null;
                }
                final Address _address = addresses.get(0);

                return _address.getLocality();

                /**
                 * Address[addressLines=[0:"Avenida João Gualberto, 717 - Alto da Glória",1:"Curitiba - PR",2:"Brasil"],
                 *        feature=717, admin=Paraná, sub-admin=null, locality=Curitiba,
                 *        thoroughfare=Avenida João Gualberto, postalCode=80030, countryCode=BR,
                 *        countryName=Brasil ,hasLatitude=true, latitude=-25.419892, hasLongitude=true,
                 *         longitude=-49.2653363,phone=null,url=null,extras=null]
                 */

            }catch (final Exception e){
                e.printStackTrace();
                return null;
            }
        }

        @Override
        protected void onPostExecute(String s) {
            if(null == s){
                Toast.makeText(getApplicationContext(), "Não foi possível carregar! ", Toast.LENGTH_SHORT).show();
            }else{
                Toast.makeText(getApplicationContext(), s, Toast.LENGTH_SHORT).show();

            }
        }
    }


}