Android onLocationChanged location.getTime() zwraca niewłaściwym czasie

Question

Mam Samsung Galaxy Tab A. I wprowadziły android.location.LocationListener i onLocationChanged(Location location) jest wywoływana i to daje mi trochę właściwą długość i szerokość geograficzną, ale

Problemem jest: location.getTime() daje mi zły czas, zwraca czas blisko 300 000 mil. Powinno to być coś w rodzaju 1471243684497.

Nie wiem, co robić.

klasa GPSTracker:

import java.io.IOException; 
import java.util.List; 
import java.util.Locale; 

import android.app.Service; 
import android.content.Context; 
import android.content.Intent; 
import android.location.Address; 
import android.location.Geocoder; 
import android.location.Location; 
import android.location.LocationListener; 
import android.location.LocationManager; 
import android.os.Bundle; 
import android.os.IBinder; 
import android.util.Log; 

public class GPSTracker extends Service implements LocationListener 
{ 
    //flag for GPS Status 
    boolean isGPSEnabled = false; 

    //flag for network status 
    //boolean isNetworkEnabled = false; 

    boolean canGetLocation = false; 

    Location location; 
    double latitude; 
    double longitude; 

    //The minimum distance to change updates in metters 
    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; //10 metters 

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

    //Declaring a Location Manager 
    protected LocationManager locationManager; 

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

    public Location getLocation(Context ctx) 
    { 
     try 
     { 
      locationManager = (LocationManager) ctx.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); 
         updateGPSCoordinates(); 
        } 
       }*/ 

       //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); 
          updateGPSCoordinates(); 
         } 
        } 
       } 
      } 
     } 
     catch (Exception e) 
     { 
      //e.printStackTrace(); 
      Log.e("Error : Location", "Impossible to connect to LocationManager", e); 
     } 

     return location; 
    } 

    public void updateGPSCoordinates() 
    { 
     if (location != null) 
     { 
      latitude = location.getLatitude(); 
      longitude = location.getLongitude(); 
     } 
    } 

    /** 
    * 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; 
    } 

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

     return longitude; 
    } 

    /** 
    * Function to check GPS/wifi enabled 
    */ 
    public boolean canGetLocation() 
    { 
     if(!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)/*&& 
       !locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)*/){ 
      this.canGetLocation = false; 
     } else { 
      this.canGetLocation = true; 
     } 
     return this.canGetLocation; 
    } 

    /** 
    * Get list of address by latitude and longitude 
    * @return null or List<Address> 
    */ 
    public List<Address> getGeocoderAddress(Context context) 
    { 
     if (location != null) 
     { 
      Geocoder geocoder = new Geocoder(context, Locale.ENGLISH); 
      try 
      { 
       List<Address> addresses = geocoder.getFromLocation(latitude, longitude, 1); 
       return addresses; 
      } 
      catch (IOException e) 
      { 
       //e.printStackTrace(); 
       Log.e("Error : Geocoder", "Impossible to connect to Geocoder", e); 
      } 
     } 

     return null; 
    } 

    /** 
    * Try to get AddressLine 
    * @return null or addressLine 
    */ 
    public String getAddressLine(Context context) 
    { 
     List<Address> addresses = getGeocoderAddress(context); 
     if (addresses != null && addresses.size() > 0) 
     { 
      Address address = addresses.get(0); 
      String addressLine = address.getAddressLine(0); 

      return addressLine; 
     } 
     else 
     { 
      return null; 
     } 
    } 

    /** 
    * Try to get Locality 
    * @return null or locality 
    */ 
    public String getLocality(Context context) 
    { 
     List<Address> addresses = getGeocoderAddress(context); 
     if (addresses != null && addresses.size() > 0) 
     { 
      Address address = addresses.get(0); 
      String locality = address.getLocality(); 

      return locality; 
     } 
     else 
     { 
      return null; 
     } 
    } 

    /** 
    * Try to get Postal Code 
    * @return null or postalCode 
    */ 
    public String getPostalCode(Context context) 
    { 
     List<Address> addresses = getGeocoderAddress(context); 
     if (addresses != null && addresses.size() > 0) 
     { 
      Address address = addresses.get(0); 
      String postalCode = address.getPostalCode(); 

      return postalCode; 
     } 
     else 
     { 
      return null; 
     } 
    } 

    /** 
    * Try to get CountryName 
    * @return null or postalCode 
    */ 
    public String getCountryName(Context context) 
    { 
     List<Address> addresses = getGeocoderAddress(context); 
     if (addresses != null && addresses.size() > 0) 
     { 
      Address address = addresses.get(0); 
      String countryName = address.getCountryName(); 

      return countryName; 
     } 
     else 
     { 
      return null; 
     } 
    } 

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

I moje własne klasy, która rozszerza klasę GPSTracker:

public class NewMainService extends GPSTracker { 


    @Override 
    public void onLocationChanged(Location location) { 
     long time = location.getTime(); 
     Log.i("TAG", "onLocationChanged time: "+time); //prints wrong timestamp 
     super.onLocationChanged(location); 
    } 
} 

EDIT:

wszystko działa poprawnie na innych urządzeniach.

I googled to i jest to błąd w niektórych urządzeniach. nasłuchiwanie lokalizacji przestaje otrzymywać zmiany po pewnym czasie.

czas, jaki mi daje, to jak czas działania urządzenia, to kilka godzin, to nie jest randka.

Answer 1

Można użyć odbiornika lokalizacji NMEA i uzyskać tylko czas od tego. To zawsze prawda i jest w czasie UTC, nawet jeśli zmienisz strefę czasową swojego urządzenia lub datę i godzinę, to zawsze da ci aktualną prawdziwą datę i godzinę.

Limitaions:

-jeżeli GPS lub lokalizacji jest wyłączone, nie dostaniesz NMEA. (możesz sprawdzić, czy Lokalizacja jest włączona).

-jeśli lokalizacja jest włączona, ale użytkownik zmienił jej dokładność na sieć tylko za pośrednictwem ustawień, nie dostaniesz NMEA. (można sprawdzić, czy locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER))