GPS location is not working in Mashmallow Version

Question

This is My Code

@Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        switch (requestCode) {
            case 1: {
                // If request is cancelled, the result arrays are empty.
                TrackGPS gps = new TrackGPS(this, DashboardActivity.this);
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//                    if (ActivityCompat.shouldShowRequestPermissionRationale(this,Manifest.permission.ACCESS_FINE_LOCATION)){
//
//                        Toast.makeText(this,"GPS permission allows us to access location data. Please allow in App Settings for additional functionality.",Toast.LENGTH_LONG).show();
//
//                    }

                    if (gps.canGetLocation()) {
                        double latitude = gps.getLatitude();
                        double logitude = gps.getLongitude();
                        System.out.println("latitude=" + latitude);
                        System.out.println("logitude=" + logitude);
                        city = getCity(latitude, logitude);

                        tvCity.setText(city);

                    }
                }
            }
        }

    }
}

Permission related problem for tracking location via GPS.How to request for permission when using a higher version devices like Marshmallow.

Answer 1

You Can give any manifest permission as of now here Read and write external storage permission is given

public static final int MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE = 123;
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        public static boolean checkPermission(final Context context)
        {
            int currentAPIVersion = Build.VERSION.SDK_INT;
            if(currentAPIVersion>=android.os.Build.VERSION_CODES.M)
            {
                if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
                    if (ActivityCompat.shouldShowRequestPermissionRationale((Activity) context, Manifest.permission.READ_EXTERNAL_STORAGE)) {
                        AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context);
                        alertBuilder.setCancelable(true);
                        alertBuilder.setTitle("Permission necessary");
                        alertBuilder.setMessage("External storage permission is necessary");
                        alertBuilder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                            @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
                            public void onClick(DialogInterface dialog, int which) {
                                ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE);
                            }
                        });
                        AlertDialog alert = alertBuilder.create();
                        alert.show();
                    } else {
                        ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE);
                    }
                    return false;
                } else {
                    return true;
                }
            } else {
                return true;
            }

Answer 2

Try this

btnCurrentLocation.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String permission = android.Manifest.permission.ACCESS_FINE_LOCATION;
                if (ActivityCompat.checkSelfPermission(SearchCityClass.this, permission)
                        != PackageManager.PERMISSION_GRANTED && ActivityCompat.
                        checkSelfPermission(SearchCityClass.this, android.Manifest.permission.ACCESS_COARSE_LOCATION)
                        != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions(SearchCityClass.this, new String[]
                            {permission}, PERMISSION_GPS_CODE);

                } else {
                    isPermissionGranted(true);                       

                }
            }

        });

than

@Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == PERMISSION_GPS_CODE) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {


                Toast.makeText(this, R.string.location_permission_granted_msg, Toast.LENGTH_SHORT).show();

            } else {

                Toast.makeText(this, R.string.location_permission_not_granted_msg, Toast.LENGTH_SHORT).show();
            }
        }

    }

crate a method name isPermissionGranted

public void isPermissionGranted(boolean permission) {
        if (!permission) {
            startActivity(new Intent(SearchCityClass.this, CheckPermissionClasss.class)
                    .putExtra("permissionName", "location"));
        } else {

            gps = new GPSTracker(SearchCityClass.this);
            if (gps.canGetLocation()) {
                if (gps.isGPSEnabled /*|| gps.isNetworkEnabled*/) {
                    double latitude = gps.getLatitude();
                    double longitude = gps.getLongitude();

/*
                    Toast.makeText(getApplicationContext(), "Sending Your Location is - \nLat: "
                            + latitude + "\nLong: " + longitude, Toast.LENGTH_LONG).show();
*/

                   /* Intent i = new Intent(SearchCityClass.this, SearchAreaClass.class);
                    i.putExtra("longitude", longitude);
                    i.putExtra("latitude", latitude);
                    startActivity(i);*/

                    Intent i = new Intent(context, SearchResultClass.class);
                    i.putExtra("city", "Ahmedabad");
                    SearchResultClass.flag = 1;
                    i.putExtra("room", 1);
                    context.startActivity(i);


                } else {
                    if (!gps.isGPSEnabled) {
                        Toast.makeText(SearchCityClass.this, R.string.gps_not_available_err, Toast.LENGTH_SHORT).show();
                        gps.showSettingsAlert();
                    } else if (!gps.isNetworkEnabled) {
                        Toast.makeText(SearchCityClass.this, getString(R.string.str_internet_err), Toast.LENGTH_SHORT).show();
                        return;
                    }


                }

            } else {
                //gps.showSettingsAlert();
            }

        }
    }

