forked from upstream-mirrors/OpenTracks
Matthew Simmons
690 lines
25 KiB
Java
690 lines
25 KiB
Java
/*
|
|
* Copyright 2008 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
|
* the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*/
|
|
package com.google.android.apps.mytracks.io;
|
|
|
|
import com.google.android.apps.mymaps.MyMapsFeature;
|
|
import com.google.android.apps.mymaps.MyMapsGDataConverter;
|
|
import com.google.android.apps.mymaps.MyMapsGDataWrapper;
|
|
import com.google.android.apps.mymaps.MyMapsGDataWrapper.QueryFunction;
|
|
import com.google.android.apps.mymaps.MyMapsMapMetadata;
|
|
import com.google.android.apps.mytracks.MyTracksConstants;
|
|
import com.google.android.apps.mytracks.MyTracksSettings;
|
|
import com.google.android.apps.mytracks.ProgressIndicator;
|
|
import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
|
|
import com.google.android.apps.mytracks.content.Track;
|
|
import com.google.android.apps.mytracks.content.Waypoint;
|
|
import com.google.android.apps.mytracks.stats.DoubleBuffer;
|
|
import com.google.android.apps.mytracks.stats.TripStatistics;
|
|
import com.google.android.apps.mytracks.util.MyTracksUtils;
|
|
import com.google.android.apps.mytracks.util.StringUtils;
|
|
import com.google.android.apps.mytracks.util.UnitConversions;
|
|
import com.google.android.maps.mytracks.R;
|
|
import com.google.wireless.gdata.client.HttpException;
|
|
import com.google.wireless.gdata.data.Entry;
|
|
import com.google.wireless.gdata.maps.MapsClient;
|
|
import com.google.wireless.gdata.parser.ParseException;
|
|
import com.google.wireless.gdata2.client.AuthenticationException;
|
|
|
|
import android.app.Activity;
|
|
import android.content.Context;
|
|
import android.content.SharedPreferences;
|
|
import android.database.Cursor;
|
|
import android.location.Location;
|
|
import android.util.Log;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Vector;
|
|
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
/**
|
|
* A helper class used to transmit tracks to Google MyMaps.
|
|
* A new instance should be used for each upload.
|
|
*
|
|
* @author Leif Hendrik Wilden
|
|
*/
|
|
public class SendToMyMaps implements Runnable {
|
|
|
|
public static final String NEW_MAP_ID = "new";
|
|
private static final String END_ICON_URL =
|
|
"http://maps.google.com/mapfiles/ms/micons/red-dot.png";
|
|
private static final String START_ICON_URL =
|
|
"http://maps.google.com/mapfiles/ms/micons/green-dot.png";
|
|
private static final int MAX_POINTS_PER_UPLOAD = 2048;
|
|
|
|
private final Activity context;
|
|
private final AuthManager auth;
|
|
private final long trackId;
|
|
private final ProgressIndicator progressIndicator;
|
|
private final OnSendCompletedListener onCompletion;
|
|
private final StringUtils stringUtils;
|
|
private final MyTracksProviderUtils providerUtils;
|
|
private String mapId;
|
|
|
|
// GData service
|
|
private MyMapsGDataWrapper wrapper;
|
|
private MyMapsGDataConverter gdataConverter;
|
|
|
|
// Progress status
|
|
private int totalLocationsRead;
|
|
private int totalLocationsPrepared;
|
|
private int totalLocationsUploaded;
|
|
private int totalLocations;
|
|
private int totalSegmentsUploaded;
|
|
|
|
public interface OnSendCompletedListener {
|
|
void onSendCompleted(String mapId, boolean success, int statusMessage);
|
|
}
|
|
|
|
public SendToMyMaps(Activity context, String mapId, AuthManager auth,
|
|
long trackId, ProgressIndicator progressIndicator,
|
|
OnSendCompletedListener onCompletion) {
|
|
this.context = context;
|
|
this.mapId = mapId;
|
|
this.auth = auth;
|
|
this.trackId = trackId;
|
|
this.progressIndicator = progressIndicator;
|
|
this.onCompletion = onCompletion;
|
|
this.stringUtils = new StringUtils(context);
|
|
this.providerUtils = MyTracksProviderUtils.Factory.get(context);
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
Log.d(MyTracksConstants.TAG, "Sending to MyMaps: trackId = " + trackId);
|
|
doUpload();
|
|
}
|
|
|
|
private void doUpload() {
|
|
int statusMessageId = R.string.error_sending_to_mymap;
|
|
boolean success = true;
|
|
try {
|
|
gdataConverter = new MyMapsGDataConverter();
|
|
|
|
progressIndicator.setProgressValue(1);
|
|
progressIndicator.setProgressMessage(
|
|
R.string.progress_message_reading_track);
|
|
|
|
// Get the track meta-data
|
|
Track track = providerUtils.getTrack(trackId);
|
|
String originalDescription = track.getDescription();
|
|
track.setDescription("<p>" + track.getDescription() + "</p><p>"
|
|
+ stringUtils.generateTrackDescription(track, null, null) + "</p>");
|
|
wrapper = new MyMapsGDataWrapper(context);
|
|
wrapper.setAuthManager(auth);
|
|
wrapper.setRetryOnAuthFailure(true);
|
|
|
|
// Create a new map if necessary:
|
|
boolean isNewMap = mapId.equals(NEW_MAP_ID);
|
|
if (isNewMap) {
|
|
success = createNewMap(track, originalDescription);
|
|
}
|
|
|
|
// Upload all of the segments of the track plus start/end markers
|
|
if (success) {
|
|
success = uploadAllTrackPoints(track, originalDescription);
|
|
}
|
|
|
|
// Put waypoints.
|
|
if (success) {
|
|
success = uploadWaypoints(track);
|
|
if (!success) {
|
|
Log.w(MyTracksConstants.TAG,
|
|
"SendToMyMaps: upload waypoints failed.");
|
|
}
|
|
}
|
|
|
|
if (success) {
|
|
statusMessageId = isNewMap
|
|
? R.string.status_new_mymap_has_been_created
|
|
: R.string.status_tracks_have_been_uploaded;
|
|
}
|
|
Log.d(MyTracksConstants.TAG, "SendToMyMaps: Done: " + success);
|
|
progressIndicator.setProgressValue(100);
|
|
} catch (XmlPullParserException e) {
|
|
Log.e(MyTracksConstants.TAG, "Caught an unexpected exception.", e);
|
|
} finally {
|
|
if (wrapper != null) {
|
|
wrapper.cleanUp();
|
|
}
|
|
|
|
final boolean finalSuccess = success;
|
|
final int finalStatusMessageId = statusMessageId;
|
|
context.runOnUiThread(new Runnable() {
|
|
public void run() {
|
|
if (onCompletion != null) {
|
|
onCompletion.onSendCompleted(
|
|
mapId, finalSuccess, finalStatusMessageId);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new map for the given track.
|
|
*
|
|
* @param track The track that will be uploaded to this map
|
|
* @return True on success.
|
|
*/
|
|
private boolean createNewMap(final Track track, final String description) {
|
|
progressIndicator.setProgressMessage(
|
|
R.string.progress_message_creating_map);
|
|
return wrapper.runQuery(new QueryFunction() {
|
|
@Override
|
|
public void query(MapsClient client) throws IOException, Exception {
|
|
Log.d(MyTracksConstants.TAG, "Creating a new map.");
|
|
String mapFeed = MapsClient.getMapsFeed();
|
|
Log.d(MyTracksConstants.TAG, "Map feed is " + mapFeed);
|
|
MyMapsMapMetadata metaData = new MyMapsMapMetadata();
|
|
metaData.setTitle(track.getName());
|
|
metaData.setDescription(description + " - "
|
|
+ track.getCategory() + " - "
|
|
+ context.getString(R.string.new_map_description));
|
|
SharedPreferences preferences = context.getSharedPreferences(
|
|
MyTracksSettings.SETTINGS_NAME, 0);
|
|
boolean mapPublic = true;
|
|
if (preferences != null) {
|
|
mapPublic = preferences.getBoolean(
|
|
context.getString(R.string.default_map_public_key), true);
|
|
}
|
|
metaData.setSearchable(mapPublic);
|
|
Entry entry = MyMapsGDataConverter.getMapEntryForMetadata(metaData);
|
|
Log.d(MyTracksConstants.TAG, "Title: " + entry.getTitle());
|
|
Entry map = client.createEntry(mapFeed, auth.getAuthToken(), entry);
|
|
mapId = MapsClient.getMapIdFromMapEntryId(map.getId());
|
|
Log.d(MyTracksConstants.TAG, "New map id is: " + mapId);
|
|
}
|
|
});
|
|
}
|
|
|
|
private boolean uploadAllTrackPoints(
|
|
final Track track, String originalDescription) {
|
|
SharedPreferences preferences = context.getSharedPreferences(
|
|
MyTracksSettings.SETTINGS_NAME, 0);
|
|
boolean metricUnits = true;
|
|
if (preferences != null) {
|
|
metricUnits =
|
|
preferences.getBoolean(context.getString(R.string.metric_units_key),
|
|
true);
|
|
}
|
|
|
|
Cursor locationsCursor =
|
|
providerUtils.getLocationsCursor(track.getId(), 0, -1, false);
|
|
try {
|
|
if (!locationsCursor.moveToFirst()) {
|
|
Log.w(MyTracksConstants.TAG, "Unable to get any points to upload");
|
|
return false;
|
|
}
|
|
|
|
totalLocationsRead = 0;
|
|
totalLocationsPrepared = 0;
|
|
totalLocationsUploaded = 0;
|
|
totalLocations = locationsCursor.getCount();
|
|
totalSegmentsUploaded = 0;
|
|
|
|
// Limit the number of elevation readings. Ideally we would want around 250.
|
|
int elevationSamplingFrequency =
|
|
Math.max(1, (int) (totalLocations / 250.0));
|
|
Log.d(MyTracksConstants.TAG,
|
|
"Using elevation sampling factor: " + elevationSamplingFrequency
|
|
+ " on " + totalLocations);
|
|
double totalDistance = 0;
|
|
|
|
Vector<Double> distances = new Vector<Double>();
|
|
Vector<Double> elevations = new Vector<Double>();
|
|
DoubleBuffer elevationBuffer =
|
|
new DoubleBuffer(MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
|
|
|
|
List<Location> locations = new ArrayList<Location>(MAX_POINTS_PER_UPLOAD);
|
|
progressIndicator.setProgressMessage(
|
|
R.string.progress_message_reading_track);
|
|
Location lastLocation = null;
|
|
do {
|
|
if (totalLocationsRead % 100 == 0) {
|
|
updateProgress();
|
|
}
|
|
|
|
Location loc = providerUtils.createLocation(locationsCursor);
|
|
locations.add(loc);
|
|
|
|
if (totalLocationsRead == 0) {
|
|
// Put a marker at the first point of the first valid segment:
|
|
uploadMarker(track, loc, true);
|
|
}
|
|
|
|
// Add to the elevation profile.
|
|
if (loc != null && MyTracksUtils.isValidLocation(loc)) {
|
|
// All points go into the smoothing buffer...
|
|
elevationBuffer.setNext(metricUnits ? loc.getAltitude()
|
|
: loc.getAltitude() * UnitConversions.M_TO_FT);
|
|
if (lastLocation != null) {
|
|
double dist = lastLocation.distanceTo(loc);
|
|
totalDistance += dist;
|
|
}
|
|
|
|
// ...but only a few points are really used to keep the url short.
|
|
if (totalLocationsRead % elevationSamplingFrequency == 0) {
|
|
distances.add(totalDistance);
|
|
elevations.add(elevationBuffer.getAverage());
|
|
}
|
|
}
|
|
|
|
// If the location was not valid, it's a segment split, so make sure the
|
|
// distance between the previous segment and the new one is not accounted
|
|
// for in the next iteration.
|
|
lastLocation = loc;
|
|
|
|
// Every now and then, upload the accumulated points
|
|
if (totalLocationsRead % MAX_POINTS_PER_UPLOAD
|
|
== MAX_POINTS_PER_UPLOAD - 1) {
|
|
if (!prepareAndUploadPoints(track, locations)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
totalLocationsRead++;
|
|
} while (locationsCursor.moveToNext());
|
|
|
|
// Do a final upload with what's left
|
|
if (!prepareAndUploadPoints(track, locations)) {
|
|
return false;
|
|
}
|
|
|
|
// Put an end marker at the last point of the last valid segment:
|
|
if (lastLocation != null) {
|
|
track.setDescription("<p>" + originalDescription + "</p><p>"
|
|
+ stringUtils.generateTrackDescription(
|
|
track, distances, elevations)
|
|
+ "</p>");
|
|
return uploadMarker(track, lastLocation, false);
|
|
}
|
|
|
|
return true;
|
|
} finally {
|
|
locationsCursor.close();
|
|
}
|
|
}
|
|
|
|
private boolean uploadMarker(final Track track,
|
|
final Location location,
|
|
final boolean isStart) {
|
|
boolean okay = wrapper.runQuery(new QueryFunction() {
|
|
@Override
|
|
public void query(MapsClient client)
|
|
throws AuthenticationException, IOException, Exception {
|
|
String featureFeed = MapsClient.getFeaturesFeed(mapId);
|
|
insertMarker(context, client, featureFeed, track, location, isStart);
|
|
}
|
|
});
|
|
return okay;
|
|
}
|
|
|
|
/**
|
|
* Inserts a place mark. Second try if 1st try fails. Will throw exception on
|
|
* 2nd failure.
|
|
*/
|
|
private void insertMarker(Context context, MapsClient client,
|
|
String featureFeed, Track track, Location loc,
|
|
boolean isStart) throws IOException, Exception {
|
|
Entry entry = gdataConverter.getEntryForFeature(
|
|
buildMyMapsPlacemarkFeature(context, track, loc, isStart));
|
|
Log.d(MyTracksConstants.TAG, "SendToMyMaps: Creating placemark "
|
|
+ entry.getTitle());
|
|
try {
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG, "SendToMyMaps: createEntry success!");
|
|
} catch (IOException e) {
|
|
Log.w(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry 1st try failed. Trying again.");
|
|
// Retry once (often IOException is thrown on a timeout):
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry success on 2nd try!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Builds a placemark MyMapsFeature from a track.
|
|
*
|
|
* @param track the track
|
|
* @param isStart true if it's the start of the track, or false for end
|
|
* @return a MyMapsFeature
|
|
*/
|
|
private static MyMapsFeature buildMyMapsPlacemarkFeature(Context context,
|
|
Track track, Location loc, boolean isStart) {
|
|
MyMapsFeature myMapsFeature = new MyMapsFeature();
|
|
myMapsFeature.generateAndroidId();
|
|
myMapsFeature.setType(MyMapsFeature.MARKER);
|
|
if (isStart) {
|
|
myMapsFeature.setIconUrl(START_ICON_URL);
|
|
} else {
|
|
myMapsFeature.setIconUrl(END_ICON_URL);
|
|
}
|
|
myMapsFeature.addPoint(MyTracksUtils.getGeoPoint(loc));
|
|
String name = track.getName() + " "
|
|
+ (isStart ? context.getString(R.string.start)
|
|
: context.getString(R.string.end));
|
|
myMapsFeature.setTitle(name);
|
|
myMapsFeature.setDescription(isStart ? "" : track.getDescription());
|
|
return myMapsFeature;
|
|
}
|
|
|
|
private boolean prepareAndUploadPoints(Track track, List<Location> locations) {
|
|
progressIndicator.setProgressMessage(
|
|
R.string.progress_message_preparing_track);
|
|
updateProgress();
|
|
|
|
int numLocations = locations.size();
|
|
if (numLocations < 2) {
|
|
Log.d(MyTracksConstants.TAG, "Not preparing/uploading too few points");
|
|
totalLocationsUploaded += numLocations;
|
|
return true;
|
|
}
|
|
|
|
// Prepare/pre-process the points
|
|
ArrayList<Track> splitTracks = prepareLocations(track, locations);
|
|
|
|
// Start uploading them
|
|
progressIndicator.setProgressMessage(
|
|
R.string.progress_message_sending_mymaps);
|
|
for (Track splitTrack : splitTracks) {
|
|
if (totalSegmentsUploaded > 1) {
|
|
splitTrack.setName(splitTrack.getName() + " "
|
|
+ String.format(
|
|
context.getString(R.string.part), totalSegmentsUploaded));
|
|
}
|
|
totalSegmentsUploaded++;
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: Prepared feature for upload w/ "
|
|
+ splitTrack.getLocations().size() + " points.");
|
|
|
|
// Transmit tracks via GData feed:
|
|
// -------------------------------
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: Uploading to map " + mapId + " w/ auth " + auth);
|
|
if (!uploadTrackPoints(splitTrack)) {
|
|
Log.e(MyTracksConstants.TAG, "Uploading failed");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
locations.clear();
|
|
totalLocationsUploaded += numLocations;
|
|
updateProgress();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Prepares a buffer of locations for transmission to google maps.
|
|
*
|
|
* @param track the original track with meta data
|
|
* @param buffer a buffer of locations on the track
|
|
* @return an array of tracks each with a sub section of the points in the
|
|
* original buffer
|
|
*/
|
|
private ArrayList<Track> prepareLocations(
|
|
Track track, Iterable<Location> locations) {
|
|
ArrayList<Track> splitTracks = new ArrayList<Track>();
|
|
|
|
// Create segments from each full track:
|
|
Track segment = new Track();
|
|
TripStatistics segmentStats = segment.getStatistics();
|
|
TripStatistics trackStats = track.getStatistics();
|
|
segment.setId(track.getId());
|
|
segment.setName(track.getName());
|
|
segment.setDescription(/* track.getDescription() */ "");
|
|
segment.setCategory(track.getCategory());
|
|
segmentStats.setStartTime(trackStats.getStartTime());
|
|
segmentStats.setStopTime(trackStats.getStopTime());
|
|
boolean startNewTrackSegment = false;
|
|
for (Location loc : locations) {
|
|
if (totalLocationsPrepared % 100 == 0) {
|
|
updateProgress();
|
|
}
|
|
if (loc.getLatitude() > 90) {
|
|
startNewTrackSegment = true;
|
|
}
|
|
|
|
if (startNewTrackSegment) {
|
|
// Close up the last segment.
|
|
prepareTrackSegment(segment, splitTracks);
|
|
|
|
Log.d(MyTracksConstants.TAG,
|
|
"MyTracksSendToMyMaps: Starting new track segment...");
|
|
startNewTrackSegment = false;
|
|
segment = new Track();
|
|
segment.setId(track.getId());
|
|
segment.setName(track.getName());
|
|
segment.setDescription(/* track.getDescription() */ "");
|
|
segment.setCategory(track.getCategory());
|
|
}
|
|
|
|
if (loc.getLatitude() <= 90) {
|
|
segment.addLocation(loc);
|
|
if (segmentStats.getStartTime() < 0) {
|
|
segmentStats.setStartTime(loc.getTime());
|
|
}
|
|
}
|
|
totalLocationsPrepared++;
|
|
}
|
|
|
|
prepareTrackSegment(segment, splitTracks);
|
|
|
|
return splitTracks;
|
|
}
|
|
|
|
/**
|
|
* Prepares a track segment for sending to google maps.
|
|
* The main steps are:
|
|
* - correcting end time
|
|
* - decimating locations
|
|
* - splitting into smaller tracks.
|
|
*
|
|
* The final track pieces will be put in the array list splitTracks.
|
|
*
|
|
* @param segment the original segment of the track
|
|
* @param splitTracks an array of smaller track segments
|
|
*/
|
|
private void prepareTrackSegment(
|
|
Track segment, ArrayList<Track> splitTracks) {
|
|
TripStatistics segmentStats = segment.getStatistics();
|
|
if (segmentStats.getStopTime() < 0
|
|
&& segment.getLocations().size() > 0) {
|
|
segmentStats.setStopTime(segment.getLocations().size() - 1);
|
|
}
|
|
|
|
/*
|
|
* Decimate to 2 meter precision. Mapshop doesn't like too many
|
|
* points:
|
|
*/
|
|
MyTracksUtils.decimate(segment, 2.0);
|
|
|
|
/* It the track still has > 500 points, split it in pieces: */
|
|
if (segment.getLocations().size() > 500) {
|
|
splitTracks.addAll(MyTracksUtils.split(segment, 500));
|
|
} else if (segment.getLocations().size() >= 2) {
|
|
splitTracks.add(segment);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uploads a given list of tracks to Google MyMaps using the maps GData feed.
|
|
*/
|
|
private boolean uploadTrackPoints(final Track track) {
|
|
return wrapper.runQuery(new QueryFunction() {
|
|
@Override
|
|
public void query(MapsClient client)
|
|
throws AuthenticationException, IOException, Exception {
|
|
String featureFeed = MapsClient.getFeaturesFeed(mapId);
|
|
Log.d(MyTracksConstants.TAG, "Feature feed url: " + featureFeed);
|
|
uploadTrackPoints(track, client, featureFeed);
|
|
}
|
|
});
|
|
}
|
|
|
|
private boolean uploadTrackPoints(Track splitTrack,
|
|
MapsClient client,
|
|
String featureFeed)
|
|
throws IOException, Exception {
|
|
Entry entry = null;
|
|
int numLocations = splitTrack.getLocations().size();
|
|
if (numLocations < 2) {
|
|
// Need at least two points for a polyline:
|
|
Log.w(MyTracksConstants.TAG, "Not uploading too few points");
|
|
return true;
|
|
}
|
|
|
|
// Put the line:
|
|
entry = gdataConverter.getEntryForFeature(
|
|
buildMyMapsLineFeature(splitTrack));
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: Creating line " + entry.getTitle());
|
|
try {
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG, "SendToMyMaps: createEntry success!");
|
|
} catch (IOException e) {
|
|
Log.w(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry 1st try failed. Trying again.");
|
|
// Retry once (often IOException is thrown on a timeout):
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry success on 2nd try!");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Builds a MyMapsFeature from a track.
|
|
*
|
|
* @param track the track
|
|
* @return a MyMapsFeature
|
|
*/
|
|
private static MyMapsFeature buildMyMapsLineFeature(Track track) {
|
|
MyMapsFeature myMapsFeature = new MyMapsFeature();
|
|
myMapsFeature.generateAndroidId();
|
|
myMapsFeature.setType(MyMapsFeature.LINE);
|
|
if (track.getName().length() < 1) {
|
|
// Features must have a name (otherwise GData upload may fail):
|
|
myMapsFeature.setTitle("-");
|
|
} else {
|
|
myMapsFeature.setTitle(track.getName());
|
|
}
|
|
myMapsFeature.setColor(0x80FF0000);
|
|
for (Location loc : track.getLocations()) {
|
|
myMapsFeature.addPoint(MyTracksUtils.getGeoPoint(loc));
|
|
}
|
|
return myMapsFeature;
|
|
}
|
|
|
|
/**
|
|
* Uploads all of the waypoints associated with this track to map.
|
|
*
|
|
* @param track The track to upload waypoints for.
|
|
*
|
|
* @return True on success.
|
|
*/
|
|
private boolean uploadWaypoints(final Track track) {
|
|
return wrapper.runQuery(new QueryFunction() {
|
|
public void query(MapsClient client) {
|
|
// TODO: Stream through he waypoints in chunks.
|
|
// I am leaving the number of waypoints very high which should not be a
|
|
// problem because we don't try to load them into objects all at the
|
|
// same time.
|
|
Cursor c = null;
|
|
c = providerUtils.getWaypointsCursor(
|
|
track.getId(), 0,
|
|
MyTracksConstants.MAX_LOADED_WAYPOINTS_POINTS);
|
|
String featureFeed = MapsClient.getFeaturesFeed(mapId);
|
|
if (c != null) {
|
|
try {
|
|
if (c.moveToFirst()) {
|
|
// This will skip the 1st waypoint (it carries the stats for the
|
|
// last segment).
|
|
while (c.moveToNext()) {
|
|
Waypoint wpt = providerUtils.createWaypoint(c);
|
|
Entry entry = gdataConverter.getEntryForFeature(
|
|
buildMyMapsPlacemarkFeature(wpt));
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: Creating waypoint.");
|
|
try {
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry success!");
|
|
} catch (IOException e) {
|
|
Log.w(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry 1st try failed. Retrying.");
|
|
|
|
// Retry once (often IOException is thrown on a timeout):
|
|
client.createEntry(featureFeed, auth.getAuthToken(), entry);
|
|
Log.d(MyTracksConstants.TAG,
|
|
"SendToMyMaps: createEntry success on 2nd try!");
|
|
}
|
|
}
|
|
}
|
|
} catch (ParseException e) {
|
|
Log.w(MyTracksConstants.TAG, "ParseException caught.", e);
|
|
} catch (HttpException e) {
|
|
Log.w(MyTracksConstants.TAG, "HttpException caught.", e);
|
|
} catch (IOException e) {
|
|
Log.w(MyTracksConstants.TAG, "IOException caught.", e);
|
|
} finally {
|
|
c.close();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Builds a MyMapsFeature from a track.
|
|
*
|
|
* @param wpt the waypoint
|
|
* @return a MyMapsFeature
|
|
*/
|
|
private static MyMapsFeature buildMyMapsPlacemarkFeature(Waypoint wpt) {
|
|
MyMapsFeature myMapsFeature = new MyMapsFeature();
|
|
myMapsFeature.generateAndroidId();
|
|
myMapsFeature.setType(MyMapsFeature.MARKER);
|
|
myMapsFeature.setIconUrl(wpt.getIcon());
|
|
myMapsFeature.setDescription(wpt.getDescription());
|
|
myMapsFeature.addPoint(MyTracksUtils.getGeoPoint(wpt.getLocation()));
|
|
if (wpt.getName().length() < 1) {
|
|
// Features must have a name (otherwise GData upload may fail):
|
|
myMapsFeature.setTitle("-");
|
|
} else {
|
|
myMapsFeature.setTitle(wpt.getName());
|
|
}
|
|
myMapsFeature.setDescription(wpt.getDescription().replaceAll("\n", "<br>"));
|
|
return myMapsFeature;
|
|
}
|
|
|
|
/**
|
|
* Sets the current upload progress.
|
|
*/
|
|
private void updateProgress() {
|
|
// The percent of the total that represents the completed part of this
|
|
// segment.
|
|
int totalPercentage =
|
|
(totalLocationsRead + totalLocationsPrepared + totalLocationsUploaded)
|
|
/ (totalLocations * 3);
|
|
totalPercentage = Math.min(99, totalPercentage);
|
|
progressIndicator.setProgressValue(totalPercentage);
|
|
}
|
|
}
|