@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {
super.draw(canvas, mapView, shadow);
Projection projection = mapView.getProjection();
int latSpan = mapView.getLatitudeSpan();
int lngSpan = mapView.getLongitudeSpan();
GeoPoint mapCenter = mapView.getMapCenter();
int mapLeftGeo = mapCenter.getLongitudeE6() - (lngSpan / 2);
int mapRightGeo = mapCenter.getLongitudeE6() + (lngSpan / 2);
int mapTopGeo = mapCenter.getLatitudeE6() - (latSpan / 2);
int mapBottomGeo = mapCenter.getLatitudeE6() + (latSpan / 2);
GeoPoint geoPoint = this.getSampleLocation();
if ((geoPoint.getLatitudeE6() > mapTopGeo && geoPoint.getLatitudeE6() < mapBottomGeo)
&& (geoPoint.getLongitudeE6() > mapLeftGeo && geoPoint.getLongitudeE6() < mapRightGeo)) {
Point myPoint = new Point();
projection.toPixels(geoPoint, myPoint);
Bitmap marker =
BitmapFactory.decodeResource(mapView.getContext().getResources(), R.drawable.markerblue);
canvas.drawBitmap(marker, myPoint.x - 15, myPoint.y - 30, null);
}
}
public void calculateNewPathIfNeeded(MapView mv) {
if (m_legs.isEmpty()) return;
boolean shouldCalculate = false;
GeoPoint ctr = mv.getMapCenter();
// If we don't yet have a path, that obviously means we need to calculate, and
// we should also cache the view limits for next time
if (m_path == null) {
shouldCalculate = true;
} else {
// We already have a path, which means we must have cached values
// If we've simply moved a bit without changing the zoom level, and have
// stayed on-screen, just shift pixels.
int lat = ctr.getLatitudeE6();
int lng = ctr.getLongitudeE6();
if (lat < m_lat1
|| lat > m_lat2
|| lng < m_lng1
|| lng > m_lng2
|| mv.getLongitudeSpan() != (m_lng2 - m_lng1)) {
shouldCalculate = true;
}
}
if (shouldCalculate) {
// Okay, we need to calculate a new path. We'll make a path big enough to cover 9 screens.
// (One each to the North, NE, E, SE, S, SW, W, and NW, and of course the real screen)
// This allows us to wander all around the original screen all we want without having to
// recalculate
m_path = new Path();
// So, lets set our 'area of interest'...
m_lat = ctr.getLatitudeE6();
m_lng = ctr.getLongitudeE6();
int latSpan = mv.getLatitudeSpan();
int lngSpan = mv.getLongitudeSpan();
m_lat1 = m_lat - 2 * latSpan / 3;
m_lat2 = m_lat + 2 * latSpan / 3;
m_lng1 = m_lng - 2 * lngSpan / 3;
m_lng2 = m_lng + 2 * lngSpan / 3;
// Each tip may have one or more legs. Try to draw them all
for (TripLeg leg : m_legs) {
// We can be more efficient here by short-circuiting and not considering
// legs that aren't even partially on-screen
// Iterate over each point in the leg, and figure out if we need to add it
// to the drawn path. The analogy here is a pen.
boolean drewLastPoint = false;
for (int i = 0; i < leg.size(); i++) {
GeoPoint gp = leg.elementAt(i);
int lat = gp.getLatitudeE6();
int lng = gp.getLongitudeE6();
Point thisPoint = new Point();
Point otherPoint = new Point();
if (lat >= m_lat1 && lat <= m_lat2 && lng >= m_lng1 && lng <= m_lng2) {
// This point is in area of interest. We will need to do some drawing
mv.getProjection().toPixels(gp, thisPoint);
if (drewLastPoint) {
// Last point was also in area of interest...
// The pen is on the paper. Draw to the current point.
m_path.lineTo(thisPoint.x, thisPoint.y);
} else if (i != 0) {
// The last point was out of the area of intersest.
// Pick up the pen and put it there, then draw to the current point.
mv.getProjection().toPixels(leg.elementAt(i - 1), otherPoint);
m_path.moveTo(otherPoint.x, otherPoint.y);
m_path.lineTo(thisPoint.x, thisPoint.y);
} else {
// This is the first point in the leg.
// Pick up the pen and position it at this point.
m_path.moveTo(thisPoint.x, thisPoint.y);
}
drewLastPoint = true;
} else {
// This point is not in the area of interest...
if (drewLastPoint) {
// ... but the last point was. Draw to this point to finish the path
mv.getProjection().toPixels(gp, thisPoint);
m_path.lineTo(thisPoint.x, thisPoint.y);
} else {
// Neither is in the area of interest. But, their connecting line
// might CROSS the area of interest
if (i != 0) {
GeoPoint lastgeo = leg.elementAt(i - 1);
Point previous = new Point(lastgeo.getLongitudeE6(), lastgeo.getLatitudeE6());
Point current = new Point(lng, lat);
if (Utils.doExteriorPointsCutRect(
previous, current,
m_lng1, m_lat1,
m_lng2, m_lat2)) {
mv.getProjection().toPixels(gp, thisPoint);
mv.getProjection().toPixels(lastgeo, otherPoint);
m_path.moveTo(otherPoint.x, otherPoint.y);
m_path.lineTo(thisPoint.x, thisPoint.y);
}
}
}
drewLastPoint = false;
}
}
}
} else {
// Here, we don't need to calculate a whole new path, but we might need to move the existing
// one a bit
Point lastPoint = new Point();
Point thisPoint = new Point();
mv.getProjection().toPixels(new GeoPoint(m_lat, m_lng), lastPoint);
mv.getProjection().toPixels(ctr, thisPoint);
float dx = lastPoint.x - thisPoint.x;
float dy = lastPoint.y - thisPoint.y;
if (dx != 0.0 || dy != 0.0) {
m_path.offset(dx, dy);
}
m_lat = ctr.getLatitudeE6();
m_lng = ctr.getLongitudeE6();
}
}
@Override
public int getLongitudeSpan() {
return mMapView.getLongitudeSpan();
}