than create one class like this

import android.Manifest;
import android.app.AlertDialog;
import android.app.Service;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
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.support.v4.app.ActivityCompat;
import android.util.Log;
import android.widget.Toast;

import com.ncrypted.redfox.R;


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 = 1; // 10 meters
    // The minimum time between updates in milliseconds
    private static final long MIN_TIME_BW_UPDATES = 1000 * 60; // 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);
//            Toast.makeText(mContext, "isGPSEnabled = "+isGPSEnabled, Toast.LENGTH_SHORT).show();
            // getting network status
            isNetworkEnabled = locationManager
                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);
//            Toast.makeText(mContext, "isNetworkEnabled = "+isNetworkEnabled, Toast.LENGTH_SHORT).show();

            if (!isGPSEnabled && !isNetworkEnabled) {
                // no network provider is enabled
                showSettingsAlert();
                Toast.makeText(mContext, getString(R.string.str_internet_err), Toast.LENGTH_SHORT).show();
            } 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) {
                            Log.d("isNetworkEbanbled", "Network Available");
                            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 is Enabled");
                        if (locationManager != null) {
                            location = locationManager
                                    .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                            if (location != null) {
                                Log.d("isGPSEnabled", "GPS");
                                latitude = location.getLatitude();
                                longitude = location.getLongitude();
                            }
                        }
                    }
                }
                if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

                }
            }

        } 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) {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                    != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            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(R.string.gps_setting_dialog_title);

        // Setting Dialog Message
        alertDialog.setMessage(R.string.gps_dialog_msg);

        // On pressing Settings button
        alertDialog.setPositiveButton(R.string.gps_setting_dailog_seeting, 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(R.string.gps_dailog_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;
    }

}

than add permission in manifest file like this

 <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Answer 3

Try this I am also facing the problem.

1. You have to reload your activity
2. After that, you can get location`
3. take boolean in gps tracker class
4. make sure alert is in try catch to avoid crash if you want to enable or disable Gps

---

public class GpsTracker extends Service implements LocationListener {

private final Context mContext;

 public static boolean isFromSetting=false;
// 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 {
        if (ActivityCompat.checkSelfPermission(mContext, 
    Manifest.permission.ACCESS_FINE_LOCATION) != 
      PackageManager.PERMISSION_GRANTED
                && ActivityCompat.checkSelfPermission(mContext, 
  Manifest.permission.ACCESS_COARSE_LOCATION) != 
   PackageManager.PERMISSION_GRANTED) {

            return null;
        }
        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) {
                if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
                        && ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

                    return 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){
    if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
            && ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

        return ;
    }
    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(){
         try{
         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);
             isFromSetting = true;
            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();
       }catch(Exception e){e.printstacktrace}
      }

      @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;
         }
        } 

---

1. In you MainActivity.java do this

---

@Override
protected void onResume() {
    super.onResume();
  if (GPSTracker.isFromSetting==true){
            finish();
            startActivity(getIntent());
            GPSTracker.isFromSetting=false;
        }
     }
       @Override
        public void onBackPressed() {
          super.onBackPressed();
         if (GPSTracker.isFromSetting==true){
           finish();
            startActivity(getIntent());
            GPSTracker.isFromSetting=false;
           }
          }
      @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
       gps = new GPSTracker(LoginActivity.this);

    if(gps.canGetLocation()){

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

        Log.e("55",""+latitude);
        Log.e("56",""+longitude);
        Toast.makeText(getApplicationContext(), "Your Location is - \nLat: "                   
        + latitude + "\nLong: " + longitude, Toast.LENGTH_LONG).show();
         }else{

            gps.showSettingsAlert(); 
          }
        }

Answer 4

writed code in main activity
  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

    switch (requestCode) {
        case 1: {
 TrackGPS gps = new TrackGPS(getApplicationContext(), DashboardActivity.this);
  if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
if (gps.canGetLocation()) {
                    double latitude = gps.getLatitude();
                    double logitude = gps.getLongitude();
                    System.out.println("latitude=" + latitude);
                    System.out.println("logitude=" + logitude);
                    city = getCity(latitude, logitude);

                    tvCity.setText(city);

                }
            }
}
}
//this marshmallow permission call in oncreate method
 private void marshmallowGPSPremissionCheck() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
            && this.checkSelfPermission(
            Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
            && this.checkSelfPermission(
            Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(
                new String[]{Manifest.permission.ACCESS_COARSE_LOCATION,
                        Manifest.permission.ACCESS_FINE_LOCATION},
                MY_PERMISSION_LOCATION);
    } else {
        //   gps functions.

    }
}