Location issue in Android 10

package com.artoon.location;

import android.Manifest;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.app.ActivityCompat;
import androidx.core.location.LocationManagerCompat;

import com.google.android.gms.common.api.ApiException;
import com.google.android.gms.common.api.ResolvableApiException;
import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationAvailability;
import com.google.android.gms.location.LocationCallback;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationResult;
import com.google.android.gms.location.LocationSettingsRequest;
import com.google.android.gms.location.LocationSettingsResponse;
import com.google.android.gms.location.LocationSettingsStatusCodes;
import com.google.android.gms.location.SettingsClient;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;
import com.karumi.dexter.Dexter;
import com.karumi.dexter.MultiplePermissionsReport;
import com.karumi.dexter.PermissionToken;
import com.karumi.dexter.listener.multi.MultiplePermissionsListener;

import org.json.JSONObject;

import java.util.List;

import static com.google.android.gms.location.LocationServices.getFusedLocationProviderClient;
import static com.google.android.gms.location.LocationServices.getSettingsClient;

public class LocationActivity extends Activity {

    private static final String TAG = "LocationPlugin";
    private SettingsClient mSettingsClient = null;
    private FusedLocationProviderClient fusedLocationClient;
    private int REQUEST_CHECK_SETTINGS = 0x1;

    private LocationCallback locationCallback = new LocationCallback() {
        @Override
        public void onLocationResult(LocationResult locationResult) {
            super.onLocationResult(locationResult);
            fusedLocationClient.removeLocationUpdates(locationCallback);
            Location location = locationResult.getLastLocation();
            if (location != null) {
                SuccessCallback(location);
            } else {
                FailCallback("");
            }
        }

        @Override
        public void onLocationAvailability(LocationAvailability locationAvailability) {
            super.onLocationAvailability(locationAvailability);
            Log.e(TAG, "onLocationAvailability: called " + locationAvailability);
        }
    };

    private void FailCallback(String reason) {
        Log.e(TAG, "FailCallback: " + reason);
        finish();
    }

    @SuppressLint("MissingPermission")
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);


        mSettingsClient = getSettingsClient(this);
        fusedLocationClient = getFusedLocationProviderClient(this);

        if (!checkPermissions()) {
            String error = "Not have permission of location";
            Log.e("Location", error);
            takePermission();
        } else {
            getLastLocation();
        }


    }

    private void SuccessCallback(Location location) {
        Log.e(TAG, "SuccessCallback: " + location);
        try {
            JSONObject obj = new JSONObject();
            obj.put("latitude", location.getLatitude());
            obj.put("longitude", location.getLongitude());
            Log.d("Success","Location "+obj.toString());

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

    @SuppressLint("MissingPermission")
    private void getLastLocation() {
        fusedLocationClient.getLastLocation()
                .addOnCompleteListener(this, new OnCompleteListener<Location>() {
                    @Override
                    public void onComplete(@NonNull Task<Location> task) {
                        if (task.isSuccessful()) {
                            Location location = task.getResult();
                            if (location != null) {
                                SuccessCallback(location);
                            } else {
                                getLocation();
                            }
                        } else {
                            getLocation();
                        }
                    }
                });
    }

    @SuppressLint("MissingPermission")
    private void getLocation() {
        final LocationRequest mLocationRequest = getLocationRequest();
        LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
        builder.setAlwaysShow(true);
        builder.addLocationRequest(mLocationRequest);
        LocationSettingsRequest mLocationSettingsRequest = builder.build();
        mSettingsClient.checkLocationSettings(mLocationSettingsRequest)
                .addOnFailureListener(new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        int statusCode = ((ApiException) e).getStatusCode();

                        if (statusCode == LocationSettingsStatusCodes.RESOLUTION_REQUIRED) {
                            Log.i(TAG, "Location settings are not satisfied. Attempting to upgrade " + "location settings ");
                            try {
                                ResolvableApiException rae = (ResolvableApiException) e;
                                rae.startResolutionForResult(LocationActivity.this, REQUEST_CHECK_SETTINGS);
                            } catch (IntentSender.SendIntentException e1) {
                                Log.i(TAG, "PendingIntent unable to execute request." + e1);
                            }
                        } else if (statusCode == LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE) {
                            String errorMessage =
                                    "Location settings are inadequate, and cannot be" + "fixed here. Fix in Settings.";
                            Log.e(TAG, errorMessage);
                            Toast.makeText(LocationActivity.this, errorMessage, Toast.LENGTH_LONG).show();


                        } else {
                            String errorMessage = "Location settings Can't found";
                            Log.e(TAG, errorMessage);
                            Toast.makeText(LocationActivity.this, errorMessage, Toast.LENGTH_LONG).show();

                        }
                    }
                })
                .addOnSuccessListener(new OnSuccessListener<LocationSettingsResponse>() {
                    @Override
                    public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
                        requestLocation();
                    }
                });
    }

    private void requestLocation() {
        if (ActivityCompat.checkSelfPermission(LocationActivity.this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        LocationRequest mLocationRequest = getLocationRequest();
        fusedLocationClient.requestLocationUpdates(mLocationRequest, locationCallback, Looper.getMainLooper());
    }

    private LocationRequest getLocationRequest() {
        LocationRequest request = new LocationRequest();
        request.setInterval(1000);
        request.setNumUpdates(1);
        request.setMaxWaitTime(2500);
        request.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        return request;
    }

    /**
     * Returns the current state of the permissions needed.
     */
    private boolean checkPermissions() {
        return PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(
                this,
                Manifest.permission.ACCESS_COARSE_LOCATION
        ) && PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(
                this,
                Manifest.permission.ACCESS_COARSE_LOCATION
        );
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Log.e(TAG, "onActivityResult: ");
            LocationManager lm = (LocationManager) getSystemService(LOCATION_SERVICE);
            if (LocationManagerCompat.isLocationEnabled(lm)) {
                Log.d(TAG, "Location is enabled by user");
                requestLocation();

            } else {
                Log.d(TAG, "Location enable request is cancelled by user");

            }


    }

    private void takePermission() {
        Dexter.withContext(this)
                .withPermissions(
                        Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.ACCESS_COARSE_LOCATION
                )
                .withListener(new MultiplePermissionsListener() {
                    @Override
                    public void onPermissionsChecked(MultiplePermissionsReport p0) {
                        if (p0.areAllPermissionsGranted()) {
                            getLocation();
                        } else {
                            if (p0.getDeniedPermissionResponses().size() > 0) {
                                Log.e("Error","Location Permission Not Granted");
                            }
                        }
                    }

                    @Override
                    public void onPermissionRationaleShouldBeShown(List<com.karumi.dexter.listener.PermissionRequest> list, PermissionToken permissionToken) {
                        if (permissionToken != null) {
                            permissionToken.continuePermissionRequest();
                        }
                    }
                }).check();
    }

    @Override
    public void finish() {
        fusedLocationClient.removeLocationUpdates(locationCallback);
        super.finish();
    }
}