Refactoring API level detection.

MyTracks/src/com/google/android/apps/mytracks/io/SendToMyMaps.java

@@ -0,0 +1,698 @@
+/*
+ * 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.TrackBuffer;
+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.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Vector;
+
+/**
+ * A helper class used to transmit tracks to Google MyMaps.
+ *
+ * @author Leif Hendrik Wilden
+ */
+public class SendToMyMaps {
+
+  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 final Activity context;
+  private final AuthManager auth;
+  private final long trackId;
+  private final ProgressIndicator progressIndicator;
+  private final StringUtils stringUtils;
+  private final MyTracksProviderUtils providerUtils;
+  private String mapId;
+
+  private String statusMessage = "";
+  private boolean success = true;
+  private Runnable onCompletion;
+
+  private HandlerThread handlerThread;
+  private Handler handler;
+
+  private String originalDescription;
+
+  private MyMapsGDataWrapper wrapper;
+  private MyMapsGDataConverter gdataConverter;
+
+  private Location last = null;
+
+  private Vector<Double> distances;
+  private Vector<Double> elevations;
+  private DoubleBuffer elevationBuffer;
+
+  /**
+   * 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,
+                                            TrackBuffer buffer) {
+    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 (int i = 0; i < buffer.getLocationsLoaded(); ++i) {
+      Location loc = buffer.get(i);
+      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());
+        }
+      }
+    }
+
+    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);
+    }
+  }
+
+  /**
+   * 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!");
+    }
+  }
+
+  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;
+  }
+
+  /**
+   * Sets the current upload progress.
+   *
+   * @param track The track being uploaded
+   * @param totalLocationsRead The total number of locations already read and
+   *        uploaded
+   * @param segmentSize The percent of total that each segment corresponds to
+   * @param progressInSegment The approximate progress in this segment
+   */
+  private void setProgress(final Track track, int totalLocationsRead,
+                           double segmentSize, double progressInSegment) {
+    long totalLocations = track.getStopId() - track.getStartId();
+
+    // The percent of the total that represents the completed part of this
+    // segment.
+    double percentSegmentInTotal = (segmentSize * progressInSegment);
+
+    int progress = (int) ((100.0 * totalLocationsRead / totalLocations)
+        + percentSegmentInTotal);
+    progress = Math.min(99, progress);
+    progressIndicator.setProgressValue(progress);
+  }
+
+  private boolean uploadAllTrackPoints(final Track track) {
+    int totalLocationsRead = 0;
+    // TODO: This might not actually be accurate.
+    long totalLocations = track.getStopId() - track.getStartId();
+
+    // 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;
+    Location lastLocation = null;
+
+    TrackBuffer buffer = new TrackBuffer((int) Math.min(2048, totalLocations));
+    int part = 1;
+
+    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);
+    }
+
+    // For the progress monitor:
+    // For each track segment 33% = read, 33% = prep & 33% = upload
+    // Note: These numbers are very rough.
+
+    // The size of each segment in the 100% progress
+    double segmentSize = buffer.getSize() * 100.0 / totalLocations;
+    while (success && buffer.getLastLocationRead() < track.getStopId()) {
+      setProgress(track, totalLocationsRead, segmentSize, 0.0);
+      progressIndicator.setProgressMessage(
+          context.getString(R.string.progress_message_reading_track));
+
+      providerUtils.getTrackPoints(track, buffer);
+      if (buffer.getLocationsLoaded() <= 0) {
+         continue;
+      }
+      if (totalLocationsRead == 0) {
+        // Put a marker at the first point of the first valid segment:
+        uploadMarker(track, buffer.get(0), true);
+      }
+      last = buffer.get(buffer.getLocationsLoaded() - 1);
+
+      // Extract the elevation profile.
+      for (int i = 0; i < buffer.getLocationsLoaded(); i++) {
+        // Add all points to the smoothing buffer.
+        Location l = buffer.get(i);
+        if (l != null && MyTracksUtils.isValidLocation(l)) {
+          elevationBuffer.setNext(metricUnits ? l.getAltitude()
+              : l.getAltitude() * UnitConversions.M_TO_FT);
+          if (lastLocation != null) {
+            double dist = lastLocation.distanceTo(l);
+            totalDistance += dist;
+          }
+          lastLocation = l;
+
+          // Only add some data points to keep the url short.
+          if (i % elevationSamplingFrequency == 0) {
+            distances.add(totalDistance);
+            elevations.add(elevationBuffer.getAverage());
+          }
+        }
+      }
+
+      setProgress(track, totalLocationsRead, segmentSize, 0.3333);
+      progressIndicator.setProgressMessage(
+          context.getString(R.string.progress_message_preparing_track));
+
+      ArrayList<Track> splitTracks = prepareLocations(track, buffer);
+
+      int i = 0;
+      for (Track t : splitTracks) {
+        if (part > 1) {
+          t.setName(t.getName() + " "
+              + String.format(context.getString(R.string.part), part));
+        }
+        part++;
+        Log.d(MyTracksConstants.TAG,
+            "SendToMyMaps: Prepared feature for upload w/ "
+            + t.getLocations().size() + " points.");
+
+        //
+        // Transmit tracks via GData feed:
+        // -------------------------------
+        Log.d(MyTracksConstants.TAG,
+              "SendToMyMaps: Uploading to map " + mapId + " w/ auth " + auth);
+        if (!uploadTrackPoints(track, t,
+                               totalLocationsRead, segmentSize)) {
+          success = false;
+          return false;
+        }
+        i++;
+      }
+      totalLocationsRead += buffer.getLocationsLoaded();
+    }
+
+    return true;
+  }
+
+  /**
+   * Uploads a given list of tracks to Google MyMaps using the maps GData feed.
+   *
+   * @param track the track meta-data is used for the map name
+   */
+  private boolean uploadTrackPoints(final Track track, final Track currentTrack,
+      int totalLocationsRead, double segmentSize) {
+    setProgress(track, totalLocationsRead, segmentSize, 0.6666);
+    progressIndicator.setProgressMessage(
+        context.getString(R.string.progress_message_sending_mymaps));
+    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, currentTrack, client, featureFeed);
+      }
+    });
+  }
+
+  /**
+   * 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) {
+    progressIndicator.setProgressMessage(context
+        .getString(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(originalDescription + " - "
+            + 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 uploadTrackPoints(final Track track,
+                                    Track splitTrack,
+                                    MapsClient client,
+                                    String featureFeed)
+      throws IOException, Exception  {
+    Entry entry = null;
+    if (splitTrack.getId() != track.getId()
+        || splitTrack.getLocations().size() < 2) {
+      // Need at least two points for a polyline:
+      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;
+  }
+
+  /**
+   * 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();
+          }
+        }
+      }
+    });
+  }
+
+  public SendToMyMaps(Activity context, String mapId, AuthManager auth,
+      long trackId, ProgressIndicator progressIndicator) {
+    this.context = context;
+    this.mapId = mapId;
+    this.auth = auth;
+    this.trackId = trackId;
+    this.progressIndicator = progressIndicator;
+    this.stringUtils = new StringUtils(context);
+    this.providerUtils = MyTracksProviderUtils.Factory.get(context);
+
+    Log.d(MyTracksConstants.TAG, "Sending to MyMap: trackId = " + trackId);
+    handlerThread = new HandlerThread("SendToMyMaps");
+    handlerThread.start();
+    handler = new Handler(handlerThread.getLooper());
+  }
+
+  public void run() {
+    handler.post(new Runnable() {
+      @Override
+      public void run() {
+        doUpload();
+      }
+    });
+  }
+
+  public void setOnCompletion(Runnable onCompletion) {
+    this.onCompletion = onCompletion;
+  }
+
+  public String getMapId() {
+    return mapId;
+  }
+
+  public boolean wasSuccess() {
+    return success;
+  }
+
+  public String getStatusMessage() {
+    return statusMessage;
+  }
+
+  private void doUpload() {
+    statusMessage = context.getString(R.string.error_sending_to_mymap);
+    success = true;
+    try {
+      gdataConverter = new MyMapsGDataConverter();
+
+      progressIndicator.setProgressValue(1);
+      progressIndicator.setProgressMessage(
+          context.getString(R.string.progress_message_reading_track));
+
+      // Get the track meta-data
+      Track track = providerUtils.getTrack(trackId);
+      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);
+
+      distances = new Vector<Double>();
+      elevations = new Vector<Double>();
+      elevationBuffer =
+          new DoubleBuffer(MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+
+      // Create a new map if necessary:
+      if (mapId.equals("new")) {
+        if (!createNewMap(track)) {
+          success = false;
+        }
+      }
+
+      // Upload all of the segments of the track.
+      if (success) {
+        if (!uploadAllTrackPoints(track)) {
+          success = false;
+        }
+      }
+
+      // Start end end markers.
+      if (success) {
+      // Put an end marker at the last point of the last valid segment:
+        if (last != null) {
+          track.setDescription("<p>" + originalDescription + "</p><p>"
+              + stringUtils.generateTrackDescription(
+                  track, distances, elevations)
+              + "</p>");
+          if (!uploadMarker(track, last, false)) {
+            success = false;
+          }
+        }
+      }
+
+      // Put waypoints.
+      if (success) {
+        if (!uploadWaypoints(track)) {
+          Log.w(MyTracksConstants.TAG,
+              "SendToMyMaps: upload waypoints failed.");
+          success = false;
+        }
+      }
+
+      if (success) {
+        if (mapId.equals("new")) {
+          statusMessage =
+              context.getString(R.string.status_new_mymap_has_been_created);
+        } else {
+          statusMessage =
+              context.getString(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();
+      }
+
+      context.runOnUiThread(new Runnable() {
+        public void run() {
+          if (onCompletion != null) {
+            onCompletion.run();
+          }
+        }
+      });
+    }
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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;
+  }
+}