// Copyright 2007 The Android Open Source Project
package com.android.internal.location;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import android.location.Criteria;
import android.location.Location;
import android.location.LocationProviderImpl;
import android.os.Bundle;
import android.util.Config;
import android.util.Log;
/**
* A dummy provider that returns positions interpolated from a sequence
* of caller-supplied waypoints. The waypoints are supplied as a
* String containing one or more numeric quadruples of the form:
* <br>
* <code>
* <time in millis> <latitude> <longitude> <altitude>
* </code>
*
* <p> The waypoints must be supplied in increasing timestamp order.
*
* <p> The time at which the provider is constructed is considered to
* be time 0, and further requests for positions will return a
* position that is linearly interpolated between the waypoints whose
* timestamps are closest to the amount of wall clock time that has
* elapsed since time 0.
*
* <p> Following the time of the last waypoint, the position of that
* waypoint will continue to be returned indefinitely.
*
* {@hide}
*/
public class TrackProvider extends LocationProviderImpl {
static final String LOG_TAG = "TrackProvider";
private static final long INTERVAL = 1000L;
private boolean mEnabled = true;
private double mLatitude;
private double mLongitude;
private boolean mHasAltitude;
private boolean mHasBearing;
private boolean mHasSpeed;
private double mAltitude;
private float mBearing;
private float mSpeed;
private Bundle mExtras;
private long mBaseTime;
private long mLastTime = -1L;
private long mTime;
private long mMinTime;
private long mMaxTime;
private List<Waypoint> mWaypoints = new ArrayList<Waypoint>();
private int mWaypointIndex = 0;
private boolean mRequiresNetwork = false;
private boolean mRequiresSatellite = false;
private boolean mRequiresCell = false;
private boolean mHasMonetaryCost = false;
private boolean mSupportsAltitude = true;
private boolean mSupportsSpeed = true;
private boolean mSupportsBearing = true;
private boolean mRepeat = false;
private int mPowerRequirement = Criteria.POWER_LOW;
private int mAccuracy = Criteria.ACCURACY_COARSE;
private float mTrackSpeed = 100.0f; // km/hr - default for kml tracks
private Location mInitialLocation;
private void close(Reader rdr) {
try {
if (rdr != null) {
rdr.close();
}
} catch (IOException e) {
Log.w(LOG_TAG, "Exception closing reader", e);
}
}
public void readTrack(File trackFile) {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(trackFile), 8192);
String s;
long lastTime = -Long.MAX_VALUE;
while ((s = br.readLine()) != null) {
String[] tokens = s.split("\\s+");
if (tokens.length != 4 && tokens.length != 6) {
Log.e(LOG_TAG, "Got track \"" + s +
"\", wanted <time> <long> <lat> <alt> [<bearing> <speed>]");
continue;
}
long time;
double longitude, latitude, altitude;
try {
time = Long.parseLong(tokens[0]);
longitude = Double.parseDouble(tokens[1]);
latitude = Double.parseDouble(tokens[2]);
altitude = Double.parseDouble(tokens[3]);
} catch (NumberFormatException e) {
Log.e(LOG_TAG, "Got track \"" + s +
"\", wanted <time> <long> <lat> <alt> " +
"[<bearing> <speed>]", e);
continue;
}
Waypoint w = new Waypoint(getName(), time, latitude, longitude, altitude);
if (tokens.length >= 6) {
float bearing, speed;
try {
bearing = Float.parseFloat(tokens[4]);
speed = Float.parseFloat(tokens[5]);
w.setBearing(bearing);
w.setSpeed(speed);
} catch (NumberFormatException e) {
Log.e(LOG_TAG, "Ignoring bearing and speed \"" +
tokens[4] + "\", \"" + tokens[5] + "\"", e);
}
}
if (mInitialLocation == null) {
mInitialLocation = w.getLocation();
}
// Ignore waypoints whose time is less than or equal to 0 or
// the time of the previous waypoint
if (time < 0) {
Log.e(LOG_TAG, "Ignoring waypoint at negative time=" + time);
continue;
}
if (time <= lastTime) {
Log.e(LOG_TAG, "Ignoring waypoint at time=" + time +
" (< " + lastTime + ")");
continue;
}
mWaypoints.add(w);
lastTime = time;
}
setTimes();
return;
} catch (IOException e) {
Log.e(LOG_TAG, "Exception reading track file", e);
mWaypoints.clear();
} finally {
close(br);
}
}
public void readKml(File kmlFile) {
FileReader kmlReader = null;
try {
kmlReader = new FileReader(kmlFile);
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser xpp = factory.newPullParser();
xpp.setInput(kmlReader);
// Concatenate the text of each <coordinates> tag
boolean inCoordinates = false;
StringBuilder sb = new StringBuilder();
int eventType = xpp.getEventType();
do {
if (eventType == XmlPullParser.START_DOCUMENT) {
// do nothing
} else if (eventType == XmlPullParser.END_DOCUMENT) {
// do nothing
} else if (eventType == XmlPullParser.START_TAG) {
String startTagName = xpp.getName();
if (startTagName.equals("coordinates")) {
inCoordinates = true;
}
} else if (eventType == XmlPullParser.END_TAG) {
String endTagName = xpp.getName();
if (endTagName.equals("coordinates")) {
inCoordinates = false;
}
} else if (eventType == XmlPullParser.TEXT) {
if (inCoordinates) {
sb.append(xpp.getText());
sb.append(' ');
}
}
eventType = xpp.next();
} while (eventType != XmlPullParser.END_DOCUMENT);
String coordinates = sb.toString();
// Parse the "lon,lat,alt" triples and supply times
// for each waypoint based on a constant speed
Location loc = null;
double KM_PER_HOUR = mTrackSpeed;
double KM_PER_METER = 1.0 / 1000.0;
double MILLIS_PER_HOUR = 60.0 * 60.0 * 1000.0;
double MILLIS_PER_METER =
(1.0 / KM_PER_HOUR) * (KM_PER_METER) * (MILLIS_PER_HOUR);
long time = 0L;
StringTokenizer st = new StringTokenizer(coordinates, ", ");
while (st.hasMoreTokens()) {
try {
String lon = st.nextToken();
String lat = st.nextToken();
String alt = st.nextToken();
if (Config.LOGD) {
Log.d(LOG_TAG,
"lon=" + lon + ", lat=" + lat + ", alt=" + alt);
}
double nLongitude = Double.parseDouble(lon);
double nLatitude = Double.parseDouble(lat);
double nAltitude = Double.parseDouble(alt);
Location nLoc = new Location(getName());
nLoc.setLatitude(nLatitude);
nLoc.setLongitude(nLongitude);
if (loc != null) {
double distance = loc.distanceTo(nLoc);
if (Config.LOGD) {
Log.d(LOG_TAG, "distance = " + distance);
}
time += (long) (distance * MILLIS_PER_METER);
}
Waypoint w = new Waypoint(getName(), time,
nLatitude, nLongitude, nAltitude);
if (supportsSpeed()) {
w.setSpeed(mTrackSpeed);
}
if (supportsBearing()) {
w.setBearing(0.0f);
}
mWaypoints.add(w);
if (mInitialLocation == null) {
mInitialLocation = w.getLocation();
}
loc = nLoc;
} catch (NumberFormatException nfe) {
Log.e(LOG_TAG, "Got NumberFormatException reading KML data: " +
nfe, nfe);
}
}
setTimes();
return;
} catch (IOException ioe) {
mWaypoints.clear();
Log.e(LOG_TAG, "Exception reading KML data: " + ioe, ioe);
// fall through
} catch (XmlPullParserException xppe) {
mWaypoints.clear();
Log.e(LOG_TAG, "Exception reading KML data: " + xppe, xppe);
// fall through
} finally {
close(kmlReader);
}
}
public void readNmea(String name, File file) {
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader(file), 8192);
String s;
String provider = getName();
NmeaParser parser = new NmeaParser(name);
while ((s = br.readLine()) != null) {
boolean newWaypoint = parser.parseSentence(s);
if (newWaypoint) {
Location loc = parser.getLocation();
Waypoint w = new Waypoint(loc);
mWaypoints.add(w);
// Log.i(TAG, "Got waypoint " + w);
}
}
setTimes();
return;
} catch (IOException ioe) {
Log.e(LOG_TAG, "Exception reading NMEA data: " + ioe);
mWaypoints.clear();
} finally {
close(br);
}
}
private static boolean booleanVal(String tf) {
return (tf == null) || (tf.equalsIgnoreCase("true"));
}
private static int intVal(String val) {
try {
return (val == null) ? 0 : Integer.parseInt(val);
} catch (NumberFormatException nfe) {
return 0;
}
}
private static float floatVal(String val) {
try {
return (val == null) ? 0 : Float.parseFloat(val);
} catch (NumberFormatException nfe) {
return 0.0f;
}
}
public void readProperties(File propertiesFile) {
BufferedReader br = null;
if (!propertiesFile.exists()) {
return;
}
try {
if (Config.LOGD) {
Log.d(LOG_TAG, "Loading properties file " +
propertiesFile.getPath());
}
br = new BufferedReader(new FileReader(propertiesFile), 8192);
String s;
while ((s = br.readLine()) != null) {
StringTokenizer st = new StringTokenizer(s);
String command = null;
String value = null;
if (!st.hasMoreTokens()) {
continue;
}
command = st.nextToken();
if (st.hasMoreTokens()) {
value = st.nextToken();
}
if (command.equalsIgnoreCase("requiresNetwork")) {
setRequiresNetwork(booleanVal(value));
} else if (command.equalsIgnoreCase("requiresSatellite")) {
setRequiresSatellite(booleanVal(value));
} else if (command.equalsIgnoreCase("requiresCell")) {
setRequiresCell(booleanVal(value));
} else if (command.equalsIgnoreCase("hasMonetaryCost")) {
setHasMonetaryCost(booleanVal(value));
} else if (command.equalsIgnoreCase("supportsAltitude")) {
setSupportsAltitude(booleanVal(value));
} else if (command.equalsIgnoreCase("supportsBearing")) {
setSupportsBearing(booleanVal(value));
} else if (command.equalsIgnoreCase("repeat")) {
setRepeat(booleanVal(value));
} else if (command.equalsIgnoreCase("supportsSpeed")) {
setSupportsSpeed(booleanVal(value));
} else if (command.equalsIgnoreCase("powerRequirement")) {
setPowerRequirement(intVal(value));
} else if (command.equalsIgnoreCase("accuracy")) {
setAccuracy(intVal(value));
} else if (command.equalsIgnoreCase("trackspeed")) {
setTrackSpeed(floatVal(value));
} else {
Log.e(LOG_TAG, "Unknown command \"" + command + "\"");
}
}
} catch (IOException ioe) {
Log.e(LOG_TAG, "IOException reading properties file " +
propertiesFile.getPath(), ioe);
} finally {
try {
if (br != null) {
br.close();
}
} catch (IOException e) {
Log.w(LOG_TAG, "IOException closing properties file " +
propertiesFile.getPath(), e);
}
}
}
public TrackProvider(String name) {
super(name);
setTimes();
}
public TrackProvider(String name, File file) {
this(name);
String filename = file.getName();
if (filename.endsWith("kml")) {
readKml(file);
} else if (filename.endsWith("nmea")) {
readNmea(getName(), file);
} else if (filename.endsWith("track")) {
readTrack(file);
} else {
Log.e(LOG_TAG, "Can't initialize TrackProvider from file " +
filename + " (not *kml, *nmea, or *track)");
}
setTimes();
}
private void setTimes() {
mBaseTime = System.currentTimeMillis();
if (mWaypoints.size() >= 2) {
mMinTime = mWaypoints.get(0).getTime();
mMaxTime = mWaypoints.get(mWaypoints.size() - 1).getTime();
} else {
mMinTime = mMaxTime = 0;
}
}
private double interp(double d0, double d1, float frac) {
return d0 + frac * (d1 - d0);
}
private void update() {
// Don't update the position at all unless INTERVAL milliseconds
// have passed since the last request
long time = System.currentTimeMillis() - mBaseTime;
if (time - mLastTime < INTERVAL) {
return;
}
List<Waypoint> waypoints = mWaypoints;
if (waypoints == null) {
return;
}
int size = waypoints.size();
if (size < 2) {
return;
}
long t = time;
if (t < mMinTime) {
t = mMinTime;
}
if (mRepeat) {
t -= mMinTime;
long deltaT = mMaxTime - mMinTime;
t %= 2 * deltaT;
if (t > deltaT) {
t = 2 * deltaT - t;
}
t += mMinTime;
} else if (t > mMaxTime) {
t = mMaxTime;
}
// Locate the time interval for the current time
// We slide the window since we don't expect to move
// much between calls
Waypoint w0 = waypoints.get(mWaypointIndex);
Waypoint w1 = waypoints.get(mWaypointIndex + 1);
// If the right end of the current interval is too early,
// move forward to the next waypoint
while (t > w1.getTime()) {
w0 = w1;
w1 = waypoints.get(++mWaypointIndex + 1);
}
// If the left end of the current interval is too late,
// move back to the previous waypoint
while (t < w0.getTime()) {
w1 = w0;
w0 = waypoints.get(--mWaypointIndex);
}
// Now we know that w0.mTime <= t <= w1.mTime
long w0Time = w0.getTime();
long w1Time = w1.getTime();
long dt = w1Time - w0Time;
float frac = (dt == 0) ? 0 : ((float) (t - w0Time) / dt);
mLatitude = interp(w0.getLatitude(), w1.getLatitude(), frac);
mLongitude = interp(w0.getLongitude(), w1.getLongitude(), frac);
mHasAltitude = w0.hasAltitude() && w1.hasAltitude();
if (mSupportsAltitude && mHasAltitude) {
mAltitude = interp(w0.getAltitude(), w1.getAltitude(), frac);
}
if (mSupportsBearing) {
mHasBearing = frac <= 0.5f ? w0.hasBearing() : w1.hasBearing();
if (mHasBearing) {
mBearing = frac <= 0.5f ? w0.getBearing() : w1.getBearing();
}
}
if (mSupportsSpeed) {
mHasSpeed = frac <= 0.5f ? w0.hasSpeed() : w1.hasSpeed();
if (mHasSpeed) {
mSpeed = frac <= 0.5f ? w0.getSpeed() : w1.getSpeed();
}
}
mLastTime = time;
mTime = time;
}
public void setRequiresNetwork(boolean requiresNetwork) {
mRequiresNetwork = requiresNetwork;
}
@Override public boolean requiresNetwork() {
return mRequiresNetwork;
}
public void setRequiresSatellite(boolean requiresSatellite) {
mRequiresSatellite = requiresSatellite;
}
@Override public boolean requiresSatellite() {
return mRequiresSatellite;
}
public void setRequiresCell(boolean requiresCell) {
mRequiresCell = requiresCell;
}
@Override public boolean requiresCell() {
return mRequiresCell;
}
public void setHasMonetaryCost(boolean hasMonetaryCost) {
mHasMonetaryCost = hasMonetaryCost;
}
@Override public boolean hasMonetaryCost() {
return mHasMonetaryCost;
}
public void setSupportsAltitude(boolean supportsAltitude) {
mSupportsAltitude = supportsAltitude;
}
@Override public boolean supportsAltitude() {
return mSupportsAltitude;
}
public void setSupportsSpeed(boolean supportsSpeed) {
mSupportsSpeed = supportsSpeed;
}
@Override public boolean supportsSpeed() {
return mSupportsSpeed;
}
public void setSupportsBearing(boolean supportsBearing) {
mSupportsBearing = supportsBearing;
}
@Override public boolean supportsBearing() {
return mSupportsBearing;
}
public void setRepeat(boolean repeat) {
mRepeat = repeat;
}
public void setPowerRequirement(int powerRequirement) {
if (powerRequirement < Criteria.POWER_LOW ||
powerRequirement > Criteria.POWER_HIGH) {
throw new IllegalArgumentException("powerRequirement = " +
powerRequirement);
}
mPowerRequirement = powerRequirement;
}
@Override public int getPowerRequirement() {
return mPowerRequirement;
}
public void setAccuracy(int accuracy) {
mAccuracy = accuracy;
}
@Override public int getAccuracy() {
return mAccuracy;
}
public void setTrackSpeed(float trackSpeed) {
mTrackSpeed = trackSpeed;
}
@Override public void enable() {
mEnabled = true;
}
@Override public void disable() {
mEnabled = false;
}
@Override public boolean isEnabled() {
return mEnabled;
}
@Override public int getStatus(Bundle extras) {
return AVAILABLE;
}
@Override public boolean getLocation(Location l) {
if (mEnabled) {
update();
l.setProvider(getName());
l.setTime(mTime + mBaseTime);
l.setLatitude(mLatitude);
l.setLongitude(mLongitude);
if (mSupportsAltitude && mHasAltitude) {
l.setAltitude(mAltitude);
}
if (mSupportsBearing && mHasBearing) {
l.setBearing(mBearing);
}
if (mSupportsSpeed && mHasSpeed) {
l.setSpeed(mSpeed);
}
if (mExtras != null) {
l.setExtras(mExtras);
}
return true;
} else {
return false;
}
}
public Location getInitialLocation() {
return mInitialLocation;
}
}
/**
* A simple tuple of (time stamp, latitude, longitude, altitude), plus optional
* extras.
*
* {@hide}
*/
class Waypoint {
public Location mLocation;
public Waypoint(Location location) {
mLocation = location;
}
public Waypoint(String providerName, long time, double latitude, double longitude,
double altitude) {
mLocation = new Location(providerName);
mLocation.setTime(time);
mLocation.setLatitude(latitude);
mLocation.setLongitude(longitude);
mLocation.setAltitude(altitude);
}
public long getTime() {
return mLocation.getTime();
}
public double getLatitude() {
return mLocation.getLatitude();
}
public double getLongitude() {
return mLocation.getLongitude();
}
public boolean hasAltitude() {
return mLocation.hasAltitude();
}
public double getAltitude() {
return mLocation.getAltitude();
}
public boolean hasBearing() {
return mLocation.hasBearing();
}
public void setBearing(float bearing) {
mLocation.setBearing(bearing);
}
public float getBearing() {
return mLocation.getBearing();
}
public boolean hasSpeed() {
return mLocation.hasSpeed();
}
public void setSpeed(float speed) {
mLocation.setSpeed(speed);
}
public float getSpeed() {
return mLocation.getSpeed();
}
public Bundle getExtras() {
return mLocation.getExtras();
}
public Location getLocation() {
return new Location(mLocation);
}
@Override public String toString() {
return "Waypoint[mLocation=" + mLocation + "]";
}
}
|
