hi to all
how can i get the speed using the ACCESS_COARSE_LOCATION in android
thank you
Hi are you referring to Location.getSpeed() I believe that is an optional field and probably up to the device to actually support it. First off try this
Criteria criteria = new Criteria();
criteria.setSpeedRequired(true);
LocationProvider[] providers = mLocationManager.getProviders(criteria, false);
if (providers == null || providers.length == 0) {
//Sorry it doesn't do it by default.
}
Luckily Math and Science will help us :) Just calculate the speed as you get updates from your LocationProviders. Make sure to calculate the distance between the lat,longs over times as the difference of the recorded times stamps of two Location updates.
...
onLocationChanged(Location location) {
if (mOldLocation != null) {
float distance = getDistance(mOldLocation, location);
long time = location.getTime() - mOldLocation.getTime();
mSpeed = distance/time;
}
mOldLocation = location;
}
It won't necessarily be greatly accurate (probably really noisy) but it's better to make lemonade than to have rotted fruit ... hopefully this helps. Make sure to only compare deltas across the same provider too. You will probably find yourself tweaking the manual calculation because the devices providers are very diverse and don't guarantee that time always moves forward.
Most likely, you cannot. Location technology that is "coarse" only knows where you are within several hundred meters. Your speed could vary wildly. If you need to know your speed, you will most likely need a "fine" location provider.
Or, better yet, use the Criteria object to stipulate that you need to know the device's speed, and let it guide you to the best provider to use.
Related
I am trying to make a simple app that revolves around tracking someone's speed. I have read through Android Studio's Location guide, however it doesn't show how to get someone's speed, or get someone's location at an even interval.
Currently, I have this snippet of code set up:
if (OldLocation != null) {
OldLocation = NewLocation;
NewLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
} else {
OldLocation = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
try {Thread.sleep(1000);} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
NewLocation = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
}
float distance = OldLocation.distanceTo(NewLocation);
float speed = distance / 1000;
I am currently using Thread.sleep to do this, though I think there would be a better way to request updates periodically.
Can anyone show me how?
That is the worst way you can possible do it. For a dozen reasons you should almost never use getLastKnownLocation- and getting continual updates is definitely NOT one of those places to do it. Instead, use LocationManager.requestLocationUpdates(). You provide it a callback object and it calls you when an updated position is available.
Also, use LocationManager or the Google Play Fused Location. There's no good reason to mix and match.
I have the following code in main activity:
LocationManager mlocMan = (LocationManager)getActivity().getSystemService(Context.LOCATION_SERVICE);
if (mlocMan.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
LocationListener mlocListener = new LocationManagerHelper(...);
mlocMan.requestLocationUpdates(LocationManager.GPS_PROVIDER,0,0,mlocListener);
}
In the location listener I have this: (theAccuracy was initialized to -1)
if (theAccuracy == -1 || theAccuracy > loc.getAccuracy()) {
theAccuracy = Math.round(loc.getAccuracy());
latitude = loc.getLatitude();
longitude = loc.getLongitude();
}
updateTimes++;
if (updateTimes == 3) {
mLocMan.removeUpdates(this);
updateTimes = 0;
//get address for location
theAccuracy = -1;
}
Meaning, after 3 location updates from the GPS, take the best accurate location and get its address. On the emulator I get fixed accuracy of 20m (I send long/lat using DDMS) but that's not real life so I tried with my device and while the very first time (3 requests) gave me the exact address (on the spot) with 40m accuracy, the next ones were sometimes more accurate but the address was nearby. The best accuracy I got was 29m (happened once) most of the times it's above 30. Is this a problem of my GPS (LG G3) or is there any other idea that can make things more accurate after 3-4-5 requests?
A few reasons:
Your emulator doesn't have actual gps hardware, so it's probably using your ip address, so that's why it seems fixed.
GPS hardware on your phone has to warm up a bit. Set the frequency of polling up for a bit (1 update a second, or half-second), and let it run for a few seconds, before taking measurements that count.
The location manager supports both hardware and network lookups (wifi / celltowers). Not sure how to set provider to just your phone's hardware, but if you use the googlePlayServices gps client (LocationClient), it's quite simple:
mLocationRequest = LocationRequest.create();
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
mLocationClient.requestLocationUpdates(mLocationRequest, (LocationListener) this);
You're probably testing at your computer in doors. Buildings definitely effect gps accuracy.
I've been using the fused location provider since its release and I am pretty happy with it (way better than the old system). But I ran into a peculiar problem when using geofencing in combination with LocationClient.lastKnownLocation(). The setup is as follows:
I drop several geofences around some home location (with increasing ranges). When I get the intent that a fence is crossed I retrieve the last known location from LocationClient and work with it. Apart from than I also registered for regular location updates with update mode PRIORITY_BALANCED_POWER_ACCURACY.
Most of the times this works perfectly fine, but sometimes this happens:
Time 000 s - (Lat,Lon,Accuracy) = (48.127316,11.5855167,683.0)
Time 120 s - (Lat,Lon,Accuracy) = (48.1260497,11.5731745,31.823)
Time 300 s - (Lat,Lon,Accuracy) = (48.1217455,11.5641666,143.81)
Time 420 s - (Lat,Lon,Accuracy) = (48.1189942,11.559061,36.0)
Time 600s - (Lat,Lon,Accuracy) = (48.127316,11.5855167,683.0)
Notice that all these locations are retrieved by getLastKnownLocation(). What seems fishy here is that the first and the last location are identical (even in the other attributes), to be more specific:
* intent at time 0: *
component: ComponentInfo{package.Class}
key [location]: Location[mProvider=fused,mTime=1373524391934,mLatitude=48.127316,mLongitude=11.5855167,mHasAltitude=false,mAltitude=0.0,mHasSpeed=false,mSpeed=0.0,mHasBearing=false,mBearing=0.0,mHasAccuracy=true,mAccuracy=683.0,mExtras=Bundle[mParcelledData.dataSize=352]]
* intent at time 600: *
component: ComponentInfo{package.Class}
key [location]: Location[mProvider=fused,mTime=1373524994871,mLatitude=48.127316,mLongitude=11.5855167,mHasAltitude=false,mAltitude=0.0,mHasSpeed=false,mSpeed=0.0,mHasBearing=false,mBearing=0.0,mHasAccuracy=true,mAccuracy=683.0,mExtras=Bundle[mParcelledData.dataSize=352]]
* note the ~600 s difference in the timestamp *
I do not understand how this can happen, as there have been locations in between that were both more recent and more accurate. Also the new timestamp on an old location makes me curious... apparently similar things happened when using the old API, but this new location provider is just called fused, so I can not distinguish GPS from WPS from sensors... If it is the cell tower switching problem (outlined in the linked question concerning the old API) then why would the phone connect to a "far away" tower if it has seen closer towers?
Why is this happening?
The first and last points were gotten using cell triangulation. The error/accuracy is typical of cell-based location, and it looks like the Google power saving logic decided that switching to cell would be OK, even as you say its recent history included points much closer.
Aw, SHUCKS! I got this too today... And I moved to the new Google Play Services location precisely to AVOID this... And I was so thrilled up until just now when I got it too. You may or may not know that the old one had these kind of problems, and it was a pain.
There are lots of threads regarding this, including one of my own :(
Why is locationmanager returning old location fixes with new gettime-timestamp?
I guess the only thing to do is avoid using cached location...
Instead of polling, one can work around one or more sources of inaccuracy using this subscription mechanism.
LocationListener locListener = new LocationListener() {
#Override
public void onLocationChanged(Location location) {
if (location == null)
return;
// process these:
// location.getLatitude();
// location.getLongitude();
// location.getAccuracy();
...
}
...
}
((LocationManager) getSystemService(Context.LOCATION_SERVICE)
.requestLocationUpdates(LocationManager.GPS_PROVIDER,
minTimeMilliSec,
minDistanceMeters,
locListener));
I have used the code below and everything is working fine except that onLocationChanged is called even if I am sitting at the same location .
I thought it should be called only when I am moving right ?
I only want to get the location after I have moved a certain distance.
Please help me out.
Thanks in advance.
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
locationMgr = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationMgr.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,
this);
}
#Override
public void onLocationChanged(Location location) {
Toast.makeText(this, "Working!", Toast.LENGTH_SHORT).show();
if (location != null) {
double lat = location.getLatitude();
double lng = location.getLongitude();
String Text = "Latitud = " + lat + "\nLongitud = " +
lng;
Toast.makeText(getBaseContext(),Text,Toast.LENGTH_SHORT).show();
}
}
You're requesting location updates at the shortest possible intervals/distances
locationMgr.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,
this);
This is what the documentation says about those parameters
" The location update interval can be controlled using the minTime parameter. The elapsed time between location updates will never be less than minTime, although it can be more depending on the Location Provider implementation and the update interval requested by other applications. "
The minDistance parameter can also be used to control the frequency of location updates. If it is greater than 0 then the location provider will only send your application an update when the location has changed by at least minDistance meters, AND at least minTime milliseconds have passed. However it is more difficult for location providers to save power using the minDistance parameter, so minTime should be the primary tool to conserving battery life.
I personally use a minTime of 10 seconds and 10 meters for my app
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10000,
10, locationListener);
Network location is not as precise as you would think it is. Therefore the result returned by the sensors can fluctuate. This is even more true when you consider that GPS signal weakens if you don't have direct line of sight with the satellites, and the number of visible satellites also has effect on the precision. This gets even worse when you start using the network provider, where the position is calculated by triangulation of the signal strength of cell towers, and the number and SSIDs of visible wireless network. Since these can fluctuate quite a lot, the precision suffers greatly. There are bunch of averaging algorithms, and heuristics employed to minimize such fluctuations, but ultimately nothing can stabilize it to be as good as you expect it to be.
A simple averaging and variation filtering can help you. Adding a correction based on the device accelerometer can also help a lot, but it will make your code more complex.
I'd like to track my Location every minute. For that I use a locManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 60000, 0, pll);
Here is the log when my phone is idle.
Date Latitude Longitude Accuracy
07:45:35 51.362402459999996 - 6.2174867399999995 (75.0)
07:46:35 51.362402459999996 - 6.2174867399999995 (75.0)
07:47:35 51.362402459999996 - 6.2174867399999995 (75.0)
...
07:50:35 51.362402459999996 - 6.2174867399999995 (75.0) # I'm further than 75m away from my home at that time
I've indeed a new location every minute but it is exactly the same. Just the time is updated. The position is not updated (maybe normal when I don't move enough) but I find it strange that the coordinates are exactly the same. Also as I don't have wireless activated, it should locate me accordingly to the CellId (with an accuracy of ~1000m), here I still have an accuracy of 75.0. It seems, it is the last location recorded using wireless networks.
Any idea how can I record the real last location (even with low accuracy) ?
public void onLocationChanged(Location location) {
System.out.println(new Date(location.getTime())+" "
+location.getLatitude()+" - "+location.getLongitude()+" ("+location.getAccuracy()+")");
callback.addEntry(location);
}
Hey use GPS_PROVIDER instead of NETWORK_PROVIDER as per below code
locManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 60000, 0, pll);
NETWORK_PROVIDER will give you only fix tower location and gps will give you exact changing location
You have got nearest GSM tower coordinates.
It seems there is no way to force to compute the position using the LocationManager with the celltower only when there is no wireless connexion.
Maybe another way would be to use the method mentioned in the thread Poor Man GPS : manually compute the position knowing the CellId.
Pseudo code :
onLocationChanged(new_location)
if isConnected()
record(new_location)
else
cell_location = poorManGPS()
record(cell_location)
end
The problem is of course that I cannot query the cell-id database with no internet connection. I see several solutions :
Store the current (and previous) cell id when I have internet and hope I'll stay in this one when I won't have internet
Use the cell id database on the phone (but I think root privileges needed)
Store the cell id for further localization