Android Location Manager, Get GPS location ,if no GPS then get to Network Provider location

前端 未结 7 2173
臣服心动
臣服心动 2020-11-29 20:52

I am using this given below code to get locations:

public Location getLocation() {
        try {
            mLocationManager = (LocationManager) context.get         


        
相关标签:
7条回答
  • 2020-11-29 20:56

    You're saying that you need GPS location first if its available, but what you did is first you're getting location from network provider and then from GPS. This will get location from Network and GPS as well if both are available. What you can do is, write these cases in if..else if block. Similar to-

    if( !isGPSEnabled && !isNetworkEnabled) {
    
    // Can't get location by any way
    
    } else {
    
        if(isGPSEnabled) {
    
        // get location from GPS
    
        } else if(isNetworkEnabled) {
    
        // get location from Network Provider
    
        }
    }
    

    So this will fetch location from GPS first (if available), else it will try to fetch location from Network Provider.

    EDIT:

    To make it better, I'll post a snippet. Consider it is in try-catch:

    boolean gps_enabled = false;
    boolean network_enabled = false;
    
    LocationManager lm = (LocationManager) mCtx
                    .getSystemService(Context.LOCATION_SERVICE);
    
    gps_enabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER);
    network_enabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    
    Location net_loc = null, gps_loc = null, finalLoc = null;
    
    if (gps_enabled)
        gps_loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
    if (network_enabled)
        net_loc = lm.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
    
    if (gps_loc != null && net_loc != null) {
    
        //smaller the number more accurate result will
        if (gps_loc.getAccuracy() > net_loc.getAccuracy()) 
            finalLoc = net_loc;
        else
            finalLoc = gps_loc;
    
            // I used this just to get an idea (if both avail, its upto you which you want to take as I've taken location with more accuracy)
    
    } else {
    
        if (gps_loc != null) {
            finalLoc = gps_loc;
        } else if (net_loc != null) {
            finalLoc = net_loc;
        }
    }
    

    Now you check finalLoc for null, if not then return it. You can write above code in a function which returns the desired (finalLoc) location. I think this might help.

    0 讨论(0)
  • 2020-11-29 20:57

    If you want to run inside a background service and take the data in foreground use the below one, it is tested and verified.

    public class MyService extends Service 
            implements OnMapReadyCallback, GoogleApiClient.ConnectionCallbacks, 
            GoogleApiClient.OnConnectionFailedListener, 
            com.google.android.gms.location.LocationListener {
    
    
        private static final int ASHIS = 1234;
        Intent intentForPendingIntent;
        HandlerThread handlerThread;
        Looper looper;
        GoogleApiClient mGoogleApiClient;
        private LocationRequest mLocationRrequest;
        private static final int UPDATE_INTERVAL = 1000;
        private static final int FASTEST_INTERVAL = 100;
        private static final int DSIPLACEMENT_UPDATES = 1;
        ;
        private Handler handler1;
        private Runnable runable1;
        private Location mLastLocation;
        private float waitingTime;
        private int waiting2min;
        private Location locationOld;
        private double distance;
        private float totalWaiting;
        private float speed;
        private long timeGpsUpdate;
        private long timeOld;
        private NotificationManager mNotificationManager;
        Notification notification;
        PendingIntent resultPendingIntent;
        NotificationCompat.Builder mBuilder;
    
    
        // Sets an ID for the notification
        int mNotificationId = 001;
        private static final String TAG = "BroadcastService";
        public static final String BROADCAST_ACTION = "speedExceeded";
        private final Handler handler = new Handler();
        Intent intentforBroadcast;
        int counter = 0;
        private Runnable sendUpdatesToUI;
    
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            Toast.makeText(MyService.this, "binder", Toast.LENGTH_SHORT).show();
    
            return null;
        }
    
    
        @Override
        public void onCreate() {
            showNotification();
            intentforBroadcast  = new Intent(BROADCAST_ACTION);
    
            Toast.makeText(MyService.this, "created", Toast.LENGTH_SHORT).show();
    
            if (mGoogleApiClient == null) {
                mGoogleApiClient = new GoogleApiClient.Builder(this)
                        .addConnectionCallbacks(this)
                        .addOnConnectionFailedListener(this)
                        .addApi(LocationServices.API)
                        .build();
            }
            createLocationRequest();
            mGoogleApiClient.connect();
    
    
        }
    
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
        private void showNotification() {
    
            mBuilder =
                    (NotificationCompat.Builder) new NotificationCompat.Builder(this)
                            .setSmallIcon(R.drawable.ic_media_play)
                            .setContentTitle("Total Waiting Time")
                            .setContentText(totalWaiting+"");
    
    
            Intent resultIntent = new Intent(this, trackingFusion.class);
    
            // Because clicking the notification opens a new ("special") activity, there's
            // no need to create an artificial back stack.
            PendingIntent resultPendingIntent =
                    PendingIntent.getActivity(
                            this,
                            0,
                            resultIntent,
                            PendingIntent.FLAG_UPDATE_CURRENT
                    );
            mBuilder.setContentIntent(resultPendingIntent);
            NotificationManager mNotifyMgr =
                    (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            // Builds the notification and issues it.
    
            mNotifyMgr.notify(mNotificationId, mBuilder.build());
    
    
            startForeground(001, mBuilder.getNotification());
        }
    
    
        @Override
        public void onLocationChanged(Location location) {
    
            //handler.removeCallbacks(runable);
    
            Toast.makeText(MyService.this, "speed" + speed, Toast.LENGTH_SHORT).show();
            timeGpsUpdate = location.getTime();
            float delta = (timeGpsUpdate - timeOld) / 1000;
            if (location.getAccuracy() < 100) {
                speed = location.getSpeed();
                distance += mLastLocation.distanceTo(location);
                Log.e("distance", "onLocationChanged: " + distance);
                //mLastLocation = location;
                //newLocation = mLastLocation;
    
                Log.e("location:", location + "");
    
    
                //speed = (long) (distance / delta);
    
    
                locationOld = location;
                mLastLocation = location;
    
                diaplayViews();
            }
    
            diaplayViews();
         /*if (map != null) {
             map.addMarker(new MarkerOptions()
                     .position(new LatLng(location.getLatitude(), location.getLongitude()))
                     .title("Hello world"));
    
    
         }*/
        }
    
    
        private void createLocationRequest() {
    
            mLocationRrequest = new LocationRequest();
    
            mLocationRrequest.setInterval(UPDATE_INTERVAL);
            mLocationRrequest.setFastestInterval(FASTEST_INTERVAL);
            mLocationRrequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
            mLocationRrequest.setSmallestDisplacement(DSIPLACEMENT_UPDATES);
    
        }
    
    
        private void methodToCalculateWaitingTime() {
    
    
            if (handler1 != null) {
                handler1.removeCallbacks(runable1);
    
            }
    
    
            Log.e("Here", "here1");
            handler1 = new Handler(Looper.getMainLooper());
            runable1 = new Runnable() {
                public void run() {
    
                    Log.e("Here", "here2:" + mLastLocation.getSpeed());
    
    
                    if (mLastLocation != null) {
                        diaplayViews();
                        if ((mLastLocation.getSpeed() == 0.0)) {
    
                            increaseTime();
    
                        } else {
                            if (waitingTime <= 120) {
                                waiting2min = 0;
    
                            }
                        }
                        handler1.postDelayed(this, 10000);
                    } else {
                        if (ActivityCompat.checkSelfPermission(MyService.this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(MyService.this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                            // TODO: Consider calling
                            //    ActivityCompat#requestPermissions
                            // here to request the missing permissions, and then overriding
                            //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                            //                                          int[] grantResults)
                            // to handle the case where the user grants the permission. See the documentation
                            // for ActivityCompat#requestPermissions for more details.
                            return;
                        }
    
                        locationOld = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
                        mLastLocation = locationOld;
    
                    }
                }
            };
    
            handler1.postDelayed(runable1, 10000);
    
    
        }
    
        private void diaplayViews() {
            float price = (float) (14 + distance * 0.5);
    
            //textDistance.setText(waitingTime);a
        }
    
    
        private void increaseTime() {
            waiting2min = waiting2min + 10;
            if (waiting2min >= 120)
    
            {
                if (waiting2min == 120) {
                    waitingTime = waitingTime + 2 * 60;
    
    
                } else {
                    waitingTime = waitingTime + 10;
                }
    
    
                totalWaiting = waitingTime / 60;
                showNotification();
                Log.e("waiting Time", "increaseTime: " + totalWaiting);
            }
    
    
        }
    
        @Override
        public void onDestroy() {
            Toast.makeText(MyService.this, "distroyed", Toast.LENGTH_SHORT).show();
            if (mGoogleApiClient.isConnected()) {
    
                mGoogleApiClient.disconnect();
            }
            mGoogleApiClient.disconnect();
    
        }
    
        @Override
        public void onConnected(Bundle bundle) {
            Log.e("Connection_fusion", "connected");
    
            startLocationUpdates();
    
    
        }
    
    
        @Override
        public void onConnectionSuspended(int i) {
    
        }
    
        private void startLocationUpdates() {
            Location location = plotTheInitialMarkerAndGetInitialGps();
            if (location == null) {
                plotTheInitialMarkerAndGetInitialGps();
    
    
            } else {
    
                mLastLocation = location;
                methodToCalculateWaitingTime();
            }
        }
    
        private Location plotTheInitialMarkerAndGetInitialGps() {
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                // TODO: Consider calling
                //    ActivityCompat#requestPermissions
                // here to request the missing permissions, and then overriding
                //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
                //                                          int[] grantResults)
                // to handle the case where the user grants the permission. See the documentation
                // for ActivityCompat#requestPermissions for more details.
                return null;
            }
            LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRrequest, this);
            locationOld = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
            if ((locationOld != null)) {
                mLastLocation = locationOld;
    
                timeOld = locationOld.getTime();
            } else {
                startLocationUpdates();
            }
    
            return mLastLocation;
        }
    
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            onStart(intent, startId);
            Toast.makeText(MyService.this, "start command", Toast.LENGTH_SHORT).show();
    
            sendUpdatesToUI = new Runnable() {
                public void run() {
                    DisplayLoggingInfo();
                    handler.postDelayed(this, 10000); // 5 seconds
                }
            };
            handler.postDelayed(sendUpdatesToUI, 10000); // 1 second
            Log.i("LocalService", "Received start id " + startId + ": " + intent);
            return START_NOT_STICKY;
        }
    
        @Override
        public void onStart(Intent intent, int startId) {
            sendUpdatesToUI = new Runnable() {
                public void run() {
                    Log.e("sent", "sent");
                    DisplayLoggingInfo();
                    handler.postDelayed(this, 5000); // 5 seconds
                }
            };
            handler.postDelayed(sendUpdatesToUI, 1000); // 1 second
            Log.i("LocalService", "Received start id " + startId + ": " + intent);
            super.onStart(intent, startId);
        }
    
        private void DisplayLoggingInfo() {
            Log.d(TAG, "entered DisplayLoggingInfo");
            intentforBroadcast.putExtra("distance", distance);
            LocalBroadcastManager.getInstance(this).sendBroadcast(intentforBroadcast);
        }
    
        @Override
        public void onConnectionFailed(ConnectionResult connectionResult) {
    
        }
    
        @Override
        public void onMapReady(GoogleMap googleMap) {
    
        }
    }
    
    0 讨论(0)
  • 2020-11-29 21:00

    there are better ways to do it as mentioned on android developer sites http://developer.android.com/guide/topics/location/strategies.html

    0 讨论(0)
  • 2020-11-29 21:04

    I made some changes in above code to look for a location fix by both GPS and Network for about 5sec and give me the best known location out of it.

    public class LocationService implements LocationListener {
    
        boolean isGPSEnabled = false;
    
        boolean isNetworkEnabled = false;
    
        boolean canGetLocation = false;
    
        final static long MIN_TIME_INTERVAL = 60 * 1000L;
    
        Location location;
    
    
        // The minimum distance to change Updates in meters
        private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 0; // 10
    
        // The minimum time between updates in milliseconds
        private static final long MIN_TIME_BW_UPDATES = 1; // 1 minute
    
        protected LocationManager locationManager;
    
        private CountDownTimer timer = new CountDownTimer(5 * 1000, 1000) {
    
            public void onTick(long millisUntilFinished) {
    
            }
    
            public void onFinish() {
                stopUsingGPS();
            }
        };
    
        public LocationService() {
            super(R.id.gps_service_id);
        }
    
    
        public void start() {
            if (Utils.isNetworkAvailable(context)) {
    
                try {
    
    
                    timer.start();
    
    
                    locationManager = (LocationManager) context
                            .getSystemService(Context.LOCATION_SERVICE);
    
                    isGPSEnabled = locationManager
                            .isProviderEnabled(LocationManager.GPS_PROVIDER);
    
                    isNetworkEnabled = locationManager
                            .isProviderEnabled(LocationManager.NETWORK_PROVIDER);
                    this.canGetLocation = true;
                    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 tempLocation = locationManager
                                    .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                            if (tempLocation != null
                                    && isBetterLocation(tempLocation,
                                            location))
                                location = tempLocation;
                        }
                    }
                    if (isGPSEnabled) {
    
                        locationManager.requestSingleUpdate(
                                LocationManager.GPS_PROVIDER, this, 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 tempLocation = locationManager
                                    .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                            if (tempLocation != null
                                    && isBetterLocation(tempLocation,
                                            location))
                                location = tempLocation;
                        }
                    }
    
                } catch (Exception e) {
                    onTaskError(e.getMessage());
                    e.printStackTrace();
                }
            } else {
                onOfflineResponse(requestData);
            }
        }
    
        public void stopUsingGPS() {
            if (locationManager != null) {
                locationManager.removeUpdates(LocationService.this);
            }
        }
    
        public boolean canGetLocation() {
            locationManager = (LocationManager) context
                    .getSystemService(Context.LOCATION_SERVICE);
            isGPSEnabled = locationManager
                    .isProviderEnabled(LocationManager.GPS_PROVIDER);
    
            // getting network status
            isNetworkEnabled = locationManager
                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);
            return isGPSEnabled || isNetworkEnabled;
        }
    
        @Override
        public void onLocationChanged(Location location) {
    
            if (location != null
                    && isBetterLocation(location, this.location)) {
    
                this.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 Object getResponseObject(Object location) {
            return location;
        }
    
        public static boolean isBetterLocation(Location location,
                Location currentBestLocation) {
            if (currentBestLocation == null) {
                // A new location is always better than no location
                return true;
            }
    
            // Check whether the new location fix is newer or older
            long timeDelta = location.getTime() - currentBestLocation.getTime();
            boolean isSignificantlyNewer = timeDelta > MIN_TIME_INTERVAL;
            boolean isSignificantlyOlder = timeDelta < -MIN_TIME_INTERVAL;
            boolean isNewer = timeDelta > 0;
    
            // If it's been more than two minutes since the current location,
            // use the new location
            // because the user has likely moved
            if (isSignificantlyNewer) {
                return true;
                // If the new location is more than two minutes older, it must
                // be worse
            } else if (isSignificantlyOlder) {
                return false;
            }
    
            // Check whether the new location fix is more or less accurate
            int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation
                    .getAccuracy());
            boolean isLessAccurate = accuracyDelta > 0;
            boolean isMoreAccurate = accuracyDelta < 0;
            boolean isSignificantlyLessAccurate = accuracyDelta > 200;
    
            // Check if the old and new location are from the same provider
            boolean isFromSameProvider = isSameProvider(location.getProvider(),
                    currentBestLocation.getProvider());
    
            // Determine location quality using a combination of timeliness and
            // accuracy
            if (isMoreAccurate) {
                return true;
            } else if (isNewer && !isLessAccurate) {
                return true;
            } else if (isNewer && !isSignificantlyLessAccurate
                    && isFromSameProvider) {
                return true;
            }
            return false;
        }
    
    }
    

    In the above class, I am registering a location listener for both GPS and network, so an onLocationChanged call back can be called by either or both of them multiple times and we just compare the new location fix with the one we already have and keep the best one.

    0 讨论(0)
  • 2020-11-29 21:15

    The recommended way to do this is to use LocationClient:

    First, define location update interval values. Adjust this to your needs.

    private static final int MILLISECONDS_PER_SECOND = 1000;
    private static final long UPDATE_INTERVAL = MILLISECONDS_PER_SECOND * UPDATE_INTERVAL_IN_SECONDS;
    private static final int FASTEST_INTERVAL_IN_SECONDS = 1;
    private static final long FASTEST_INTERVAL = MILLISECONDS_PER_SECOND * FASTEST_INTERVAL_IN_SECONDS;
    

    Have your Activity implement GooglePlayServicesClient.ConnectionCallbacks, GooglePlayServicesClient.OnConnectionFailedListener, and LocationListener.

    public class LocationActivity extends Activity implements 
    GooglePlayServicesClient.ConnectionCallbacks, GooglePlayServicesClient.OnConnectionFailedListener, LocationListener {}
    

    Then, set up a LocationClientin the onCreate() method of your Activity:

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    
        mLocationClient = new LocationClient(this, this, this);
    
        mLocationRequest = LocationRequest.create();
        mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        mLocationRequest.setInterval(UPDATE_INTERVAL);
        mLocationRequest.setFastestInterval(FASTEST_INTERVAL);
    }
    

    Add the required methods to your Activity; onConnected() is the method that is called when the LocationClientconnects. onLocationChanged() is where you'll retrieve the most up-to-date location.

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        Log.w(TAG, "Location client connection failed");
    }
    
    @Override
    public void onConnected(Bundle dataBundle) {
        Log.d(TAG, "Location client connected");
        mLocationClient.requestLocationUpdates(mLocationRequest, this); 
    }
    
    @Override
    public void onDisconnected() {
        Log.d(TAG, "Location client disconnected");
    }
    
    @Override
    public void onLocationChanged(Location location) {
        if (location != null) {
            Log.d(TAG, "Updated Location: " + Double.toString(location.getLatitude()) + "," + Double.toString(location.getLongitude()));
        } else {
            Log.d(TAG, "Updated location NULL");
        } 
    }     
    

    Be sure to connect/disconnect the LocationClient so it's only using extra battery when absolutely necessary and so the GPS doesn't run indefinitely. The LocationClient must be connected in order to get data from it.

    public void onResume() {
        super.onResume();
        mLocationClient.connect();
    }
    
    public void onStop() {
        if (mLocationClient.isConnected()) {
            mLocationClient.removeLocationUpdates(this);
        }
        mLocationClient.disconnect();
        super.onStop();
    }
    

    Get the user's location. First try using the LocationClient; if that fails, fall back to the LocationManager.

    public Location getLocation() {
        if (mLocationClient != null && mLocationClient.isConnected()) {
            return mLocationClient.getLastLocation();
        } else {
            LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
            if (locationManager != null) {
                Location lastKnownLocationGPS = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
                if (lastKnownLocationGPS != null) {
                    return lastKnownLocationGPS;
                } else {
                    return locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                }
            } else {
                return null;
            }
        }
    }
    
    0 讨论(0)
  • 2020-11-29 21:15

    use the fusion API that google developer have developed with fusion of GPS Sensor,Magnetometer,Accelerometer also using Wifi or cell location to calculate or estimate the location. It is also able to give location updates also inside the building accurately.

    package com.example.ashis.gpslocation;
    
    import android.app.Activity;
    import android.location.Location;
    import android.os.Bundle;
    import android.support.v7.app.ActionBarActivity;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.widget.TextView;
    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.common.api.GoogleApiClient.ConnectionCallbacks;
    import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
    import com.google.android.gms.location.LocationListener;
    import com.google.android.gms.location.LocationRequest;
    import com.google.android.gms.location.LocationServices;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Location sample.
     *
     * Demonstrates use of the Location API to retrieve the last known location for a device.
     * This sample uses Google Play services (GoogleApiClient) but does not need to authenticate a user.
     * See https://github.com/googlesamples/android-google-accounts/tree/master/QuickStart if you are
     * also using APIs that need authentication.
     */
    
    public class MainActivity extends Activity implements LocationListener,
            GoogleApiClient.ConnectionCallbacks,
            GoogleApiClient.OnConnectionFailedListener {
    
        private static final long ONE_MIN = 500;
        private static final long TWO_MIN = 500;
        private static final long FIVE_MIN = 500;
        private static final long POLLING_FREQ = 1000 * 20;
        private static final long FASTEST_UPDATE_FREQ = 1000 * 5;
        private static final float MIN_ACCURACY = 1.0f;
        private static final float MIN_LAST_READ_ACCURACY = 1;
    
        private LocationRequest mLocationRequest;
        private Location mBestReading;
    TextView tv;
        private GoogleApiClient mGoogleApiClient;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            if (!servicesAvailable()) {
                finish();
            }
    
            setContentView(R.layout.activity_main);
    tv= (TextView) findViewById(R.id.tv1);
            mLocationRequest = LocationRequest.create();
            mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
            mLocationRequest.setInterval(POLLING_FREQ);
            mLocationRequest.setFastestInterval(FASTEST_UPDATE_FREQ);
    
            mGoogleApiClient = new GoogleApiClient.Builder(this)
                    .addApi(LocationServices.API)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .build();
    
    
            if (mGoogleApiClient != null) {
                mGoogleApiClient.connect();
            }
        }
    
        @Override
        protected void onResume() {
            super.onResume();
    
            if (mGoogleApiClient != null) {
                mGoogleApiClient.connect();
            }
        }
    
        @Override
        protected void onPause() {d
            super.onPause();
    
            if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
                mGoogleApiClient.disconnect();
            }
        }
    
    
            tv.setText(location + "");
            // Determine whether new location is better than current best
            // estimate
            if (null == mBestReading || location.getAccuracy() < mBestReading.getAccuracy()) {
                mBestReading = location;
    
    
                if (mBestReading.getAccuracy() < MIN_ACCURACY) {
                    LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
                }
            }
        }
    
        @Override
        public void onConnected(Bundle dataBundle) {
            // Get first reading. Get additional location updates if necessary
            if (servicesAvailable()) {
    
                // Get best last location measurement meeting criteria
                mBestReading = bestLastKnownLocation(MIN_LAST_READ_ACCURACY, FIVE_MIN);
    
                if (null == mBestReading
                        || mBestReading.getAccuracy() > MIN_LAST_READ_ACCURACY
                        || mBestReading.getTime() < System.currentTimeMillis() - TWO_MIN) {
    
                    LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
    
                   //Schedule a runnable to unregister location listeners
    
                        @Override
                        public void run() {
                            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, MainActivity.this);
    
                        }
    
                    }, ONE_MIN, TimeUnit.MILLISECONDS);
    
                }
    
            }
        }
    
        @Override
        public void onConnectionSuspended(int i) {
    
        }
    
    
        private Location bestLastKnownLocation(float minAccuracy, long minTime) {
            Location bestResult = null;
            float bestAccuracy = Float.MAX_VALUE;
            long bestTime = Long.MIN_VALUE;
    
            // Get the best most recent location currently available
            Location mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
            //tv.setText(mCurrentLocation+"");
            if (mCurrentLocation != null) {
                float accuracy = mCurrentLocation.getAccuracy();
                long time = mCurrentLocation.getTime();
    
                if (accuracy < bestAccuracy) {
                    bestResult = mCurrentLocation;
                    bestAccuracy = accuracy;
                    bestTime = time;
                }
            }
    
            // Return best reading or null
            if (bestAccuracy > minAccuracy || bestTime < minTime) {
                return null;
            }
            else {
                return bestResult;
            }
        }
    
        @Override
        public void onConnectionFailed(ConnectionResult connectionResult) {
    
        }
    
        private boolean servicesAvailable() {
            int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
    
            if (ConnectionResult.SUCCESS == resultCode) {
                return true;
            }
            else {
                GooglePlayServicesUtil.getErrorDialog(resultCode, this, 0).show();
                return false;
            }
        }
    }
    
    0 讨论(0)
提交回复
热议问题