Issue 45: Add ImportAllTracks to import GPX files from /sdcard/MyTracks/gpx

ImportAllTracks is essentially just a modification of ExportAllTracks that
uses the existing GpxImporter to import all GPX files found in
/sdcard/MyTracks/gpx. So that the import functionality can always be accessed,
the MyTracks Activity's MenuManager is altered so that the Tracks button shows
regardless of whether there are any tracks in the database (ImportAllTracks is
launched by a button in the lower right of the MyTracksList activity).

A Toast message shows if no GPX files are found; this serves as a hint to
users on where to put GPX files for import so that this addition should be
discoverable and useable without documentation.

Im

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010 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 android.content.Intent;
+
+/**
+ * This interface describes a class that will fetch and maintain a Google
+ * authentication token.
+ * 
+ * @author Sandor Dornbush
+ */
+public interface AuthManager {
+
+  /**
+   * Initializes the login process. The user should be asked to login if they
+   * haven't already. The {@link Runnable} provided will be executed when the
+   * auth token is successfully fetched.
+   *
+   * @param whenFinished A {@link Runnable} to execute when the auth token
+   *        has been successfully fetched and is available via
+   *        {@link #getAuthToken()}
+   */
+  public abstract void doLogin(Runnable whenFinished, Object o);
+
+  /**
+   * The {@link android.app.Activity} owner of this class should call this
+   * function when it gets {@link android.app.Activity#onActivityResult} with
+   * the request code passed into the constructor. The resultCode and results
+   * should come directly from the {@link android.app.Activity#onActivityResult}
+   * function. This function will return true if an auth token was successfully
+   *  fetched or the process is not finished.
+   *
+   * @param resultCode The result code passed in to the
+   *        {@link android.app.Activity}'s
+   *        {@link android.app.Activity#onActivityResult} function
+   * @param results The data passed in to the {@link android.app.Activity}'s
+   *        {@link android.app.Activity#onActivityResult} function
+   * @return True if the auth token was fetched or we aren't done fetching
+   *         the auth token, or False if there was an error or the request was
+   *         canceled
+   */
+  public abstract boolean authResult(int resultCode, Intent results);
+
+  /**
+   * Returns the current auth token. Response may be null if no valid auth
+   * token has been fetched.
+   *
+   * @return The current auth token or null if no auth token has been
+   *         fetched
+   */
+  public abstract String getAuthToken();
+
+  /**
+   * Invalidates the existing auth token and request a new one. The
+   * {@link Runnable} provided will be executed when the new auth token is
+   * successfully fetched.
+   *
+   * @param whenFinished A {@link Runnable} to execute when a new auth token
+   *        is successfully fetched
+   */
+  public abstract void invalidateAndRefresh(Runnable whenFinished);
+
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010 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.mytracks.MyTracksConstants;
+
+import android.app.Activity;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+
+/**
+ * A factory for getting the platform specific AuthManager.
+ * 
+ * @author Sandor Dornbush
+ */
+public class AuthManagerFactory {
+
+  private AuthManagerFactory() {
+  }
+
+  /**
+   * Returns whether the modern AuthManager should be used
+   */
+  public static boolean useModernAuthManager() {
+    return Integer.parseInt(Build.VERSION.SDK) >= 7;
+  }
+
+  /**
+   * Get a right {@link AuthManager} for the platform.
+   * @return A new AuthManager
+   */
+  public static AuthManager getAuthManager(Activity activity, int code,
+      Bundle extras, boolean requireGoogle, String service) {
+    if (useModernAuthManager()) {
+      Log.i(MyTracksConstants.TAG,
+          "Creating modern auth manager: " + service);
+      return new ModernAuthManager(activity, code, extras, requireGoogle, service);
+    } else {
+      Log.i(MyTracksConstants.TAG,
+          "Creating legacy auth manager: " + service);
+      return new AuthManagerOld(activity, code, extras, requireGoogle, service);
+    }
+  }
+
+}

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

@@ -0,0 +1,198 @@
+/*
+ * Copyright 2009 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.googlelogindist.GoogleLoginServiceConstants;
+import com.google.android.googlelogindist.GoogleLoginServiceHelper;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+
+import java.util.Iterator;
+import java.util.Vector;
+
+/**
+ * AuthManager keeps track of the current auth token for a user. The advantage
+ * over just passing around a String is that this class can renew the auth
+ * token if necessary, and it will change for all classes using this
+ * AuthManager.
+ */
+public class AuthManagerOld implements AuthManager {
+  /** The activity that will handle auth result callbacks. */
+  private final Activity activity;
+
+  /** The code used to tell the activity that it is an auth result. */
+  private final int code;
+
+  /** Extras to pass into the getCredentials function. */
+  private final Bundle extras;
+
+  /** True if the account must be a Google account (not a domain account). */
+  private final boolean requireGoogle;
+
+  /** The name of the service to authorize for. */
+  private final String service;
+
+  /** A list of handlers to call when a new auth token is fetched. */
+  private final Vector<Runnable> newTokenListeners = new Vector<Runnable>();
+
+  /** The most recently fetched auth token or null if none is available. */
+  private String authToken;
+
+  /**
+   * The number of handlers at the beginning of the above list that shouldn't
+   * be removed after they are called.
+   */
+  private int stickyNewTokenListenerCount;
+
+  /**
+   * AuthManager requires many of the same parameters as
+   * {@link GoogleLoginServiceHelper#getCredentials(Activity, int, Bundle,
+   * boolean, String, boolean)}. The activity must have
+   * a handler in {@link Activity#onActivityResult} that calls
+   * {@link #authResult(int, Intent)} if the request code is the code given
+   * here.
+   *
+   * @param activity An activity with a handler in
+   *        {@link Activity#onActivityResult} that calls
+   *        {@link #authResult(int, Intent)} when {@literal code} is the request
+   *        code
+   * @param code The request code to pass to
+   *        {@link Activity#onActivityResult} when
+   *        {@link #authResult(int, Intent)} should be called
+   * @param extras A {@link Bundle} of extras for
+   *        {@link GoogleLoginServiceHelper}
+   * @param requireGoogle True if the account must be a Google account
+   * @param service The name of the service to authenticate as
+   */
+  public AuthManagerOld(Activity activity, int code, Bundle extras,
+      boolean requireGoogle, String service) {
+    this.activity = activity;
+    this.code = code;
+    this.extras = extras;
+    this.requireGoogle = requireGoogle;
+    this.service = service;
+  }
+
+  /* (non-Javadoc)
+   * @see com.google.android.apps.mytracks.io.AuthManager#doLogin(java.lang.Runnable)
+   */
+  public void doLogin(Runnable whenFinished, Object o) {
+    synchronized (newTokenListeners) {
+      if (whenFinished != null) {
+        newTokenListeners.add(whenFinished);
+      }
+    }
+    activity.runOnUiThread(new LoginRunnable());
+  }
+
+  /**
+   * Runnable which actually gets login credentials.
+   */
+  private class LoginRunnable implements Runnable {
+    @Override
+    public void run() {
+      GoogleLoginServiceHelper.getCredentials(
+          activity, code, extras, requireGoogle, service, true);
+    }
+  }
+
+  /* (non-Javadoc)
+   * @see com.google.android.apps.mytracks.io.AuthManager#authResult(int, android.content.Intent)
+   */
+  public boolean authResult(int resultCode, Intent results) {
+    if (resultCode == Activity.RESULT_OK) {
+      authToken = results.getStringExtra(
+          GoogleLoginServiceConstants.AUTHTOKEN_KEY);
+      if (authToken == null) {
+        GoogleLoginServiceHelper.getCredentials(
+            activity, code, extras, requireGoogle, service, false);
+        return true;
+      } else {
+        // Notify all active listeners that we have a new auth token.
+        synchronized (newTokenListeners) {
+          Iterator<Runnable> iter = newTokenListeners.iterator();
+          while (iter.hasNext()) {
+            iter.next().run();
+          }
+          iter = null;
+          // Remove anything not in the sticky part of the list.
+          newTokenListeners.setSize(stickyNewTokenListenerCount);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /* (non-Javadoc)
+   * @see com.google.android.apps.mytracks.io.AuthManager#getAuthToken()
+   */
+  public String getAuthToken() {
+    return authToken;
+  }
+
+  /* (non-Javadoc)
+   * @see com.google.android.apps.mytracks.io.AuthManager#invalidateAndRefresh(java.lang.Runnable)
+   */
+  public void invalidateAndRefresh(Runnable whenFinished) {
+    synchronized (newTokenListeners) {
+      if (whenFinished != null) {
+        newTokenListeners.add(whenFinished);
+      }
+    }
+    activity.runOnUiThread(new Runnable() {
+      public void run() {
+        GoogleLoginServiceHelper.invalidateAuthToken(activity, code, authToken);
+      }
+    });
+  }
+
+  /**
+   * Adds a {@link Runnable} to be executed every time the auth token is
+   * updated. The {@link Runnable} will not be removed until manually removed
+   * with {@link #removeStickyNewTokenListener(Runnable)}.
+   *
+   * @param listener The {@link Runnable} to execute every time a new auth
+   *        token is fetched
+   */
+  public void addStickyNewTokenListener(Runnable listener) {
+    synchronized (newTokenListeners) {
+      newTokenListeners.add(0, listener);
+      stickyNewTokenListenerCount++;
+    }
+  }
+
+  /**
+   * Stops executing the given {@link Runnable} every time the auth token is
+   * updated. This {@link Runnable} must have been added with
+   * {@link #addStickyNewTokenListener(Runnable)} above. If the
+   * {@link Runnable} was added more than once, only the first occurrence
+   * will be removed.
+   *
+   * @param listener The {@link Runnable} to stop executing every time a new
+   *        auth token is fetched
+   */
+  public void removeStickyNewTokenListener(Runnable listener) {
+    synchronized (newTokenListeners) {
+      if (stickyNewTokenListenerCount > 0
+          && newTokenListeners.remove(listener)) {
+        stickyNewTokenListenerCount--;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2010 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.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.TrackWriterFactory.TrackFileFormat;
+
+import android.location.Location;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+/**
+ * Exports a track as a CSV file, according to RFC 4180.
+ *
+ * The first field is a type:
+ * TRACK - track description
+ * P - point
+ * WAYPOINT - waypoint
+ *
+ * For each type, the fields are:
+ *
+ * TRACK,,,,,,,,name,description,
+ * P,time,lat,lon,alt,bearing,accurancy,speed,,,segmentIdx
+ * WAYPOINT,time,lat,lon,alt,bearing,accuracy,speed,name,description,
+ *
+ * @author Rodrigo Damazio
+ */
+public class CsvTrackWriter implements TrackFormatWriter {
+  static final SimpleDateFormat TIMESTAMP_FORMAT =
+      new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+  static {
+    TIMESTAMP_FORMAT.setTimeZone(TimeZone.getTimeZone("UTC"));
+  }
+
+  private int segmentIdx = 0;
+  private int numFields = -1;
+  private PrintWriter pw;
+  private Track track;
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.CSV.getExtension();
+  }
+
+  @Override
+  public void prepare(Track track, OutputStream out) {
+    this.track = track;
+    this.pw = new PrintWriter(out);
+  }
+
+  @Override
+  public void writeHeader() {
+    writeCommaSeparatedLine("TYPE", "TIME", "LAT", "LON", "ALT", "BEARING",
+        "ACCURACY", "SPEED", "NAME", "DESCRIPTION", "SEGMENT");
+  }
+
+  @Override
+  public void writeBeginTrack(Location firstPoint) {
+    writeCommaSeparatedLine("TRACK",
+        null, null, null, null, null, null, null,
+        track.getName(), track.getDescription(),
+        null);
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    // Do nothing
+  }
+
+  @Override
+  public void writeLocation(Location location) {
+    String timeStr = TIMESTAMP_FORMAT.format(new Date(location.getTime()));
+    writeCommaSeparatedLine("P",
+        timeStr,
+        Double.toString(location.getLatitude()),
+        Double.toString(location.getLongitude()),
+        Double.toString(location.getAltitude()),
+        Double.toString(location.getBearing()),
+        Double.toString(location.getAccuracy()),
+        Double.toString(location.getSpeed()),
+        null, null,
+        Integer.toString(segmentIdx));
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    Location location = waypoint.getLocation();
+    String timeStr = TIMESTAMP_FORMAT.format(new Date(location.getTime()));
+    writeCommaSeparatedLine("WAYPOINT",
+        timeStr,
+        Double.toString(location.getLatitude()),
+        Double.toString(location.getLongitude()),
+        Double.toString(location.getAltitude()),
+        Double.toString(location.getBearing()),
+        Double.toString(location.getAccuracy()),
+        Double.toString(location.getSpeed()),
+        waypoint.getName(),
+        waypoint.getDescription(),
+        null);
+  }
+
+  /**
+   * Writes a single line of a comma-separated-value file.
+   *
+   * @param strs the values to be written as comma-separated
+   */
+  private void writeCommaSeparatedLine(String... strs) {
+    if (numFields == -1) {
+      numFields = strs.length;
+    } else if (strs.length != numFields) {
+      throw new IllegalArgumentException(
+          "CSV lines with different number of fields");
+    }
+
+    boolean isFirst = true;
+    for (String str : strs) {
+      if (!isFirst) {
+        pw.print(',');
+      }
+      isFirst = false;
+
+      if (str != null) {
+        pw.print('"');
+        pw.print(str.replaceAll("\"", "\"\""));
+        pw.print('"');
+      }
+    }
+    pw.println();
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    segmentIdx++;
+  }
+
+  @Override
+  public void writeEndTrack(Location lastPoint) {
+    // Do nothing
+  }
+
+  @Override
+  public void writeFooter() {
+    // Do nothing
+  }
+
+  @Override
+  public void close() {
+    pw.close();
+  }
+}

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

@@ -0,0 +1,541 @@
+/*
+ * Copyright 2010 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.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.stats.TripStatisticsBuilder;
+import com.google.android.apps.mytracks.util.MyTracksUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+/**
+ * Imports GPX XML files to the my tracks provider.
+ *
+ * TODO: Show progress indication to the user.
+ *
+ * @author Leif Hendrik Wilden
+ * @author Steffen Horlacher
+ * @author Rodrigo Damazio
+ */
+public class GpxImporter extends DefaultHandler {
+
+  /*
+   * GPX-XML tag names and attributes.
+   */
+  private static final String TAG_TRACK = "trk";
+  private static final String TAG_TRACK_POINT = "trkpt";
+  private static final Object TAG_TRACK_SEGMENT = "trkseg";
+  private static final String TAG_NAME = "name";
+  private static final String TAG_DESCRIPTION = "desc";
+  private static final String TAG_ALTITUDE = "ele";
+  private static final String TAG_TIME = "time";
+  private static final String ATT_LAT = "lat";
+  private static final String ATT_LON = "lon";
+
+  /**
+   * The maximum number of locations to buffer for bulk-insertion into the database.
+   */
+  private static final int MAX_BUFFERED_LOCATIONS = 512;
+
+  /**
+   * Utilities for accessing the contnet provider.
+   */
+  private final MyTracksProviderUtils providerUtils;
+
+  /**
+   * List of track ids written in the database. Only contains successfully
+   * written tracks.
+   */
+  private final List<Long> tracksWritten;
+
+  /**
+   * Contains the current elements content.
+   */
+  private String content;
+
+  /**
+   * Currently reading location.
+   */
+  private Location location;
+
+  /**
+   * Previous location, required for calculations.
+   */
+  private Location lastLocation;
+  
+  /**
+   * Currently reading track.
+   */
+  private Track track;
+
+  /**
+   * Statistics builder for the current track.
+   */
+  private TripStatisticsBuilder statsBuilder;
+
+  /**
+   * Buffer of locations to be bulk-inserted into the database.
+   */
+  private Location[] bufferedPointInserts = new Location[MAX_BUFFERED_LOCATIONS];
+
+  /**
+   * Number of locations buffered to be inserted into the database.
+   */
+  private int numBufferedPointInserts = 0;
+  
+  /**
+   * Number of locations already processed.
+   */
+  private int numberOfLocations;
+
+  /**
+   * Number of segments already processed.
+   */
+  private int numberOfSegments;
+
+  /**
+   * Used to identify if a track was written to the database but not yet
+   * finished successfully.
+   */
+  private boolean isCurrentTrackRollbackable;
+
+  /**
+   * Flag to indicate if we're inside a track's xml element.
+   * Some sub elements like name may be used in other parts of the gpx file,
+   * and we use this to ignore them.
+   */
+  private boolean isInTrackElement;
+
+  /**
+   * Counter to find out which child level of track we are processing.
+   */
+  private int trackChildDepth;
+
+  /**
+   * SAX-Locator to get current line information.
+   */
+  private Locator locator;
+  private Location lastSegmentLocation;
+
+  /**
+   * Reads GPS tracks from a GPX file and writes tracks and their coordinates to
+   * the database.
+   * 
+   * @param is a input steam with gpx-xml data
+   * @return long[] array of track ids written in the database
+   * @throws SAXException a parsing error
+   * @throws ParserConfigurationException internal error
+   * @throws IOException a file reading problem
+   */
+  public static long[] importGPXFile(final InputStream is,
+      final MyTracksProviderUtils providerUtils)
+      throws ParserConfigurationException, SAXException, IOException {
+    SAXParserFactory factory = SAXParserFactory.newInstance();
+    GpxImporter handler = new GpxImporter(providerUtils);
+    SAXParser parser = factory.newSAXParser();
+    long[] trackIds = null;
+
+    try {
+      long start = System.currentTimeMillis();
+
+      parser.parse(is, handler);
+
+      long end = System.currentTimeMillis();
+      Log.d(MyTracksConstants.TAG, "Total import time: " + (end - start) + "ms");
+
+      trackIds = handler.getImportedTrackIds();
+    } finally {
+      // delete track if not finished
+      handler.rollbackUnfinishedTracks();
+    }
+
+    return trackIds;
+  }
+
+  /**
+   * Constructor, requires providerUtils for writing tracks the database.
+   */
+  public GpxImporter(MyTracksProviderUtils providerUtils) {
+    this.providerUtils = providerUtils;
+    tracksWritten = new ArrayList<Long>();
+  }
+
+  @Override
+  public void characters(char[] ch, int start, int length) throws SAXException {
+    String newContent = new String(ch, start, length);
+    if (content == null) {
+      content = newContent;
+    } else {
+      // In 99% of the cases, a single call to this method will be made for each
+      // sequence of characters we're interested in, so we'll rarely be
+      // concatenating strings, thus not justifying the use of a StringBuilder.
+      content += newContent;
+    }
+  }
+
+  @Override
+  public void startElement(String uri, String localName, String name,
+      Attributes attributes) throws SAXException {
+    if (isInTrackElement) {
+      trackChildDepth++;
+      if (localName.equals(TAG_TRACK_POINT)) {
+        onTrackPointElementStart(attributes);
+      } else if (localName.equals(TAG_TRACK_SEGMENT)) {
+        onTrackSegmentElementStart();
+      } else if (localName.equals(TAG_TRACK)) {
+        String msg = createErrorMessage("Invalid GPX-XML detected");
+        throw new SAXException(msg);
+      }
+    } else if (localName.equals(TAG_TRACK)) {
+      isInTrackElement = true;
+      trackChildDepth = 0;
+      onTrackElementStart();
+    }
+  }
+
+  @Override
+  public void endElement(String uri, String localName, String name)
+      throws SAXException {
+    if (!isInTrackElement) { return; }
+
+    // process these elements only as sub-elements of track
+    if (localName.equals(TAG_TRACK_POINT)) {
+      onTrackPointElementEnd();
+    } else if (localName.equals(TAG_ALTITUDE)) {
+      onAltitudeElementEnd();
+    } else if (localName.equals(TAG_TIME)) {
+      onTimeElementEnd();
+    } else if (localName.equals(TAG_NAME)) {
+      // we are only interested in the first level name element
+      if (trackChildDepth == 1) {
+        onNameElementEnd();
+      }
+    } else if (localName.equals(TAG_DESCRIPTION)) {
+      // we are only interested in the first level description element
+      if (trackChildDepth == 1) {
+        onDescriptionElementEnd();
+      }
+    } else if (localName.equals(TAG_TRACK_SEGMENT)) {
+      onTrackSegmentElementEnd();
+    } else if (localName.equals(TAG_TRACK)) {
+      onTrackElementEnd();
+      isInTrackElement = false;
+      trackChildDepth = 0;
+    }
+    trackChildDepth--;
+
+    // reset element content
+    content = null;
+  }
+
+  @Override
+  public void setDocumentLocator(Locator locator) {
+    this.locator = locator;
+  }
+
+  /**
+   * Create a new Track object and insert empty track in database. Track will be
+   * updated with missing values later.
+   */
+  private void onTrackElementStart() {
+    track = new Track();
+    numberOfLocations = 0;
+
+    Uri trackUri = providerUtils.insertTrack(track);
+    long trackId = Long.parseLong(trackUri.getLastPathSegment());
+    track.setId(trackId);
+    isCurrentTrackRollbackable = true;
+  }
+
+  private void onDescriptionElementEnd() {
+    track.setDescription(content.toString().trim());
+  }
+
+  private void onNameElementEnd() {
+    track.setName(content.toString().trim());
+  }
+
+  /**
+   * Track segment started.
+   */
+  private void onTrackSegmentElementStart() {
+    if (numberOfSegments > 0) {
+      // Add a segment separator:
+      location = new Location(LocationManager.GPS_PROVIDER);
+      location.setLatitude(100.0);
+      location.setLongitude(100.0);
+      location.setAltitude(0);
+      if (lastLocation != null) {
+        location.setTime(lastLocation.getTime());
+      }
+      insertTrackPoint(location);
+      lastLocation = location;
+      lastSegmentLocation = null;
+      location = null;
+    }
+
+    numberOfSegments++;
+  }
+
+  /**
+   * Reads trackpoint attributes and assigns them to the current location.
+   *
+   * @param attributes xml attributes
+   */
+  private void onTrackPointElementStart(Attributes attributes) throws SAXException {
+    if (location != null) {
+      String errorMsg = createErrorMessage("Found a track point inside another one.");
+      throw new SAXException(errorMsg);
+    }
+
+    location = createLocationFromAttributes(attributes);
+  }
+
+  /**
+   * Creates and returns a location with the position parsed from the given
+   * attributes.
+   *
+   * @param attributes the attributes to parse
+   * @return the created location
+   * @throws SAXException if the attributes cannot be parsed
+   */
+  private Location createLocationFromAttributes(Attributes attributes) throws SAXException {
+    String latitude = attributes.getValue(ATT_LAT);
+    String longitude = attributes.getValue(ATT_LON);
+
+    if (latitude == null || longitude == null) {
+      throw new SAXException(createErrorMessage("Point with no longitude or latitude"));
+    }
+
+    // create new location and set attributes
+    Location loc = new Location(LocationManager.GPS_PROVIDER);
+    try {
+      loc.setLatitude(Double.parseDouble(latitude));
+      loc.setLongitude(Double.parseDouble(longitude));
+    } catch (NumberFormatException e) {
+      String msg = createErrorMessage(
+          "Unable to parse lat/long: " + latitude + "/" + longitude);
+      throw new SAXException(msg, e);
+    }
+    return loc;
+  }
+
+  /**
+   * Track point finished, write in database.
+   * 
+   * @throws SAXException - thrown if track point is invalid
+   */
+  private void onTrackPointElementEnd() throws SAXException {
+    if (MyTracksUtils.isValidLocation(location)) {
+      statsBuilder.addLocation(location, location.getTime());
+
+      // insert in db
+      insertTrackPoint(location);
+
+      // first track point?
+      if (lastLocation == null && numberOfSegments == 1) {
+        track.setStartId(getLastPointId());
+      }
+
+      lastLocation = location;
+      lastSegmentLocation = location;
+      location = null;
+    } else {
+      // invalid location - abort import
+      String msg = createErrorMessage("Invalid location detected: " + location);
+      throw new SAXException(msg);
+    }
+  }
+
+  private void insertTrackPoint(Location loc) {
+    bufferedPointInserts[numBufferedPointInserts] = loc;
+    numBufferedPointInserts++;
+    numberOfLocations++;
+
+    if (numBufferedPointInserts >= MAX_BUFFERED_LOCATIONS) {
+      flushPointInserts();
+    }
+  }
+
+  private void flushPointInserts() {
+    if (numBufferedPointInserts <= 0) { return; }
+
+    providerUtils.bulkInsertTrackPoints(bufferedPointInserts, numBufferedPointInserts, track.getId());
+    numBufferedPointInserts = 0;
+  }
+
+  /**
+   * Track segment finished.
+   */
+  private void onTrackSegmentElementEnd() {
+    // Nothing to be done
+  }
+
+  /**
+   * Track finished - update in database.
+   */
+  private void onTrackElementEnd() {
+    if (lastLocation != null) {
+      flushPointInserts();
+
+      // Calculate statistics for the imported track and update
+      statsBuilder.pauseAt(lastLocation.getTime());
+      track.setStopId(getLastPointId());
+      track.setNumberOfPoints(numberOfLocations);
+      track.setStatistics(statsBuilder.getStatistics());
+      providerUtils.updateTrack(track);
+      tracksWritten.add(track.getId());
+      isCurrentTrackRollbackable = false;
+      lastSegmentLocation = null;
+      lastLocation = null;
+      statsBuilder = null;
+    } else {
+      // track contains no track points makes no real
+      // sense to import it as we have no location
+      // information -> roll back
+      rollbackUnfinishedTracks();
+    }
+  }
+
+  /**
+   * Setting time and doing additional calculations as this is the last value
+   * required. Also sets the start time for track and statistics as there is no
+   * start time in the track root element.
+   * 
+   * @throws SAXException on parsing errors
+   */
+  private void onTimeElementEnd() throws SAXException {
+    if (location == null) { return; }
+
+    // Parse the time
+    long time;
+    try {
+      time = StringUtils.parseXmlDateTime(content.trim());
+    } catch (IllegalArgumentException e) {
+      String msg = createErrorMessage("Unable to parse time: " + content);
+      throw new SAXException(msg, e);
+    }
+
+    // Calculate derived attributes from previous point
+    if (lastSegmentLocation != null) {
+      long timeDifference = time - lastSegmentLocation.getTime();
+
+      // check for negative time change
+      if (timeDifference < 0) {
+        String msg = createErrorMessage("Found negative time change.");
+        throw new SAXException(msg);
+      }
+
+      // We don't have a speed and bearing in GPX, make something up from
+      // the last two points.
+      // TODO GPS points tend to have some inherent imprecision,
+      // speed and bearing will likely be off, so the statistics for things like
+      // max speed will also be off.
+      float speed = location.distanceTo(lastLocation) * 1000.0f / timeDifference;
+      location.setSpeed(speed);
+      location.setBearing(lastSegmentLocation.bearingTo(location));
+    }
+
+    // Fill in the time
+    location.setTime(time);
+
+    // initialize start time with time of first track point
+    if (statsBuilder == null) {
+      statsBuilder = new TripStatisticsBuilder(time);
+    }
+  }
+
+  private void onAltitudeElementEnd() throws SAXException {
+    if (location != null) {
+      try {
+        location.setAltitude(Double.parseDouble(content));
+      } catch (NumberFormatException e) {
+        String msg = createErrorMessage("Unable to parse altitude: " + content);
+        throw new SAXException(msg, e);
+      }
+    }
+  }
+
+  /**
+   * Deletes the last track if it was not completely imported.
+   */
+  public void rollbackUnfinishedTracks() {
+    if (isCurrentTrackRollbackable) {
+      providerUtils.deleteTrack(track.getId());
+      isCurrentTrackRollbackable = false;
+    }
+  }
+
+  /**
+   * Get all track ids of the tracks created by this importer run.
+   * 
+   * @return array of track ids
+   */
+  private long[] getImportedTrackIds() {
+    // Convert from java.lang.Long for convenience
+    long[] result = new long[tracksWritten.size()];
+    for (int i = 0; i < result.length; i++) {
+      result[i] = tracksWritten.get(i);
+    }
+    return result;
+  }
+
+  /**
+   * Returns the ID of the last point inserted into the database.
+   */
+  private long getLastPointId() {
+    flushPointInserts();
+    
+    return providerUtils.getLastLocationId(track.getId());
+  }
+
+  /**
+   * Builds a parsing error message with current line information.
+   * 
+   * @param details details about the error, will be appended
+   * @return error message string with current line information
+   */
+  private String createErrorMessage(String details) {
+    StringBuffer msg = new StringBuffer();
+    msg.append("Parsing error at line: ");
+    msg.append(locator.getLineNumber());
+    msg.append(" column: ");
+    msg.append(locator.getColumnNumber());
+    msg.append(". ");
+    msg.append(details);
+    return msg.toString();
+  }
+}

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

@@ -0,0 +1,162 @@
+/*
+ * 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.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.TrackWriterFactory.TrackFileFormat;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import android.location.Location;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+import java.text.SimpleDateFormat;
+import java.text.DecimalFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+/**
+ * Log of one track.
+ *
+ * @author Sandor Dornbush
+ */
+public class GpxTrackWriter implements TrackFormatWriter {
+
+  private static final int LATLONG_FORMAT = Location.FORMAT_DEGREES;
+  private static final DecimalFormat ELEVATION_FORMATTER =
+      new DecimalFormat("#.#");
+  private static final SimpleDateFormat TIMESTAMP_FORMATTER =
+      new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+  static {
+    TIMESTAMP_FORMATTER.setTimeZone(TimeZone.getTimeZone("UTC"));
+  }
+
+  private PrintWriter pw = null;
+  private Track track;
+
+  private String formatLocation(Location l) {
+    return "lat=\"" + Location.convert(l.getLatitude(), LATLONG_FORMAT)
+      + "\" lon=\"" + Location.convert(l.getLongitude(), LATLONG_FORMAT) + "\"";
+  }
+
+  @Override
+  public void prepare(Track track, OutputStream out) {
+    this.track = track;
+    this.pw = new PrintWriter(out);
+  }
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.GPX.getExtension();
+  }
+
+  @Override
+  public void writeHeader() {
+    if (pw != null) {
+      pw.format("<?xml version=\"1.0\" encoding=\"%s\" standalone=\"yes\"?>\n",
+          Charset.defaultCharset().name());
+      pw.println("<?xml-stylesheet type=\"text/xsl\" href=\"details.xsl\"?>");
+      pw.println("<gpx");
+      pw.println(" version=\"1.1\"");
+      pw.println(" creator=\"My Tracks for the G1 running Android\"");
+      pw.println(" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
+      pw.println(" xmlns=\"http://www.topografix.com/GPX/1/1\"");
+      pw.print(" xmlns:topografix=\"http://www.topografix.com/GPX/Private/"
+          + "TopoGrafix/0/1\"");
+      pw.print(" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 ");
+      pw.print("http://www.topografix.com/GPX/1/1/gpx.xsd ");
+      pw.print("http://www.topografix.com/GPX/Private/TopoGrafix/0/1 ");
+      pw.println("http://www.topografix.com/GPX/Private/TopoGrafix/0/1/"
+          + "topografix.xsd\">");
+      // TODO: Author etc.
+    }
+  }
+
+  @Override
+  public void writeFooter() {
+    if (pw != null) {
+      pw.println("</gpx>");
+    }
+  }
+
+  @Override
+  public void writeBeginTrack(Location firstPoint) {
+    if (pw != null) {
+      pw.println("<trk>");
+      pw.println("<name>" + StringUtils.stringAsCData(track.getName())
+          + "</name>");
+      pw.println("<desc>" + StringUtils.stringAsCData(track.getDescription())
+          + "</desc>");
+      pw.println("<number>" + track.getId() + "</number>");
+      pw.println("<extensions><topografix:color>c0c0c0</topografix:color></extensions>");
+    }
+  }
+
+  @Override
+  public void writeEndTrack(Location lastPoint) {
+    if (pw != null) {
+      pw.println("</trk>");
+    }
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    pw.println("<trkseg>");
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    pw.println("</trkseg>");
+  }
+
+  @Override
+  public void writeLocation(Location l) {
+    if (pw != null) {
+      pw.println("<trkpt " + formatLocation(l) + ">");
+      Date d = new Date(l.getTime());
+      pw.println("<ele>" + ELEVATION_FORMATTER.format(l.getAltitude()) + "</ele>");
+      pw.println("<time>" + TIMESTAMP_FORMATTER.format(d) + "</time>");
+      pw.println("</trkpt>");
+    }
+  }
+
+  @Override
+  public void close() {
+    if (pw != null) {
+      pw.close();
+      pw = null;
+    }
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    if (pw != null) {
+      Location l = waypoint.getLocation();
+      if (l != null) {
+        pw.println("<wpt " + formatLocation(l) + ">");
+        pw.println("<ele>" + ELEVATION_FORMATTER.format(l.getAltitude()) + "</ele>");
+        pw.println("<time>" + TIMESTAMP_FORMATTER.format(l.getTime()) + "</time>");
+        pw.println("<name>" + StringUtils.stringAsCData(waypoint.getName())
+            + "</name>");
+        pw.println("<desc>"
+            + StringUtils.stringAsCData(waypoint.getDescription()) + "</desc>");
+        pw.println("</wpt>");
+      }
+    }
+  }
+}

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

@@ -0,0 +1,232 @@
+/*
+ * 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.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.TrackWriterFactory.TrackFileFormat;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import android.content.Context;
+import android.location.Location;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Vector;
+
+/**
+ * Write track as KML to a file.
+ *
+ * @author Leif Hendrik Wilden
+ */
+public class KmlTrackWriter implements TrackFormatWriter {
+
+  private final Vector<Double> distances = new Vector<Double>();
+  private final Vector<Double> elevations = new Vector<Double>();
+  private final StringUtils stringUtils;
+  private PrintWriter pw = null;
+  private Track track;
+
+  public KmlTrackWriter(Context context) {
+    stringUtils = new StringUtils(context);
+  }
+
+  /**
+   * Testing constructor.
+   */
+  KmlTrackWriter(StringUtils stringUtils) {
+    this.stringUtils = stringUtils;
+  }
+
+  @Override
+  public void prepare(Track track, OutputStream out) {
+    this.track = track;
+    this.pw = new PrintWriter(out);
+  }
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.KML.getExtension();
+  }
+
+  @Override
+  public void writeHeader() {
+    if (pw != null) {
+      pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+      pw.print("<kml");
+      pw.print(" xmlns=\"http://earth.google.com/kml/2.0\"");
+      pw.println(" xmlns:atom=\"http://www.w3.org/2005/Atom\">");
+      pw.println("<Document>");
+      pw.println("<atom:author><atom:name>My Tracks running on Android"
+          + "</atom:name></atom:author>");
+      pw.println("<name>" + StringUtils.stringAsCData(track.getName())
+          + "</name>");
+      pw.println("<description>"
+          + StringUtils.stringAsCData(track.getDescription())
+          + "</description>");
+      writeStyles();
+    }
+  }
+
+  @Override
+  public void writeFooter() {
+    if (pw != null) {
+      pw.println("</Document>");
+      pw.println("</kml>");
+    }
+  }
+
+  @Override
+  public void writeBeginTrack(Location firstPoint) {
+    if (pw != null) {
+      writePlacemark("(Start)", track.getDescription(), "#sh_green-circle",
+          firstPoint);
+      pw.println("<Placemark>");
+      pw.println("<name>" + StringUtils.stringAsCData(track.getName())
+          + "</name>");
+      pw.println("<description>"
+          + StringUtils.stringAsCData(track.getDescription())
+          + "</description>");
+      pw.println("<styleUrl>#track</styleUrl>");
+      pw.println("<MultiGeometry>");
+    }
+  }
+
+  @Override
+  public void writeEndTrack(Location lastPoint) {
+    if (pw != null) {
+      pw.println("</MultiGeometry>");
+      pw.println("</Placemark>");
+      String description = stringUtils.generateTrackDescription(
+          track, distances, elevations);
+      writePlacemark("(End)", description, "#sh_red-circle", lastPoint);
+    }
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    if (pw != null) {
+      pw.print("<LineString><coordinates>");
+    }
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    if (pw != null) {
+      pw.println("</coordinates></LineString>");
+    }
+  }
+
+  @Override
+  public void writeLocation(Location l) {
+    if (pw != null) {
+      pw.print(l.getLongitude() +  "," + l.getLatitude() + ","
+          + l.getAltitude() + " ");
+    }
+  }
+
+  private String getPinStyle(Waypoint waypoint) {
+    if (waypoint.getType() == Waypoint.TYPE_STATISTICS) {
+      return "#sh_ylw-pushpin";
+    }
+    // Try to find the icon color.
+    // The string should be of the form:
+    // "http://maps.google.com/mapfiles/ms/micons/XXX.png"
+    int slash = waypoint.getIcon().lastIndexOf('/');
+    int png = waypoint.getIcon().lastIndexOf('.');
+    if ((slash != -1) && (slash < png)) {
+      String color = waypoint.getIcon().substring(slash + 1, png);
+      return "#sh_" + color + "-pushpin";
+    }
+    return "#sh_blue-pushpin";
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    if (pw != null) {
+      writePlacemark(
+          waypoint.getName(),
+          waypoint.getDescription(),
+          getPinStyle(waypoint),
+          waypoint.getLocation());
+    }
+  }
+
+  @Override
+  public void close() {
+    if (pw != null) {
+      pw.close();
+      pw = null;
+    }
+  }
+
+  private void writeStyles() {
+    pw.println("<Style id=\"track\"><LineStyle><color>7f0000ff</color>"
+        + "<width>4</width></LineStyle></Style>");
+
+    pw.print("<Style id=\"sh_green-circle\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/paddle/"
+        + "grn-circle.png</href></Icon>");
+    pw.println("<hotSpot x=\"32\" y=\"1\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+
+    pw.print("<Style id=\"sh_red-circle\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/paddle/"
+        + "red-circle.png</href></Icon>");
+    pw.println("<hotSpot x=\"32\" y=\"1\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+
+    pw.print("<Style id=\"sh_ylw-pushpin\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/pushpin/"
+        + "ylw-pushpin.png</href></Icon>");
+    pw.println("<hotSpot x=\"20\" y=\"2\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+
+    pw.print("<Style id=\"sh_blue-pushpin\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/pushpin/"
+        + "blue-pushpin.png</href></Icon>");
+    pw.println("<hotSpot x=\"20\" y=\"2\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+
+    pw.print("<Style id=\"sh_green-pushpin\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/pushpin/"
+        + "grn-pushpin.png</href></Icon>");
+    pw.println("<hotSpot x=\"20\" y=\"2\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+
+    pw.print("<Style id=\"sh_red-pushpin\"><IconStyle><scale>1.3</scale>");
+    pw.print("<Icon><href>http://maps.google.com/mapfiles/kml/pushpin/"
+        + "red-pushpin.png</href></Icon>");
+    pw.println("<hotSpot x=\"20\" y=\"2\" xunits=\"pixels\" yunits=\"pixels\"/>"
+        + "</IconStyle></Style>");
+  }
+
+  private void writePlacemark(String name, String description, String style,
+      Location location) {
+    if (location != null) {
+      pw.println("<Placemark>");
+      pw.println("  <name>" + StringUtils.stringAsCData(name) + "</name>");
+      pw.println("  <description>" + StringUtils.stringAsCData(description)
+          + "</description>");
+      pw.println("  <styleUrl>" + style + "</styleUrl>");
+      pw.println("  <Point>");
+      pw.println("    <coordinates>" + location.getLongitude() + ","
+          + location.getLatitude() + "</coordinates>");
+      pw.println("  </Point>");
+      pw.println("</Placemark>");
+    }
+  }
+}

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

@@ -0,0 +1,211 @@
+/*
+ * Copyright 2010 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.accounts.Account;
+import com.google.android.accounts.AccountManager;
+import com.google.android.accounts.AccountManagerCallback;
+import com.google.android.accounts.AccountManagerFuture;
+import com.google.android.accounts.AuthenticatorException;
+import com.google.android.accounts.OperationCanceledException;
+import com.google.android.apps.mytracks.AccountChooser;
+import com.google.android.apps.mytracks.MyTracks;
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+
+import java.io.IOException;
+
+/**
+ * AuthManager keeps track of the current auth token for a user. The advantage
+ * over just passing around a String is that this class can renew the auth
+ * token if necessary, and it will change for all classes using this
+ * AuthManager.
+ */
+public class ModernAuthManager implements AuthManager {
+  /** The activity that will handle auth result callbacks. */
+  private final Activity activity;
+
+  /** The name of the service to authorize for. */
+  private final String service;
+
+  /** The most recently fetched auth token or null if none is available. */
+  private String authToken;
+
+  private final AccountManager accountManager;
+
+  private Runnable whenFinished;
+
+  /**
+   * AuthManager requires many of the same parameters as
+   * {@link com.google.android.googlelogindist.GoogleLoginServiceHelper
+   * #getCredentials(Activity, int, Bundle, boolean, String, boolean)}.
+   * The activity must have a handler in {@link Activity#onActivityResult} that
+   * calls {@link #authResult(int, Intent)} if the request code is the code
+   * given here.
+   *
+   * @param activity An activity with a handler in
+   *        {@link Activity#onActivityResult} that calls
+   *        {@link #authResult(int, Intent)} when {@literal code} is the request
+   *        code
+   * @param code The request code to pass to
+   *        {@link Activity#onActivityResult} when
+   *        {@link #authResult(int, Intent)} should be called
+   * @param extras A {@link Bundle} of extras for
+   *        {@link com.google.android.googlelogindist.GoogleLoginServiceHelper}
+   * @param requireGoogle True if the account must be a Google account
+   * @param service The name of the service to authenticate as
+   */
+  public ModernAuthManager(Activity activity, int code, Bundle extras,
+      boolean requireGoogle, String service) {
+    this.activity = activity;
+    this.service = service;
+    this.accountManager = AccountManager.get(activity);
+  }
+
+  /**
+   * Call this to do the initial login. The user will be asked to login if
+   * they haven't already. The {@link Runnable} provided will be executed
+   * when the auth token is successfully fetched.
+   *
+   * @param runnable A {@link Runnable} to execute when the auth token
+   *        has been successfully fetched and is available via
+   *        {@link #getAuthToken()}
+   */
+  public void doLogin(final Runnable runnable, Object o) {
+    this.whenFinished = runnable;
+    if (!(o instanceof Account)) {
+      throw new IllegalArgumentException("FroyoAuthManager requires an account.");
+    }
+    Account account = (Account) o;
+    accountManager.getAuthToken(account, service, true,
+            new AccountManagerCallback<Bundle>() {
+        public void run(AccountManagerFuture<Bundle> future) {
+          try {
+            Bundle result = future.getResult();
+
+            // AccountManager needs user to grant permission
+            if (result.containsKey(AccountManager.KEY_INTENT)) {
+              Intent intent = (Intent) result.get(AccountManager.KEY_INTENT);
+              clearNewTaskFlag(intent);
+              activity.startActivityForResult(intent, MyTracksConstants.GET_LOGIN);
+              return;
+            }
+
+            authToken = result.getString(
+                AccountManager.KEY_AUTHTOKEN);
+            Log.e(MyTracksConstants.TAG, "Got auth token.");
+            runWhenFinished();
+          } catch (OperationCanceledException e) {
+            Log.e(MyTracksConstants.TAG, "Operation Canceled", e);
+          } catch (IOException e) {
+            Log.e(MyTracksConstants.TAG, "IOException", e);
+          } catch (AuthenticatorException e) {
+            Log.e(MyTracksConstants.TAG, "Authentication Failed", e);
+          }
+        }
+    }, null /* handler */);
+  }
+
+  private static void clearNewTaskFlag(Intent intent) {
+    int flags = intent.getFlags();
+    flags &= ~Intent.FLAG_ACTIVITY_NEW_TASK;
+    intent.setFlags(flags);
+  }
+
+  /**
+   * The {@link Activity} passed into the constructor should call this
+   * function when it gets {@link Activity#onActivityResult} with the request
+   * code passed into the constructor. The resultCode and results should
+   * come directly from the {@link Activity#onActivityResult} function. This
+   * function will return true if an auth token was successfully fetched or
+   * the process is not finished.
+   *
+   * @param resultCode The result code passed in to the {@link Activity}'s
+   *        {@link Activity#onActivityResult} function
+   * @param results The data passed in to the {@link Activity}'s
+   *        {@link Activity#onActivityResult} function
+   * @return True if the auth token was fetched or we aren't done fetching
+   *         the auth token, or False if there was an error or the request was
+   *         canceled
+   */
+  public boolean authResult(int resultCode, Intent results) {
+    if (results != null) {
+      authToken = results.getStringExtra(
+          AccountManager.KEY_AUTHTOKEN);
+      Log.w(MyTracksConstants.TAG, "authResult: " + authToken);
+    } else {
+      Log.e(MyTracksConstants.TAG, "No auth result results!!");
+    }
+    runWhenFinished();
+    return authToken != null;
+  }
+
+  /**
+   * Returns the current auth token. Response may be null if no valid auth
+   * token has been fetched.
+   *
+   * @return The current auth token or null if no auth token has been
+   *         fetched
+   */
+  public String getAuthToken() {
+    return authToken;
+  }
+
+  /**
+   * Invalidates the existing auth token and request a new one. The
+   * {@link Runnable} provided will be executed when the new auth token is
+   * successfully fetched.
+   *
+   * @param runnable A {@link Runnable} to execute when a new auth token
+   *        is successfully fetched
+   */
+  public void invalidateAndRefresh(final Runnable runnable) {
+    this.whenFinished = runnable;
+
+    activity.runOnUiThread(new Runnable() {
+      public void run() {
+        accountManager.invalidateAuthToken(MyTracksConstants.ACCOUNT_TYPE,
+            authToken);
+        MyTracks.getInstance().getAccountChooser().chooseAccount(activity,
+            new AccountChooser.AccountHandler() {
+              @Override
+              public void handleAccountSelected(Account account) {
+                if (account != null) {
+                  doLogin(whenFinished, account);
+                } else {
+                  runWhenFinished();
+                }
+              }
+            });
+      }
+    });
+  }
+
+  private void runWhenFinished() {
+    if (whenFinished != null) {
+      (new Thread() {
+        @Override
+        public void run() {
+          whenFinished.run();
+        }
+      }).start();
+    }
+  }
+}

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

@@ -0,0 +1,308 @@
+/*
+ * 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.mytracks.MyTracks;
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.docs.DocsHelper;
+import com.google.android.apps.mytracks.io.gdata.GDataClientFactory;
+import com.google.android.apps.mytracks.io.gdata.GDataWrapper;
+import com.google.android.common.gdata.AndroidXmlParserFactory;
+import com.google.android.maps.mytracks.R;
+import com.google.wireless.gdata.client.GDataClient;
+import com.google.wireless.gdata.docs.DocumentsClient;
+import com.google.wireless.gdata.docs.SpreadsheetsClient;
+import com.google.wireless.gdata.maps.xml.XmlMapsGDataParserFactory;
+import com.google.wireless.gdata.client.GDataServiceClient;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+
+import java.io.IOException;
+
+/**
+ * A helper class used to transmit tracks statistics to Google Docs/Trix.
+ *
+ * @author Sandor Dornbush
+ */
+public class SendToDocs {
+  /** The GData service name for Google Spreadsheets (aka Trix) */
+  public static final String GDATA_SERVICE_NAME_TRIX = "wise";
+  
+  /** The GData service name for the Google Docs Document List */
+  public static final String GDATA_SERVICE_NAME_DOCLIST = "writely";
+  
+  private final Activity activity;
+  private final AuthManager trixAuth;
+  private final AuthManager docListAuth;
+  private final long trackId;
+  private final boolean metricUnits;
+  private final HandlerThread handlerThread;
+  private final Handler handler;
+
+  private boolean createdNewSpreadSheet = false;
+
+  private boolean success = true;
+  private String statusMessage = "";
+  private Runnable onCompletion = null;
+
+  public SendToDocs(Activity activity, AuthManager trixAuth,
+      AuthManager docListAuth, long trackId) {
+    this.activity = activity;
+    this.trixAuth = trixAuth;
+    this.docListAuth = docListAuth;
+    this.trackId = trackId;
+
+    SharedPreferences preferences = activity.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    if (preferences != null) {
+      metricUnits =
+          preferences.getBoolean(activity.getString(R.string.metric_units_key),
+              true);
+    } else {
+      metricUnits = true;
+    }
+
+    Log.d(MyTracksConstants.TAG,
+        "Sending to Google Docs: trackId = " + trackId);
+    handlerThread = new HandlerThread("SendToGoogleDocs");
+    handlerThread.start();
+    handler = new Handler(handlerThread.getLooper());
+  }
+
+  public void run() {
+    handler.post(new Runnable() {
+      @Override
+      public void run() {
+        doUpload();
+      }
+    });
+  }
+
+  private void doUpload() {
+    statusMessage = activity.getString(R.string.error_sending_to_fusiontables);
+    success = false;
+
+    try {
+      if (trackId == -1) {
+        Log.w(MyTracksConstants.TAG, "Cannot get track id.");
+        return;
+      }
+
+      // Get the track from the provider:
+      Track track =
+          MyTracksProviderUtils.Factory.get(activity).getTrack(trackId);
+      if (track == null) {
+        Log.w(MyTracksConstants.TAG, "Cannot get track.");
+        return;
+      }
+
+      // Transmit track stats via GData feed:
+      // -------------------------------
+
+      Log.d(MyTracksConstants.TAG, "SendToDocs: Uploading to spreadsheet");
+      success = uploadToDocs(track);
+      if (success) {
+        if (createdNewSpreadSheet) {
+          statusMessage = activity.getString(
+              R.string.status_tracks_have_been_uploaded_to_new_doc);
+        } else {
+          statusMessage = activity.getString(
+              R.string.status_tracks_have_been_uploaded_to_docs);
+        }
+      } else {
+        statusMessage = activity.getString(R.string.error_sending_to_docs);
+      }
+      Log.d(MyTracksConstants.TAG, "SendToDocs: Done.");
+    } finally {
+      if (onCompletion != null) {
+        activity.runOnUiThread(onCompletion);
+      }
+    }
+  }
+
+  public boolean wasSuccess() {
+    return success;
+  }
+
+  public String getStatusMessage() {
+    return statusMessage;
+  }
+
+  public void setOnCompletion(Runnable onCompletion) {
+    this.onCompletion = onCompletion;
+  }
+
+  /**
+   * Uploads the statistics about a track to Google Docs using the docs GData
+   * feed.
+   *
+   * @param track the track
+   */
+  private boolean uploadToDocs(Track track) {
+    GDataWrapper<GDataServiceClient> docListWrapper = new GDataWrapper<GDataServiceClient>();
+    docListWrapper.setAuthManager(docListAuth);
+    docListWrapper.setRetryOnAuthFailure(true);
+    
+    GDataWrapper<GDataServiceClient> trixWrapper = new GDataWrapper<GDataServiceClient>();
+    trixWrapper.setAuthManager(trixAuth);
+    trixWrapper.setRetryOnAuthFailure(true);
+
+    DocsHelper docsHelper = new DocsHelper();
+
+    GDataClient androidClient = null;
+    try {
+      androidClient = GDataClientFactory.getGDataClient(activity);
+      SpreadsheetsClient gdataClient = new SpreadsheetsClient(androidClient,
+          new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+      trixWrapper.setClient(gdataClient);
+      Log.d(MyTracksConstants.TAG,
+          "GData connection prepared: " + this.docListAuth);
+      String sheetTitle = "My Tracks";
+
+      if (track.getCategory() != null && !track.getCategory().equals("")) {
+        sheetTitle += "-" + track.getCategory();
+      }
+
+      DocumentsClient docsGdataClient = new DocumentsClient(androidClient,
+          new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+      docListWrapper.setClient(docsGdataClient);
+
+      // First try to find the spreadsheet:
+      String spreadsheetId = null;
+      try {
+        spreadsheetId = docsHelper.requestSpreadsheetId(docListWrapper, 
+            sheetTitle);
+      } catch (IOException e) {
+        Log.i(MyTracksConstants.TAG, "Spreadsheet lookup failed.", e);
+        return false;
+      }
+
+      if (spreadsheetId == null) {
+        MyTracks.getInstance().setProgressValue(65);
+        // Waiting a few seconds and trying again. Maybe the server just had a
+        // hickup (unfortunately that happens quite a lot...).
+        try {
+          Thread.sleep(5000);
+        } catch (InterruptedException e) {
+          Log.e(MyTracksConstants.TAG, "Sleep interrupted", e);
+        }
+        
+        try {
+          spreadsheetId = docsHelper.requestSpreadsheetId(docListWrapper, 
+              sheetTitle);
+        } catch (IOException e) {
+          Log.i(MyTracksConstants.TAG, "2nd spreadsheet lookup failed.", e);
+          return false;
+        }
+      }
+      
+      // We were unable to find an existing spreadsheet, so create a new one.
+      MyTracks.getInstance().setProgressValue(70);
+      if (spreadsheetId == null) {
+        Log.i(MyTracksConstants.TAG, "Creating new spreadsheet: " + sheetTitle);
+
+        try {
+          spreadsheetId = docsHelper.createSpreadsheet(activity, docListWrapper,
+              sheetTitle);
+        } catch (IOException e) {
+          Log.i(MyTracksConstants.TAG, "Failed to create new spreadsheet "
+              + sheetTitle, e);
+          return false;
+        }
+        MyTracks.getInstance().setProgressValue(80);
+        createdNewSpreadSheet = true;
+
+        if (spreadsheetId == null) {
+          MyTracks.getInstance().setProgressValue(85);
+          // The previous creation might have succeeded even though GData
+          // reported an error. Seems to be a know bug,
+          // see http://code.google.com/p/gdata-issues/issues/detail?id=929
+          // Try to find the created spreadsheet:
+          Log.w(MyTracksConstants.TAG,
+              "Create might have failed. Trying to find created document.");
+          try {
+            Thread.sleep(5000);
+          } catch (InterruptedException e) {
+            Log.e(MyTracksConstants.TAG, "Sleep interrupted", e);
+          }
+
+          try {
+            spreadsheetId = docsHelper.requestSpreadsheetId(docListWrapper, 
+                sheetTitle);
+          } catch (IOException e) {
+            Log.i(MyTracksConstants.TAG, "Failed create-failed lookup", e);
+            return false;
+          }
+
+          if (spreadsheetId == null) {
+            MyTracks.getInstance().setProgressValue(87);
+            // Re-try
+            try {
+              Thread.sleep(5000);
+            } catch (InterruptedException e) {
+              Log.e(MyTracksConstants.TAG, "Sleep interrupted", e);
+            }
+            
+            try {
+              spreadsheetId = docsHelper.requestSpreadsheetId(docListWrapper, 
+                  sheetTitle);
+            } catch (IOException e) {
+              Log.i(MyTracksConstants.TAG, "Failed create-failed relookup", e);
+              return false;
+            }
+          }
+          if (spreadsheetId == null) {
+            Log.i(MyTracksConstants.TAG,
+                "Creating new spreadsheet really failed.");
+            return false;
+          }
+        }
+      }
+
+      String worksheetId = null;
+      try {
+        worksheetId = docsHelper.getWorksheetId(trixWrapper, spreadsheetId);
+        if (worksheetId == null) {
+          throw new IOException("Worksheet ID lookup returned empty");
+        }
+      } catch (IOException e) {
+        Log.i(MyTracksConstants.TAG, "Looking up worksheet id failed.", e);
+        return false;
+      }
+
+      MyTracks.getInstance().setProgressValue(90);
+
+      docsHelper.addTrackRow(activity, trixAuth, spreadsheetId, worksheetId, 
+          track, metricUnits);
+      Log.i(MyTracksConstants.TAG, "Done uploading to docs.");
+    } catch (IOException e) {
+      Log.e(MyTracksConstants.TAG, "Unable to upload docs.", e);
+      return false;
+    } finally {
+      if (androidClient != null) {
+        androidClient.close();
+      }
+    }
+    return true;
+  }
+}

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

@@ -0,0 +1,696 @@
+/*
+ * Copyright 2010 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.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.io.gdata.GDataWrapper;
+import com.google.android.apps.mytracks.io.gdata.GDataWrapper.QueryFunction;
+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.api.client.googleapis.GoogleHeaders;
+import com.google.api.client.googleapis.MethodOverrideIntercepter;
+import com.google.api.client.http.GenericUrl;
+import com.google.api.client.http.HttpRequest;
+import com.google.api.client.http.HttpResponse;
+import com.google.api.client.http.HttpResponseException;
+import com.google.api.client.http.HttpTransport;
+import com.google.api.client.http.InputStreamContent;
+import com.google.api.client.javanet.NetHttpTransport;
+import com.google.api.client.util.Strings;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.location.Location;
+import android.util.Log;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+/**
+ * A helper class used to transmit tracks to Google Fusion Tables.
+ * A new instance should be used for each upload.
+ *
+ * @author Leif Hendrik Wilden
+ */
+public class SendToFusionTables implements Runnable {
+
+  /**
+   * Listener invoked when sending to fusion tables completes.
+   */
+  public interface OnSendCompletedListener {
+    void onSendCompleted(String tableId, boolean success, int statusMessage);
+  }
+
+  /** The GData service id for Fusion Tables. */
+  public static final String SERVICE_ID = "fusiontables";
+
+  /** The path for viewing a map visualization of a table. */
+  private static final String FUSIONTABLES_MAP = 
+      "http://www.google.com/fusiontables/embedviz?" +
+      "viz=MAP&q=select+col0,+col1,+col2,+col3+from+%s+&h=false&" +
+      "lat=%f&lng=%f&z=%d&t=1&l=col2";
+
+  /** Standard base feed url for Fusion Tables. */
+  private static final String FUSIONTABLES_BASE_FEED_URL =
+      "http://www.google.com/fusiontables/api/query";
+
+  private static final int MAX_POINTS_PER_UPLOAD = 2048;
+
+  private static final String GDATA_VERSION = "2";
+  
+  // This class reports upload status to the user as a completion percentage
+  // using a progress bar.  Progress is defined as follows:
+  // 
+  //       0%   Getting track metadata
+  //       5%   Creating Fusion Table (GData to FT server)
+  //  10%-90%   Uploading the track data to Fusion Tables
+  //      95%   Uploading waypoints
+  //     100%   Done
+  private static final int PROGRESS_INITIALIZATION = 0;
+  private static final int PROGRESS_FUSION_TABLE_CREATE = 5;
+  private static final int PROGRESS_UPLOAD_DATA_MIN = 10;
+  private static final int PROGRESS_UPLOAD_DATA_MAX = 90;
+  private static final int PROGRESS_UPLOAD_WAYPOINTS = 95;
+  private static final int PROGRESS_COMPLETE = 100;
+
+  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;
+
+  // Progress status
+  private int totalLocationsRead;
+  private int totalLocationsPrepared;
+  private int totalLocationsUploaded;
+  private int totalLocations;
+  private int totalSegmentsUploaded;
+
+  private HttpTransport transport;
+  private String tableId;
+
+  private static String MARKER_TYPE_START = "large_green";
+  private static String MARKER_TYPE_END = "large_red";
+  private static String MARKER_TYPE_WAYPOINT = "large_yellow";
+
+  static {
+    // We manually assign the transport to avoid having HttpTransport try to
+    // load it via reflection (which breaks due to ProGuard).
+    HttpTransport.setLowLevelHttpTransport(new NetHttpTransport());
+  }
+
+  public SendToFusionTables(Activity context, AuthManager auth,
+      long trackId, ProgressIndicator progressIndicator,
+      OnSendCompletedListener onCompletion) {
+    this.context = context;
+    this.auth = auth;
+    this.trackId = trackId;
+    this.progressIndicator = progressIndicator;
+    this.onCompletion = onCompletion;
+    this.stringUtils = new StringUtils(context);
+    this.providerUtils = MyTracksProviderUtils.Factory.get(context);
+
+    GoogleHeaders headers = new GoogleHeaders();
+    headers.setApplicationName("Google-MyTracks-" + MyTracksUtils.getMyTracksVersion(context));
+    headers.gdataVersion = GDATA_VERSION;
+
+    transport = new HttpTransport();
+    MethodOverrideIntercepter.setAsFirstFor(transport);
+    transport.defaultHeaders = headers;
+  }
+
+  @Override
+  public void run() {
+    Log.d(MyTracksConstants.TAG, "Sending to Fusion tables: trackId = " + trackId);
+    doUpload();
+  }
+
+  public static String getMapVisualizationUrl(Track track) {
+    // TODO(leifhendrik): Determine correct bounding box and zoom level that will show the entire track.
+    TripStatistics stats = track.getStatistics();
+    double latE6 = stats.getBottom() + (stats.getTop() - stats.getBottom()) / 2;
+    double lonE6 = stats.getLeft() + (stats.getRight() - stats.getLeft()) / 2;
+    int z = 15;
+    return String.format(FUSIONTABLES_MAP, track.getTableId(), latE6 / 1.E6, lonE6 / 1.E6, z);
+  }
+
+  private void doUpload() {
+    ((GoogleHeaders) transport.defaultHeaders).setGoogleLogin(auth.getAuthToken());
+    int statusMessageId = R.string.error_sending_to_fusiontables;
+    boolean success = true;
+    try {
+      progressIndicator.setProgressValue(PROGRESS_INITIALIZATION);
+      progressIndicator.setProgressMessage(R.string.progress_message_reading_track);
+
+      // Get the track meta-data
+      Track track = providerUtils.getTrack(trackId);
+      String originalDescription = track.getDescription();
+
+      // Create a new table:
+      progressIndicator.setProgressValue(PROGRESS_FUSION_TABLE_CREATE);
+      progressIndicator.setProgressMessage(R.string.progress_message_creating_fusiontable);
+      if (!createNewTable(track) || !makeTableUnlisted(tableId)) {
+        return;
+      }
+
+      progressIndicator.setProgressValue(PROGRESS_UPLOAD_DATA_MIN);
+      progressIndicator.setProgressMessage(R.string.progress_message_sending_fusiontables);
+
+      // Upload all of the segments of the track plus start/end markers
+      if (!uploadAllTrackPoints(track, originalDescription)) {
+        return;
+      }
+      
+      progressIndicator.setProgressValue(PROGRESS_UPLOAD_WAYPOINTS);
+
+      // Upload all the waypoints.
+      if (!uploadWaypoints(track)) {
+        return;
+      }
+      
+      statusMessageId = R.string.status_new_fusiontable_has_been_created;
+      Log.d(MyTracksConstants.TAG, "SendToFusionTables: Done: " + success);
+      progressIndicator.setProgressValue(PROGRESS_COMPLETE);
+    } finally {
+
+      final boolean finalSuccess = success;
+      final int finalStatusMessageId = statusMessageId;
+      context.runOnUiThread(new Runnable() {
+        public void run() {
+          if (onCompletion != null) {
+            onCompletion.onSendCompleted(
+                tableId, finalSuccess, finalStatusMessageId);
+          }
+        }
+      });
+    }
+  }
+
+  /**
+   * Creates a new table.
+   * If successful sets {@link #tableId}.
+   *
+   * @return true in case of success.
+   */
+  private boolean createNewTable(Track track) {
+    Log.d(MyTracksConstants.TAG, "Creating a new fusion table.");
+    String query = "CREATE TABLE '" + sqlEscape(track.getName()) +
+        "' (name:STRING,description:STRING,geometry:LOCATION,marker:STRING)";
+    return runUpdate(query);
+  }
+
+  private boolean makeTableUnlisted(String tableId) {
+    Log.d(MyTracksConstants.TAG, "Setting visibility to unlisted.");
+    String query = "UPDATE TABLE " + tableId + " SET VISIBILITY = UNLISTED";
+    return runUpdate(query);
+  }
+
+  /**
+   * Formats given values SQL style. Escapes single quotes with a backslash.
+   *
+   * @param values the values to format
+   * @return the values formatted as: ('value1','value2',...,'value_n').
+   */
+  private static String values(String... values) {
+    StringBuilder builder = new StringBuilder("(");
+    for (int i = 0; i < values.length; i++) {
+      if (i > 0) {
+        builder.append(',');
+      }
+      builder.append('\'');
+      builder.append(sqlEscape(values[i]));
+      builder.append('\'');
+    }
+    builder.append(')');
+    return builder.toString();
+  }
+  
+  private static String sqlEscape(String value) {
+    return value.replaceAll("'", "''");
+  }
+
+  /**
+   * Creates a new row representing a marker.
+   *
+   * @param name the marker name
+   * @param description the marker description
+   * @param the marker location
+   * @return true in case of success.
+   */
+  private boolean createNewPoint(String name, String description, Location location,
+      String marker) {
+    Log.d(MyTracksConstants.TAG, "Creating a new row with a point.");
+    String query = "INSERT INTO " + tableId + " (name,description,geometry,marker) VALUES "
+        + values(name, description, getKmlPoint(location), marker);
+    return runUpdate(query);
+  }
+
+  /**
+   * Creates a new row representing a line segment.
+   *
+   * @param track the track/segment to draw
+   * @return true in case of success.
+   */
+  private boolean createNewLineString(Track track) {
+    Log.d(MyTracksConstants.TAG, "Creating a new row with a point.");
+    String query = "INSERT INTO " + tableId
+        + " (name,description,geometry) VALUES "
+        + values(track.getName(), track.getDescription(), getKmlLineString(track));
+    return runUpdate(query);
+  }
+
+  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);
+      Location lastLocation = null;
+      do {
+        if (totalLocationsRead % 100 == 0) {
+          updateTrackDataUploadProgress();
+        }
+
+        Location loc = providerUtils.createLocation(locationsCursor);
+        locations.add(loc);
+
+        if (totalLocationsRead == 0) {
+          // Put a marker at the first point of the first valid segment:
+          String name = track.getName() + " " + context.getString(R.string.start);
+          createNewPoint(name, "", loc, MARKER_TYPE_START);
+        }
+
+        // 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>");
+        String name = track.getName() + " " + context.getString(R.string.end);
+        return createNewPoint(name, track.getDescription(), lastLocation, MARKER_TYPE_END);
+      }
+
+      return true;
+    } finally {
+      locationsCursor.close();
+    }
+  }
+
+  /**
+   * Appends the given location to the string in the format:
+   * longitude,latitude[,altitude]
+   *
+   * @param location the location to be added
+   * @param builder the string builder to use
+   */
+  private void appendCoordinate(Location location, StringBuilder builder) {
+    builder
+        .append(location.getLongitude())
+        .append(",")
+        .append(location.getLatitude());
+    if (location.hasAltitude()) {
+      builder.append(",");
+      builder.append(location.getAltitude());
+    }
+  }
+
+  /**
+   * Gets a KML Point tag for the given location.
+   *
+   * @param location The location.
+   * @return the kml.
+   */
+  private String getKmlPoint(Location location) {
+  	StringBuilder builder = new StringBuilder("<Point><coordinates>");
+  	appendCoordinate(location, builder);
+  	builder.append("</coordinates></Point>");
+  	return builder.toString();
+  }
+
+  /**
+   * Returns a KML Point tag for the given location.
+   *
+   * @param location The location.
+   * @return the kml.
+   */
+  private String getKmlLineString(Track track) {
+    StringBuilder builder = new StringBuilder("<LineString><coordinates>");
+    for (Location location : track.getLocations()) {
+      appendCoordinate(location, builder);
+      builder.append(' ');
+    }
+    builder.append("</coordinates></LineString>");
+    return builder.toString();
+  }
+
+  private boolean prepareAndUploadPoints(Track track, List<Location> locations) {
+    updateTrackDataUploadProgress();
+
+    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
+    for (Track splitTrack : splitTracks) {
+      if (totalSegmentsUploaded > 1) {
+        splitTrack.setName(splitTrack.getName() + " "
+            + String.format(
+                context.getString(R.string.part), totalSegmentsUploaded));
+      }
+      totalSegmentsUploaded++;
+      Log.d(MyTracksConstants.TAG,
+          "SendToFusionTables: Prepared feature for upload w/ "
+          + splitTrack.getLocations().size() + " points.");
+
+      // Transmit tracks via GData feed:
+      // -------------------------------
+      Log.d(MyTracksConstants.TAG,
+            "SendToFusionTables: Uploading to table " + tableId + " w/ auth " + auth);
+      if (!uploadTrackPoints(splitTrack)) {
+        Log.e(MyTracksConstants.TAG, "Uploading failed");
+        return false;
+      }
+    }
+
+    locations.clear();
+    totalLocationsUploaded += numLocations;
+    updateTrackDataUploadProgress();
+    return true;
+  }
+
+  /**
+   * Prepares a buffer of locations for transmission to google fusion tables.
+   *
+   * @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) {
+        updateTrackDataUploadProgress();
+      }
+      if (loc.getLatitude() > 90) {
+        startNewTrackSegment = true;
+      }
+
+      if (startNewTrackSegment) {
+        // Close up the last segment.
+        prepareTrackSegment(segment, splitTracks);
+
+        Log.d(MyTracksConstants.TAG,
+            "MyTracksSendToFusionTables: 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 fusion tables.
+   * 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. Fusion tables doesn't like too many
+     * points:
+     */
+    MyTracksUtils.decimate(segment, 2.0);
+
+    /* If the track still has > 2500 points, split it in pieces: */
+    final int maxPoints = 2500;
+    if (segment.getLocations().size() > maxPoints) {
+      splitTracks.addAll(MyTracksUtils.split(segment, maxPoints));
+    } else if (segment.getLocations().size() >= 2) {
+      splitTracks.add(segment);
+    }
+  }
+
+  private boolean uploadTrackPoints(Track splitTrack) {
+    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;
+    }
+    return createNewLineString(splitTrack);
+  }
+
+  /**
+   * Uploads all of the waypoints associated with this track to a table.
+   *
+   * @param track The track to upload waypoints for.
+   *
+   * @return True on success.
+   */
+  private boolean uploadWaypoints(final Track track) {
+    // TODO: Stream through the 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.
+  	boolean success = true;
+    Cursor c = null;
+    try {
+      c = providerUtils.getWaypointsCursor(
+          track.getId(), 0,
+          MyTracksConstants.MAX_LOADED_WAYPOINTS_POINTS);
+      if (c != null) {
+        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);
+            Log.d(MyTracksConstants.TAG, "SendToFusionTables: Creating waypoint.");
+            success = createNewPoint(wpt.getName(), wpt.getDescription(), wpt.getLocation(),
+            		MARKER_TYPE_WAYPOINT);
+            if (!success) {
+            	break;
+            }
+          }
+        }
+      }
+      if (!success) {
+        Log.w(MyTracksConstants.TAG, "SendToFusionTables: upload waypoints failed.");
+      }
+      return success;
+    } finally {
+      if (c != null) {
+        c.close();
+      }
+    }
+  }
+
+  private void updateTrackDataUploadProgress() {
+    // The percent of the total that represents the completed part of this
+    // segment.  We calculate it as an absolute percentage, and then scale it
+    // to fit the completion percentage range alloted to track data upload.
+    double totalPercentage =
+        (totalLocationsRead + totalLocationsPrepared + totalLocationsUploaded)
+        / (totalLocations * 3);
+    
+    double scaledPercentage = totalPercentage 
+        * (PROGRESS_UPLOAD_DATA_MAX - PROGRESS_UPLOAD_DATA_MIN) + PROGRESS_UPLOAD_DATA_MIN;
+
+    progressIndicator.setProgressValue((int) scaledPercentage);
+  }
+
+  /**
+   * Runs an update query. Handles authentication.
+   *
+   * @param query The given SQL like query
+   * @return true in case of success
+   */
+  private boolean runUpdate(final String query) {
+    GDataWrapper<HttpTransport> wrapper = new GDataWrapper<HttpTransport>();
+    wrapper.setAuthManager(auth);
+    wrapper.setRetryOnAuthFailure(true);
+    wrapper.setClient(transport);
+    Log.d(MyTracksConstants.TAG, "GData connection prepared: " + this.auth);
+    wrapper.runQuery(new QueryFunction<HttpTransport>() {
+      @Override
+      public void query(HttpTransport client)
+          throws IOException, GDataWrapper.ParseException, GDataWrapper.HttpException,
+          GDataWrapper.AuthenticationException {
+        HttpRequest request = transport.buildPostRequest();
+        request.headers.contentType = "application/x-www-form-urlencoded";
+        GenericUrl url = new GenericUrl(FUSIONTABLES_BASE_FEED_URL);
+        request.url = url;
+        InputStreamContent isc = new InputStreamContent();
+        String sql = "sql=" + URLEncoder.encode(query, "UTF-8");
+        isc.inputStream = new ByteArrayInputStream(Strings.toBytesUtf8(sql));
+        request.content = isc;
+
+        Log.d(MyTracksConstants.TAG, "Running update query " + url.toString() + ": " + sql);
+        HttpResponse response;
+        try {
+          response = request.execute();
+        } catch (HttpResponseException e) {
+          throw new GDataWrapper.HttpException(e.response.statusCode, e.response.statusMessage);
+        }
+        boolean success = response.isSuccessStatusCode;
+        if (success) {
+          byte[] result = new byte[1024];
+          response.getContent().read(result);
+          String s = Strings.fromBytesUtf8(result);
+          String[] lines = s.split(Strings.LINE_SEPARATOR);
+          if (lines[0].equals("tableid")) {
+            tableId = lines[1];
+            Log.d(MyTracksConstants.TAG, "tableId = " + tableId);
+          } else {
+            Log.w(MyTracksConstants.TAG, "Unrecognized response: " + lines[0]);
+          }
+        } else {
+          Log.d(MyTracksConstants.TAG, "Query failed: " + response.statusMessage + " (" +
+              response.statusCode + ")");
+          throw new GDataWrapper.HttpException(response.statusCode, response.statusMessage);
+        }
+      }
+    });
+    return wrapper.getErrorType() == GDataWrapper.ERROR_NO_ERROR;
+  }
+}

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

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2010 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.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.Sensor.SensorDataSet;
+import com.google.android.apps.mytracks.io.TrackWriterFactory.TrackFileFormat;
+
+import android.location.Location;
+import android.os.Build;
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.nio.charset.Charset;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+/**
+ * Write out a a track in the Garmin training center database, tcx format.
+ * As defined by:
+ * http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2
+ *
+ * @author Sandor Dornbush
+ */
+public class TcxTrackWriter implements TrackFormatWriter {
+
+  private PrintWriter pw = null;
+  private Track track;
+
+  static final SimpleDateFormat TIMESTAMP_FORMAT =
+      new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+  static {
+    TIMESTAMP_FORMAT.setTimeZone(TimeZone.getTimeZone("UTC"));
+  }
+
+  public TcxTrackWriter() {
+  }
+
+  @Override
+  public void prepare(Track track, OutputStream out) {
+    this.track = track;
+    this.pw = new PrintWriter(out);
+
+  }
+
+  @Override
+  public void close() {
+    if (pw != null) {
+      pw.close();
+      pw = null;
+    }
+  }
+
+  @Override
+  public String getExtension() {
+    return TrackFileFormat.TCX.getExtension();
+  }
+
+  @Override
+  public void writeHeader() {
+    if (pw == null) {
+      return;
+    }
+    pw.format("<?xml version=\"1.0\" encoding=\"%s\" standalone=\"no\" ?>\n",
+        Charset.defaultCharset().name());
+    pw.print("<TrainingCenterDatabase ");
+    pw.print("xmlns=\"http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2\" ");
+    pw.print("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" ");
+    pw.print("xsi:schemaLocation=\"http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2 ");
+    pw.println("http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd\">");
+    pw.println();
+  }
+
+  @Override
+  public void writeBeginTrack(Location firstPoint) {
+    if (pw == null) {
+      return;
+    }
+    pw.println("  <Activities>");
+    pw.print("    <Activity Sport=\"");
+    if (track.getCategory() != null) {
+      pw.print(track.getCategory());
+    }
+    pw.println("\">");
+    pw.print("      <Id>");
+    pw.print(TIMESTAMP_FORMAT.format(track.getStatistics().getStartTime()));
+    pw.println("</Id>");
+    pw.println("      <Lap>");
+    pw.print("        <TotalTimeSeconds>");
+    pw.print(track.getStatistics().getTotalTime() / 1000);
+    pw.println("</TotalTimeSeconds>");
+    pw.print("        <DistanceMeters>");
+    pw.print(track.getStatistics().getTotalDistance());
+    pw.println("</DistanceMeters>");
+    // TODO max speed etc.
+    // Calories are a required element just put in 0.
+    pw.print("<Calories>0</Calories>");
+    pw.println("<Intensity>Active</Intensity>");
+    pw.println("<TriggerMethod>Manual</TriggerMethod>)");
+  }
+
+  @Override
+  public void writeOpenSegment() {
+    if (pw != null) {
+      pw.println("      <Track>");
+    }
+  }
+
+  @Override
+  public void writeLocation(Location location) {
+    if (pw == null) {
+      return;
+    }
+    pw.println("        <Trackpoint>");
+    Date d = new Date(location.getTime());
+    pw.println("          <Time>" + TIMESTAMP_FORMAT.format(d) + "</Time>");
+    pw.println("          <Position>");
+
+    pw.print("            <LatitudeDegrees>");
+    pw.print(location.getLatitude());
+    pw.println("</LatitudeDegrees>");
+
+    pw.print("            <LongitudeDegrees>");
+    pw.print(location.getLongitude());
+    pw.println("</LongitudeDegrees>");
+
+    pw.println("          </Position>");
+    pw.print("          <AltitudeMeters>");
+    pw.print(location.getAltitude());
+    pw.println("</AltitudeMeters>");
+
+    if (location instanceof MyTracksLocation) {
+      SensorDataSet sensorData = ((MyTracksLocation) location).getSensorDataSet();
+      if (sensorData != null) {
+        if (sensorData.hasHeartRate()
+            && sensorData.getHeartRate().getState() == Sensor.SensorState.SENDING
+            && sensorData.getHeartRate().hasValue()) {
+          pw.print("          <HeartRateBpm>");
+          pw.print("<Value>");
+          pw.print(sensorData.getHeartRate().getValue());
+          pw.print("</Value>");
+          pw.println("</HeartRateBpm>");
+        }
+        if (sensorData.hasPower()
+            && sensorData.getPower().getState() == Sensor.SensorState.SENDING
+            && sensorData.getPower().hasValue()) {
+          pw.print("          <Extensions>");
+          pw.print("<TPX xmlns=\"http://www.garmin.com/xmlschemas/ActivityExtension/v2\">");
+          pw.print("<Watts>");
+          pw.print(sensorData.getPower().getValue());
+          pw.print("</Watts>");
+          pw.println("</TPX></Extensions>");
+        }
+        if (sensorData.hasCadence()
+            && sensorData.getCadence().getState() == Sensor.SensorState.SENDING
+            && sensorData.getCadence().hasValue()) {
+          pw.print("          <Cadence>");
+          pw.print(sensorData.getCadence().getValue());
+          pw.println("</Cadence>");
+        }
+      }
+    }
+    pw.println("        </Trackpoint>");
+  }
+
+  @Override
+  public void writeCloseSegment() {
+    if (pw != null) {
+      pw.println("      </Track>");
+    }
+  }
+
+  @Override
+  public void writeEndTrack(Location lastPoint) {
+    if (pw == null) {
+      return;
+    }
+    pw.println("      </Lap>");
+    pw.print("      <Creator xsi:type=\"Device_t\">");
+    pw.print("<Name>");
+    pw.print(Build.MODEL);
+    pw.print("</Name>");
+    pw.println("</Creator>)");
+    pw.println("    </Activity>");
+    pw.println("  </Activities>");
+  }
+
+  @Override
+  public void writeFooter() {
+    if (pw == null) {
+      return;
+    }
+    pw.print("  <Author xsi:type=\"Application_t\">");
+    pw.print("<Name>My Tracks by Google</Name>");
+    pw.println("</Author>");
+    pw.println("</TrainingCenterDatabase>");
+  }
+
+  @Override
+  public void writeWaypoint(Waypoint waypoint) {
+    // TODO Write out the waypoints somewhere.
+  }
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010 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 android.os.Environment;
+
+import java.io.File;
+
+/**
+ * A class to clean up old temporary files.
+ * @author Sandor Dornbush
+ */
+public class TempFileCleaner {
+  
+  private long currentTimeMillis;
+
+  public static void clean() {
+    (new TempFileCleaner(System.currentTimeMillis())).cleanImpl();
+  }
+  
+  // @VisibleForTesting
+  TempFileCleaner(long time) {
+    currentTimeMillis = time;
+  }
+  
+  private void cleanImpl() {
+    if (!Environment.getExternalStorageState().equals(
+        Environment.MEDIA_MOUNTED)) {
+      return;  // Can't do anything now.
+    }
+    cleanTmpDirectory("csv");
+    cleanTmpDirectory("gpx");
+    cleanTmpDirectory("kml");
+    cleanTmpDirectory("tcx");
+  }
+
+  private void cleanTmpDirectory(String name) {
+    String sep = System.getProperty("file.separator");
+    cleanTmpDirectory(
+        new File(
+            Environment.getExternalStorageDirectory() + sep + name + sep
+            + "tmp"));
+  }
+
+  // @VisibleForTesting
+  int cleanTmpDirectory(File dir) {
+    if (!dir.exists()) {
+      return 0;
+    }
+    int count = 0;
+    long oldest = currentTimeMillis - 1000 * 3600;
+    for (File f : dir.listFiles()) {
+      if (f.lastModified() < oldest) {
+        f.delete();
+        count++;
+      }
+    }
+    return count;
+  }
+}

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2010 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.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+
+import android.location.Location;
+
+import java.io.OutputStream;
+
+/**
+ * Interface for writing data to a specific track file format.
+ *
+ * The expected sequence of calls is:
+ * <ol>
+ *   <li>{@link #prepare}
+ *   <li>{@link #writeHeader}
+ *   <li>{@link #writeBeginTrack}
+ *   <li>For each segment:
+ *   <ol>
+ *     <li>{@link #writeOpenSegment}
+ *     <li>For each location in the segment: {@link #writeLocation}
+ *     <li>{@link #writeCloseSegment}
+ *   </ol>
+ *   <li>{@link #writeEndTrack}
+ *   <li>For each waypoint: {@link #writeWaypoint}
+ *   <li>{@link #writeFooter}
+ * </ol>
+ *
+ * @author Rodrigo Damazio
+ */
+public interface TrackFormatWriter {
+
+  /**
+   * Sets up the writer to write the given track to the given output.
+   *
+   * @param track the track to write
+   * @param out the stream to write the track contents to
+   */
+  void prepare(Track track, OutputStream out);
+
+  /**
+   * @return The file extentsion (i.e. gpx, kml, ...)
+   */
+  String getExtension();
+
+  /**
+   * Writes the header.
+   * This is chance for classes to write out opening information.
+   */
+  void writeHeader();
+
+  /**
+   * Writes the footer.
+   * This is chance for classes to write out closing information.
+   */
+  void writeFooter();
+
+  /**
+   * Write the given location object.
+   *
+   * TODO Add some flexible handling of other sensor data.
+   *
+   * @param location the location to write
+   */
+  void writeLocation(Location location);
+
+  /**
+   * Write a way point.
+   *
+   * @param waypoint
+   */
+  void writeWaypoint(Waypoint waypoint);
+
+  /**
+   * Write the beginning of a track.
+   */
+  void writeBeginTrack(Location firstPoint);
+
+  /**
+   * Write the end of a track.
+   */
+  void writeEndTrack(Location lastPoint);
+
+  /**
+   * Write the statements necessary to open a new segment.
+   */
+  void writeOpenSegment();
+
+  /**
+   * Write the statements necessary to close a segment.
+   */
+  void writeCloseSegment();
+
+  /**
+   * Close the underlying file handle.
+   */
+  void close();
+}

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

@@ -0,0 +1,346 @@
+/*
+ * 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.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+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.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.MyTracksUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.content.Context;
+import android.database.Cursor;
+import android.location.Location;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+/**
+ * The class which exports tracks to the SD card.
+ * This writer is format-neutral - it handles creating the output file
+ * and reading the track to be exported, but requires an instance of
+ * {@link TrackFormatWriter} to actually format the data.
+ *
+ * @author Sandor Dornbush
+ * @author Rodrigo Damazio
+ */
+public class TrackWriter {
+
+  private final Context context;
+  private final MyTracksProviderUtils providerUtils;
+  private final Track track;
+  private final TrackFormatWriter writer;
+  private final FileUtils fileUtils;
+  private Runnable onCompletion = null;
+  private boolean success = false;
+  private int errorMessage = -1;
+  private File directory = null;
+  private File file = null;
+
+  public TrackWriter(Context context, MyTracksProviderUtils providerUtils,
+      Track track, TrackFormatWriter writer) {
+    this.context = context;
+    this.providerUtils = providerUtils;
+    this.track = track;
+    this.writer = writer;
+    this.fileUtils = new FileUtils();
+  }
+
+  /**
+   * Sets a completion callback.
+   *
+   * @param onCompletion Runnable that will be executed when finished
+   */
+  public void setOnCompletion(Runnable onCompletion) {
+    this.onCompletion = onCompletion;
+  }
+
+  /**
+   * Sets a custom directory where the file will be written.
+   */
+  public void setDirectory(File directory) {
+    this.directory = directory;
+  }
+
+  public String getAbsolutePath() {
+    return file.getAbsolutePath();
+  }
+
+  /**
+   * Writes the given track id to the SD card.
+   * This is non-blocking.
+   */
+  public void writeTrackAsync() {
+    Thread t = new Thread() {
+      @Override
+      public void run() {
+        writeTrack();
+      }
+    };
+    t.start();
+  }
+
+  /**
+   * Writes the given track id to the SD card.
+   * This is blocking.
+   */
+  public void writeTrack() {
+    // Open the input and output
+    success = false;
+    errorMessage = R.string.error_track_does_not_exist;
+    if (track != null) {
+      if (openFile()) {
+        writeDocument();
+      }
+    }
+    finished();
+  }
+
+  public int getErrorMessage() {
+    return errorMessage;
+  }
+
+  public boolean wasSuccess() {
+    return success;
+  }
+
+  /*
+   * Helper methods:
+   * ===============
+   */
+
+  private void finished() {
+    if (onCompletion != null) {
+      runOnUiThread(onCompletion);
+      return;
+    }
+  }
+
+  /**
+   * Runs the given runnable in the UI thread.
+   */
+  protected void runOnUiThread(Runnable runnable) {
+    if (context instanceof Activity) {
+      ((Activity) context).runOnUiThread(runnable);
+    }
+  }
+
+  /**
+   * Opens the file and prepares the format writer for it. 
+   * 
+   * @return true on success, false otherwise (and errorMessage is set)
+   */
+  protected boolean openFile() {
+    if (!canWriteFile()) {
+      return false;
+    }
+
+    // Make sure the file doesn't exist yet (possibly by changing the filename)
+    String fileName = fileUtils.buildUniqueFileName(
+        directory, track.getName(), writer.getExtension());
+    if (fileName == null) {
+      Log.e(MyTracksConstants.TAG,
+          "Unable to get a unique filename for " + fileName);
+      return false;
+    }
+
+    Log.i(MyTracksConstants.TAG, "Writing track to: " + fileName);
+    try {
+      writer.prepare(track, newOutputStream(fileName));
+    } catch (FileNotFoundException e) {
+      Log.e(MyTracksConstants.TAG, "Failed to open output file.", e);
+      errorMessage = R.string.io_write_failed;
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Checks and returns whether we're ready to create the output file.
+   */
+  protected boolean canWriteFile() {
+    if (directory == null) {
+      String dirName =
+          fileUtils.buildExternalDirectoryPath(writer.getExtension());
+      directory = newFile(dirName);
+    }
+
+    if (!fileUtils.isSdCardAvailable()) {
+      Log.i(MyTracksConstants.TAG, "Could not find SD card.");
+      errorMessage = R.string.io_no_external_storage_found;
+      return false;
+    }
+    if (!fileUtils.ensureDirectoryExists(directory)) {
+      Log.i(MyTracksConstants.TAG, "Could not create export directory.");
+      errorMessage = R.string.io_create_dir_failed;
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Creates a new output stream to write to the given filename.
+   *
+   * @throws FileNotFoundException if the file could't be created
+   */
+  protected OutputStream newOutputStream(String fileName)
+      throws FileNotFoundException {
+    file = new File(directory, fileName);
+    return new FileOutputStream(file);
+  }
+
+  /**
+   * Creates a new file object for the given path.
+   */
+  protected File newFile(String path) {
+    return new File(path);
+  }
+
+  /**
+   * Writes the waypoints for the given track.
+   *
+   * @param trackId the ID of the track to write waypoints for
+   */
+  private void writeWaypoints(long trackId) {
+    // 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 cursor = null;
+    cursor = providerUtils.getWaypointsCursor(trackId, 0,
+        MyTracksConstants.MAX_LOADED_WAYPOINTS_POINTS);
+    if (cursor != null) {
+      try {
+        if (cursor.moveToFirst()) {
+          // Yes, this will skip the 1st way point and that is intentional
+          // as the 1st points holds the stats for the current/last segment.
+          while (cursor.moveToNext()) {
+            Waypoint wpt = providerUtils.createWaypoint(cursor);
+            writer.writeWaypoint(wpt);
+          }
+        }
+      } finally {
+        if (cursor != null) {
+          cursor.close();
+        }
+      }
+    }
+  }
+
+  /**
+   * Does the actual work of writing the track to the now open file.
+   */
+  void writeDocument() {
+    Log.d(MyTracksConstants.TAG, "Started writing track.");
+    writer.writeHeader();
+    writeWaypoints(track.getId());
+    writeLocations();
+    writer.writeFooter();
+    writer.close();
+    success = true;
+    Log.d(MyTracksConstants.TAG, "Done writing track.");
+    errorMessage = R.string.io_write_finished;
+  }
+
+  private void writeLocations() {
+    boolean wroteFirst = false;
+    boolean segmentOpen = false;
+    boolean isLastValid = false;
+    
+    class TrackWriterLocationFactory implements MyTracksProviderUtils.LocationFactory {
+      Location currentLocation;
+      Location lastLocation;
+        
+      @Override
+      public Location createLocation() {
+        if (currentLocation == null) {
+          currentLocation = new MyTracksLocation("");
+        }
+        return currentLocation;
+      }
+      
+      public void swapLocations() {
+        Location tmpLoc = lastLocation;
+        lastLocation = currentLocation;
+        currentLocation = tmpLoc;
+        if (currentLocation != null) {
+          currentLocation.reset();
+        }
+      }
+    };
+    
+    TrackWriterLocationFactory locationFactory = new TrackWriterLocationFactory();
+    LocationIterator it = providerUtils.getLocationIterator(track.getId(), 0, false,
+        locationFactory);
+    try {
+      if (!it.hasNext()) {
+        Log.w(MyTracksConstants.TAG, "Unable to get any points to write");
+        return;
+      }
+      while (it.hasNext()) {
+        Location loc = it.next();
+  
+        boolean isValid = MyTracksUtils.isValidLocation(loc);
+        boolean validSegment = isValid && isLastValid;
+        if (!wroteFirst && validSegment) {
+          // Found the first two consecutive points which are valid
+          writer.writeBeginTrack(locationFactory.lastLocation);
+          wroteFirst = true;
+        }
+  
+        if (validSegment) {
+          if (!segmentOpen) {
+            // Start a segment for this point
+            writer.writeOpenSegment();
+            segmentOpen = true;
+  
+            // Write the previous point, which we had previously skipped
+            writer.writeLocation(locationFactory.lastLocation);
+          }
+  
+          // Write the current point
+          writer.writeLocation(loc);
+        } else {
+          if (segmentOpen) {
+            writer.writeCloseSegment();
+            segmentOpen = false;
+          }
+        }
+  
+        locationFactory.swapLocations();
+        isLastValid = isValid;
+      }
+      if (segmentOpen) {
+        writer.writeCloseSegment();
+        segmentOpen = false;
+      }
+      if (wroteFirst) {
+        writer.writeEndTrack(locationFactory.lastLocation);
+      }
+    } finally {
+      it.close();
+    }
+  }
+}

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

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2010 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.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+
+import android.content.Context;
+
+/**
+ * A factory to produce track writers for any format.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TrackWriterFactory {
+
+  /**
+   * Definition of all possible track formats.
+   */
+  public enum TrackFileFormat {
+    GPX {
+      @Override
+      TrackFormatWriter newFormatWriter(Context context) {
+        return new GpxTrackWriter();
+      }
+    },
+    KML {
+      @Override
+      TrackFormatWriter newFormatWriter(Context context) {
+        return new KmlTrackWriter(context);
+      }
+    },
+    CSV {
+      @Override
+      public TrackFormatWriter newFormatWriter(Context context) {
+        return new CsvTrackWriter();
+      }
+    },
+    TCX {
+      @Override
+      public TrackFormatWriter newFormatWriter(Context context) {
+        return new TcxTrackWriter();
+      }
+    };
+
+    /**
+     * Creates and returns a new format writer for each format.
+     */
+    abstract TrackFormatWriter newFormatWriter(Context context);
+
+    /**
+     * Returns the mime type for each format.
+     */
+    public String getMimeType() {
+      return "application/" + getExtension() + "+xml";
+    }
+
+    /**
+     * Returns the file extension for each format.
+     */
+    public String getExtension() {
+      return this.name().toLowerCase();
+    }
+  }
+
+  /**
+   * Creates a new track writer to write the track with the given ID.
+   *
+   * @param context the context in which the track will be read
+   * @param providerUtils the data provider utils to read the track with
+   * @param trackId the ID of the track to be written
+   * @param format the output format to write in
+   * @return the new track writer
+   */
+  public static TrackWriter newWriter(Context context,
+      MyTracksProviderUtils providerUtils,
+      long trackId, TrackFileFormat format) {
+    Track track = providerUtils.getTrack(trackId);
+    return newWriter(context, providerUtils, track, format);
+  }
+
+  /**
+   * Creates a new track writer to write the given track.
+   *
+   * @param context the context in which the track will be read
+   * @param providerUtils the data provider utils to read the track with
+   * @param track the track to be written
+   * @param format the output format to write in
+   * @return the new track writer
+   */
+  private static TrackWriter newWriter(Context context,
+      MyTracksProviderUtils providerUtils,
+      Track track, TrackFileFormat format) {
+    TrackFormatWriter writer = format.newFormatWriter(context);
+    return new TrackWriter(context, providerUtils, track, writer);
+  }
+
+  private TrackWriterFactory() { }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/BackupActivityHelper.java

@@ -0,0 +1,247 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.MyTracks;
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.AlertDialog.Builder;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.util.Log;
+import android.widget.Toast;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Date;
+
+/**
+ * Helper which shows a UI for writing or restoring a backup,
+ * and calls the appropriate handler for actually executing those
+ * operations.
+ *
+ * @author Rodrigo Damazio
+ */
+public class BackupActivityHelper {
+
+  // Since the user sees this format, we use the local timezone
+  private static final SimpleDateFormat DISPLAY_BACKUP_FORMAT =
+      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+  private static final Comparator<Date> REVERSE_DATE_ORDER =
+      new Comparator<Date>() {
+        @Override
+        public int compare(Date s1, Date s2) {
+          return s2.compareTo(s1);
+        }
+      };
+
+  private final FileUtils fileUtils;
+  private final ExternalFileBackup backup;
+  private final Activity activity;
+
+  public BackupActivityHelper(Activity activity) {
+    this.activity = activity;
+    this.fileUtils = new FileUtils();
+    this.backup = new ExternalFileBackup(activity, fileUtils);
+  }
+
+  /**
+   * Writes a full backup to the default file.
+   * This shows the results to the user.
+   */
+  public void writeBackup() {
+    if (!fileUtils.isSdCardAvailable()) {
+      showToast(R.string.io_no_external_storage_found);
+      return;
+    }
+
+    if (!backup.isBackupsDirectoryAvailable(true)) {
+      showToast(R.string.io_create_dir_failed);
+      return;
+    }
+
+    final ProgressDialog progressDialog = ProgressDialog.show(
+        activity,
+        activity.getString(R.string.progress_title),
+        activity.getString(R.string.backup_write_progress_message),
+        true);
+
+    // Do the writing in another thread
+    new Thread() {
+      @Override
+      public void run() {
+        try {
+          backup.writeToDefaultFile();
+          showToast(R.string.io_write_finished);
+        } catch (IOException e) {
+          Log.e(MyTracksConstants.TAG, "Failed to write backup", e);
+          showToast(R.string.io_write_failed);
+        } finally {
+          dismissDialog(progressDialog);
+        }
+      }
+    }.start();
+  }
+
+  /**
+   * Restores a full backup from the SD card.
+   * The user will be given a choice of which backup to restore as well as a
+   * confirmation dialog.
+   */
+  public void restoreBackup() {
+    // Get the list of existing backups
+    if (!fileUtils.isSdCardAvailable()) {
+      showToast(R.string.io_no_external_storage_found);
+      return;
+    }
+
+    if (!backup.isBackupsDirectoryAvailable(false)) {
+      showToast(R.string.no_backups);
+      return;
+    }
+
+    final Date[] backupDates = backup.getAvailableBackups();
+    if (backupDates == null || backupDates.length == 0) {
+      showToast(R.string.no_backups);
+      return;
+    }
+    Arrays.sort(backupDates, REVERSE_DATE_ORDER);
+
+    // Show a confirmation dialog
+    Builder confirmationDialogBuilder = new AlertDialog.Builder(activity);
+    confirmationDialogBuilder.setMessage(R.string.restore_overwrites_warning);
+    confirmationDialogBuilder.setCancelable(true);
+    confirmationDialogBuilder.setPositiveButton(android.R.string.yes,
+        new OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int which) {
+            pickBackupForRestore(backupDates);
+          }
+        });
+    confirmationDialogBuilder.setNegativeButton(android.R.string.no, null);
+    confirmationDialogBuilder.create().show();
+  }
+
+  /**
+   * Shows a backup list for the user to pick, then restores it.
+   *
+   * @param backupDir the backup directory
+   * @param backupDates the list of available backup files
+   */
+  private void pickBackupForRestore(final Date[] backupDates) {
+    if (backupDates.length == 1) {
+      // Only one choice, don't bother showing the list
+      restoreFromDateAsync(backupDates[0]);
+      return;
+    }
+
+    // Make a user-visible version of the backup filenames
+    final String backupDateStrs[] = new String[backupDates.length];
+    for (int i = 0; i < backupDates.length; i++) {
+      backupDateStrs[i] = DISPLAY_BACKUP_FORMAT.format(backupDates[i]);
+    }
+
+    // Show a dialog for the user to pick which backup to restore
+    Builder dialogBuilder = new AlertDialog.Builder(activity);
+    dialogBuilder.setCancelable(true);
+    dialogBuilder.setTitle(R.string.select_backup_to_restore);
+    dialogBuilder.setItems(backupDateStrs, new OnClickListener() {
+      @Override
+      public void onClick(DialogInterface dialog, int which) {
+        // User picked to restore this one
+        restoreFromDateAsync(backupDates[which]);
+      }
+    });
+    dialogBuilder.create().show();
+  }
+
+  /**
+   * Shows a progress dialog, then starts restoring the backup osynchronously.
+   *
+   * @param inputFile the file to restore from
+   */
+  private void restoreFromDateAsync(final Date date) {
+    // Show a progress dialog
+    final ProgressDialog progressDialog = ProgressDialog.show(
+        activity,
+        activity.getString(R.string.progress_title),
+        activity.getString(R.string.backup_import_progress_message),
+        true);
+
+    // Do the actual importing in another thread (don't block the UI)
+    new Thread() {
+      @Override
+      public void run() {
+        try {
+          backup.restoreFromDate(date);
+          showToast(R.string.io_read_finished);
+        } catch (IOException e) {
+          Log.e(MyTracksConstants.TAG, "Failed to restore backup", e);
+          showToast(R.string.io_read_failed);
+        } finally {
+          dismissDialog(progressDialog);
+
+          // Data may have been restored, "reboot" the app to catch it
+          restartApplication();
+        }
+      }
+    }.start();
+  }
+
+  /**
+   * Restarts My Tracks completely.
+   * This forces any modified data to be re-read.
+   */
+  private void restartApplication() {
+    Intent intent = new Intent(activity, MyTracks.class);
+    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+    activity.startActivity(intent);
+  }
+
+  /**
+   * Shows a toast with the given contents.
+   */
+  private void showToast(final int resId) {
+    activity.runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        Toast.makeText(activity, resId, Toast.LENGTH_LONG).show();
+      }
+    });
+  }
+
+  /**
+   * Safely dismisses the given dialog.
+   */
+  private void dismissDialog(final Dialog dialog) {
+    activity.runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        dialog.dismiss();
+      }
+    });
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/BackupColumns.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010 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.backup;
+
+import static com.google.android.apps.mytracks.content.ContentTypeIds.*;
+import com.google.android.apps.mytracks.content.TrackPointsColumns;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.content.WaypointsColumns;
+
+public class BackupColumns {
+  /** Columns that go into the backup. */
+  public static final String[] POINTS_BACKUP_COLUMNS =
+      { TrackPointsColumns._ID, TrackPointsColumns.TRACKID, TrackPointsColumns.LATITUDE,
+        TrackPointsColumns.LONGITUDE, TrackPointsColumns.ALTITUDE, TrackPointsColumns.BEARING,
+        TrackPointsColumns.TIME, TrackPointsColumns.ACCURACY, TrackPointsColumns.SPEED,
+        TrackPointsColumns.SENSOR };
+  public static final byte[] POINTS_BACKUP_COLUMN_TYPES =
+      { LONG_TYPE_ID, LONG_TYPE_ID, INT_TYPE_ID, INT_TYPE_ID, FLOAT_TYPE_ID,
+        FLOAT_TYPE_ID, LONG_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID, BLOB_TYPE_ID };
+
+  public static final String[] TRACKS_BACKUP_COLUMNS = {
+      TracksColumns._ID, TracksColumns.NAME, TracksColumns.DESCRIPTION, TracksColumns.CATEGORY,
+      TracksColumns.STARTID, TracksColumns.STOPID, TracksColumns.STARTTIME, TracksColumns.STOPTIME,
+      TracksColumns.NUMPOINTS, TracksColumns.TOTALDISTANCE, TracksColumns.TOTALTIME,
+      TracksColumns.MOVINGTIME, TracksColumns.AVGSPEED, TracksColumns.AVGMOVINGSPEED,
+      TracksColumns.MAXSPEED, TracksColumns.MINELEVATION, TracksColumns.MAXELEVATION,
+      TracksColumns.ELEVATIONGAIN, TracksColumns.MINGRADE, TracksColumns.MAXGRADE,
+      TracksColumns.MINLAT, TracksColumns.MAXLAT, TracksColumns.MINLON, TracksColumns.MAXLON,
+      TracksColumns.MAPID, TracksColumns.TABLEID};
+  public static final byte[] TRACKS_BACKUP_COLUMN_TYPES = {
+      LONG_TYPE_ID, STRING_TYPE_ID, STRING_TYPE_ID, STRING_TYPE_ID,
+      LONG_TYPE_ID, LONG_TYPE_ID, LONG_TYPE_ID, LONG_TYPE_ID, INT_TYPE_ID,
+      FLOAT_TYPE_ID, LONG_TYPE_ID, LONG_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID,
+      FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID,
+      FLOAT_TYPE_ID, INT_TYPE_ID, INT_TYPE_ID, INT_TYPE_ID, INT_TYPE_ID, STRING_TYPE_ID,
+      STRING_TYPE_ID};
+
+  public static final String[] WAYPOINTS_BACKUP_COLUMNS = {
+      WaypointsColumns._ID, WaypointsColumns.TRACKID, WaypointsColumns.NAME,
+      WaypointsColumns.DESCRIPTION, WaypointsColumns.CATEGORY, WaypointsColumns.ICON,
+      WaypointsColumns.TYPE, WaypointsColumns.LENGTH, WaypointsColumns.DURATION,
+      WaypointsColumns.STARTTIME, WaypointsColumns.STARTID, WaypointsColumns.STOPID,
+      WaypointsColumns.LATITUDE, WaypointsColumns.LONGITUDE, WaypointsColumns.ALTITUDE,
+      WaypointsColumns.BEARING, WaypointsColumns.TIME, WaypointsColumns.ACCURACY,
+      WaypointsColumns.SPEED, WaypointsColumns.TOTALDISTANCE, WaypointsColumns.TOTALTIME,
+      WaypointsColumns.MOVINGTIME, WaypointsColumns.AVGSPEED, WaypointsColumns.AVGMOVINGSPEED,
+      WaypointsColumns.MAXSPEED, WaypointsColumns.MINELEVATION, WaypointsColumns.MAXELEVATION,
+      WaypointsColumns.ELEVATIONGAIN, WaypointsColumns.MINGRADE, WaypointsColumns.MAXGRADE };
+  public static final byte[] WAYPOINTS_BACKUP_COLUMN_TYPES = {
+      LONG_TYPE_ID, LONG_TYPE_ID, STRING_TYPE_ID, STRING_TYPE_ID,
+      STRING_TYPE_ID, STRING_TYPE_ID, INT_TYPE_ID, FLOAT_TYPE_ID, LONG_TYPE_ID,
+      LONG_TYPE_ID, LONG_TYPE_ID, LONG_TYPE_ID, INT_TYPE_ID, INT_TYPE_ID,
+      FLOAT_TYPE_ID, FLOAT_TYPE_ID, LONG_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID,
+      FLOAT_TYPE_ID, LONG_TYPE_ID, LONG_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID,
+      FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID, FLOAT_TYPE_ID,
+      FLOAT_TYPE_ID };
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/BackupPreferencesListener.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.util.ApiFeatures;
+
+import android.app.backup.BackupManager;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+
+/**
+ * Shared preferences listener which notifies the backup system about new data
+ * being available for backup.
+ * This class is API-version-safe and will provide a dummy implementation if
+ * the device doesn't support backup services.
+ *
+ * @author Rodrigo Damazio
+ */
+public abstract class BackupPreferencesListener
+    implements OnSharedPreferenceChangeListener {
+
+  /**
+   * Real implementation of the listener, which calls the {@link BackupManager}.
+   */
+  private static class BackupPreferencesListenerImpl
+      extends BackupPreferencesListener {
+    private final BackupManager backupManager;
+
+    public BackupPreferencesListenerImpl(Context context) {
+      this.backupManager = new BackupManager(context);
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(
+        SharedPreferences sharedPreferences, String key) {
+      backupManager.dataChanged();
+    }
+  }
+
+  /**
+   * Dummy implementation of the listener which does nothing.
+   */
+  private static class DummyBackupPreferencesListener
+      extends BackupPreferencesListener {
+    @Override
+    public void onSharedPreferenceChanged(
+        SharedPreferences sharedPreferences, String key) {
+      // Do nothing
+    }
+  }
+
+  /**
+   * Creates and returns a proper instance of the listener for this device.
+   */
+  public static BackupPreferencesListener create(
+      Context context, ApiFeatures apiFeatures) {
+    if (apiFeatures.hasBackup()) {
+      return new BackupPreferencesListenerImpl(context);
+    } else {
+      return new DummyBackupPreferencesListener();
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/DatabaseDumper.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.content.ContentTypeIds;
+
+import android.database.Cursor;
+import android.database.MergeCursor;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+/**
+ * Database dumper which is able to write only part of the database
+ * according to some query.
+ *
+ * This dumper is symmetrical to {@link DatabaseImporter}.
+ *
+ * @author Rodrigo Damazio
+ */
+class DatabaseDumper {
+
+  /** The names of the columns being dumped. */
+  private final String[] columnNames;
+  /** The types of the columns being dumped. */
+  private final byte[] columnTypes;
+  /** Whether to output null fields. */
+  private final boolean outputNullFields;
+
+  // Temporary state
+  private int[] columnIndices;
+  private boolean[] hasFields;
+
+  public DatabaseDumper(String[] columnNames, byte[] columnTypes,
+      boolean outputNullFields) {
+    if (columnNames.length != columnTypes.length) {
+      throw new IllegalArgumentException("Names don't match types");
+    }
+
+    this.columnNames = columnNames;
+    this.columnTypes = columnTypes;
+    this.outputNullFields = outputNullFields;
+  }
+
+  /**
+   * Writes the header plus all rows that can be read from the given cursor.
+   * This assumes the cursor will have the same column and column indices on
+   * every row (and thus may not work with a {@link MergeCursor}).
+   */
+  public void writeAllRows(Cursor cursor, DataOutputStream writer)
+      throws IOException {
+    writeHeaders(cursor, cursor.getCount(), writer);
+
+    if (!cursor.moveToFirst()) {
+      return;
+    }
+
+    do {
+      writeOneRow(cursor, writer);
+    } while (cursor.moveToNext());
+  }
+
+  /**
+   * Writes just the headers for the data that will come from the given cursor.
+   * The headers include column information and the number of rows that will be
+   * written.
+   *
+   * @param cursor the cursor to get columns from
+   * @param numRows the number of rows that will be later written
+   * @throws IOException if there are errors while writing
+   */
+  public void writeHeaders(Cursor cursor, int numRows, DataOutputStream writer)
+      throws IOException {
+    initializeCachedValues(cursor);
+    writeQueryMetadata(cursor, numRows, writer);
+  }
+
+  /**
+   * Writes the current row from the cursor. The cursor is not advanced.
+   * This must be called after {@link #writeHeaders}.
+   *
+   * @param cursor the cursor to write data from
+   * @throws IOException if there are any errors while writing
+   */
+  public void writeOneRow(Cursor cursor, DataOutputStream writer)
+      throws IOException {
+    if (columnIndices == null) {
+      throw new IllegalStateException(
+          "Cannot write rows before writing the header");
+    }
+
+    if (columnIndices.length > Long.SIZE) {
+      throw new IllegalArgumentException("Too many fields");
+    }
+
+    // Build a bitmap of which fields are present
+    long fields = 0;
+    for (int i = 0; i < columnIndices.length; i++) {
+      hasFields[i] = !cursor.isNull(columnIndices[i]);
+      fields |= (hasFields[i] ? 1 : 0) << i;
+    }
+    writer.writeLong(fields);
+
+    // Actually write the present fields
+    for (int i = 0; i < columnIndices.length; i++) {
+      if (hasFields[i]) {
+        writeCell(columnIndices[i], columnTypes[i], cursor, writer);
+      } else if (outputNullFields) {
+        writeDummyCell(columnTypes[i], writer);
+      }
+    }
+  }
+
+  /**
+   * Initializes the column indices and other temporary state for reading from
+   * the given cursor.
+   */
+  private void initializeCachedValues(Cursor cursor) {
+    // These indices are constant for every row (unless we're fed a MergeCursor)
+    if (cursor instanceof MergeCursor) {
+      throw new IllegalArgumentException("Cannot use a MergeCursor");
+    }
+
+    columnIndices = new int[columnNames.length];
+    for (int i = 0; i < columnNames.length; i++) {
+      String columnName = columnNames[i];
+      columnIndices[i] = cursor.getColumnIndexOrThrow(columnName);
+    }
+
+    hasFields = new boolean[columnIndices.length];
+  }
+
+  /**
+   * Writes metadata about the query to be dumped.
+   *
+   * @param cursor the cursor that the data will come from
+   * @param numRows the number of rows that will be dumped
+   * @throws IOException if there are any errors while writing
+   */
+  private void writeQueryMetadata(
+      Cursor cursor, int numRows, DataOutputStream writer) throws IOException {
+    // Write column data
+    writer.writeInt(columnNames.length);
+    for (int i = 0; i < columnNames.length; i++) {
+      String columnName = columnNames[i];
+      byte columnType = columnTypes[i];
+      writer.writeUTF(columnName);
+      writer.writeByte(columnType);
+    }
+
+    // Write the number of rows
+    writer.writeInt(numRows);
+  }
+
+  /**
+   * Writes a single cell of the database to the output.
+   *
+   * @param columnIdx the column index to read from
+   * @param columnTypeId the type of the column to be read
+   * @param cursor the cursor to read from
+   * @throws IOException if there are any errors while writing
+   */
+  private void writeCell(
+      int columnIdx, byte columnTypeId, Cursor cursor, DataOutputStream writer)
+      throws IOException {
+    switch (columnTypeId) {
+      case ContentTypeIds.LONG_TYPE_ID:
+        writer.writeLong(cursor.getLong(columnIdx));
+        return;
+      case ContentTypeIds.DOUBLE_TYPE_ID:
+        writer.writeDouble(cursor.getDouble(columnIdx));
+        return;
+      case ContentTypeIds.FLOAT_TYPE_ID:
+        writer.writeFloat(cursor.getFloat(columnIdx));
+        return;
+      case ContentTypeIds.BOOLEAN_TYPE_ID:
+        writer.writeBoolean(cursor.getInt(columnIdx) != 0);
+        return;
+      case ContentTypeIds.INT_TYPE_ID:
+        writer.writeInt(cursor.getInt(columnIdx));
+        return;
+      case ContentTypeIds.STRING_TYPE_ID:
+        writer.writeUTF(cursor.getString(columnIdx));
+        return;
+      case ContentTypeIds.BLOB_TYPE_ID: {
+        byte[] blob = cursor.getBlob(columnIdx);
+        writer.writeInt(blob.length);
+        writer.write(blob);
+        return;
+      }
+      default:
+        throw new IllegalArgumentException(
+            "Type " + columnTypeId + " not supported");
+    }
+  }
+
+  /**
+   * Writes a dummy cell value to the output.
+   *
+   * @param columnTypeId the type of the value to write
+   * @throws IOException if there are any errors while writing
+   */
+  private void writeDummyCell(byte columnTypeId, DataOutputStream writer)
+      throws IOException {
+    switch (columnTypeId) {
+      case ContentTypeIds.LONG_TYPE_ID:
+        writer.writeLong(0L);
+        return;
+      case ContentTypeIds.DOUBLE_TYPE_ID:
+        writer.writeDouble(0.0);
+        return;
+      case ContentTypeIds.FLOAT_TYPE_ID:
+        writer.writeFloat(0.0f);
+        return;
+      case ContentTypeIds.BOOLEAN_TYPE_ID:
+        writer.writeBoolean(false);
+        return;
+      case ContentTypeIds.INT_TYPE_ID:
+        writer.writeInt(0);
+        return;
+      case ContentTypeIds.STRING_TYPE_ID:
+        writer.writeUTF("");
+        return;
+      case ContentTypeIds.BLOB_TYPE_ID:
+        writer.writeInt(0);
+        return;
+      default:
+        throw new IllegalArgumentException(
+            "Type " + columnTypeId + " not supported");
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/DatabaseImporter.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.content.ContentTypeIds;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.net.Uri;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+
+/**
+ * Database importer which reads values written by {@link DatabaseDumper}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class DatabaseImporter {
+
+  /** Maximum number of entries in a bulk insertion */
+  private static final int DEFAULT_BULK_SIZE = 1024;
+
+  private final Uri destinationUri;
+  private final ContentResolver resolver;
+  private final boolean readNullFields;
+  private final int bulkSize;
+
+  // Metadata read from the reader
+  private String[] columnNames;
+  private byte[] columnTypes;
+
+  public DatabaseImporter(Uri destinationUri, ContentResolver resolver,
+      boolean readNullFields) {
+    this(destinationUri, resolver, readNullFields, DEFAULT_BULK_SIZE);
+  }
+
+  protected DatabaseImporter(Uri destinationUri, ContentResolver resolver,
+      boolean readNullFields, int bulkSize) {
+    this.destinationUri = destinationUri;
+    this.resolver = resolver;
+    this.readNullFields = readNullFields;
+    this.bulkSize = bulkSize;
+  }
+
+  /**
+   * Reads the header which includes metadata about the table being imported.
+   *
+   * @throws IOException if there are any problems while reading
+   */
+  private void readHeaders(DataInputStream reader) throws IOException {
+    int numColumns = reader.readInt();
+    columnNames = new String[numColumns];
+    columnTypes = new byte[numColumns];
+    for (int i = 0; i < numColumns; i++) {
+      columnNames[i] = reader.readUTF();
+      columnTypes[i] = reader.readByte();
+    }
+  }
+
+  /**
+   * Imports all rows from the reader into the database.
+   * Insertion is done in bulks for efficiency.
+   *
+   * @throws IOException if there are any errors while reading
+   */
+  public void importAllRows(DataInputStream reader) throws IOException {
+    readHeaders(reader);
+
+    ContentValues[] valueBulk = new ContentValues[bulkSize];
+    int numValues = 0;
+
+    int numRows = reader.readInt();
+    int numColumns = columnNames.length;
+
+    // For each row
+    for (int r = 0; r < numRows; r++) {
+      if (valueBulk[numValues] == null) {
+        valueBulk[numValues] = new ContentValues(numColumns);
+      } else {
+        // Reuse values objects
+        valueBulk[numValues].clear();
+      }
+
+      // Read the fields bitmap
+      long fields = reader.readLong();
+      for (int c = 0; c < numColumns; c++) {
+        if ((fields & 1) == 1) {
+          // Field is present, read into values
+          readOneCell(columnNames[c], columnTypes[c], valueBulk[numValues],
+              reader);
+        } else if (readNullFields) {
+          // Field not present but still written, read and discard
+          readOneCell(columnNames[c], columnTypes[c], null, reader);
+        }
+
+        fields >>= 1;
+      }
+
+      numValues++;
+
+      // If we have enough values, flush them as a bulk insertion
+      if (numValues >= bulkSize) {
+        doBulkInsert(valueBulk);
+        numValues = 0;
+      }
+    }
+
+    // Do a final bulk insert with the leftovers
+    if (numValues > 0) {
+      ContentValues[] leftovers = new ContentValues[numValues];
+      System.arraycopy(valueBulk, 0, leftovers, 0, numValues);
+      doBulkInsert(leftovers);
+    }
+  }
+
+  protected void doBulkInsert(ContentValues[] values) {
+    resolver.bulkInsert(destinationUri, values);
+  }
+
+  /**
+   * Reads a single cell from the reader.
+   *
+   * @param name the name of the column to be read
+   * @param typeId the type ID of the column to be read
+   * @param values the {@link ContentValues} object to put the read cell value
+   *        in - if null, the value is just discarded
+   * @throws IOException if there are any problems while reading
+   */
+  private void readOneCell(String name, byte typeId, ContentValues values,
+      DataInputStream reader) throws IOException {
+    switch (typeId) {
+      case ContentTypeIds.BOOLEAN_TYPE_ID: {
+        boolean value = reader.readBoolean();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.LONG_TYPE_ID: {
+        long value = reader.readLong();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.DOUBLE_TYPE_ID: {
+        double value = reader.readDouble();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.FLOAT_TYPE_ID: {
+        Float value = reader.readFloat();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.INT_TYPE_ID: {
+        int value = reader.readInt();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.STRING_TYPE_ID: {
+        String value = reader.readUTF();
+        if (values != null) { values.put(name, value); }
+        return;
+      }
+      case ContentTypeIds.BLOB_TYPE_ID: {
+        int blobLength = reader.readInt();
+        if (blobLength != 0) {
+          byte[] blob = new byte[blobLength];
+          int readBytes = reader.read(blob, 0, blobLength);
+          if (readBytes != blobLength) {
+            throw new IOException(String.format(
+                "Short read on column %s; expected %d bytes, read %d",
+                name, blobLength, readBytes));
+          }
+          
+          if (values != null) {
+            values.put(name, blob);
+          }
+        }
+        return;
+      }
+      default:
+        throw new IOException("Read unknown type " + typeId);
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/ExternalFileBackup.java

@@ -0,0 +1,263 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.TrackPointsColumns;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.content.WaypointsColumns;
+import com.google.android.apps.mytracks.util.FileUtils;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.util.Log;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.TimeZone;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Handler for writing or reading single-file backups.
+ *
+ * @author Rodrigo Damazio
+ */
+class ExternalFileBackup {
+  // Filename format - in UTC
+  private static final SimpleDateFormat BACKUP_FILENAME_FORMAT =
+      new SimpleDateFormat("'backup-'yyyy-MM-dd_HH-mm-ss'.zip'");
+  static {
+    BACKUP_FILENAME_FORMAT.setTimeZone(TimeZone.getTimeZone("UTC"));
+  }
+
+  private static final String BACKUPS_SUBDIR = "backups";
+  private static final int BACKUP_FORMAT_VERSION = 1;
+  private static final String ZIP_ENTRY_NAME =
+      "backup.mytracks.v" + BACKUP_FORMAT_VERSION;
+  private static final int COMPRESSION_LEVEL = 8;
+
+  private final Context context;
+  private final FileUtils fileUtils;
+
+  public ExternalFileBackup(Context context, FileUtils fileUtils) {
+    this.context = context;
+    this.fileUtils = fileUtils;
+  }
+
+  /**
+   * Returns whether the backups directory is (or can be made) available.
+   *
+   * @param create whether to try creating the directory if it doesn't exist
+   */
+  public boolean isBackupsDirectoryAvailable(boolean create) {
+    return getBackupsDirectory(create) != null;
+  }
+
+  /**
+   * Returns the backup directory, or null if not available.
+   *
+   * @param create whether to try creating the directory if it doesn't exist
+   */
+  private File getBackupsDirectory(boolean create) {
+    String dirName = fileUtils.buildExternalDirectoryPath(BACKUPS_SUBDIR);
+    final File dir = new File(dirName);
+    Log.d(MyTracksConstants.TAG, "Dir: " + dir.getAbsolutePath());
+    if (create) {
+      // Try to create - if that fails, return null
+      return fileUtils.ensureDirectoryExists(dir) ? dir : null;
+    } else {
+      // Return it if it already exists, otherwise return null
+      return dir.isDirectory() ? dir : null;
+    }
+  }
+
+  /**
+   * Returns a list of available backups to be restored.
+   */
+  public Date[] getAvailableBackups() {
+    File dir = getBackupsDirectory(false);
+    if (dir == null) { return null; }
+    String[] fileNames = dir.list();
+
+    List<Date> backupDates = new ArrayList<Date>(fileNames.length);
+    for (int i = 0; i < fileNames.length; i++) {
+      String fileName = fileNames[i];
+      try {
+        backupDates.add(BACKUP_FILENAME_FORMAT.parse(fileName));
+      } catch (ParseException e) {
+        // Not a backup file, ignore
+      }
+    }
+
+    return backupDates.toArray(new Date[backupDates.size()]);
+  }
+
+  /**
+   * Writes the backup to the default file.
+   */
+  public void writeToDefaultFile() throws IOException {
+    writeToFile(getFileForDate(new Date()));
+  }
+
+  /**
+   * Restores the backup from the given date.
+   */
+  public void restoreFromDate(Date when) throws IOException {
+    restoreFromFile(getFileForDate(when));
+  }
+
+  /**
+   * Produces the proper file descriptor for the given backup date.
+   */
+  private File getFileForDate(Date when) {
+    File dir = getBackupsDirectory(false);
+    String fileName = BACKUP_FILENAME_FORMAT.format(when);
+    File file = new File(dir, fileName);
+    return file;
+  }
+
+  /**
+   * Synchronously writes a backup to the given file.
+   */
+  private void writeToFile(File outputFile) throws IOException {
+    Log.d(MyTracksConstants.TAG,
+        "Writing backup to file " + outputFile.getAbsolutePath());
+
+    // Create all the auxiliary classes that will do the writing
+    PreferenceBackupHelper preferencesHelper = new PreferenceBackupHelper();
+    DatabaseDumper trackDumper = new DatabaseDumper(
+        BackupColumns.TRACKS_BACKUP_COLUMNS,
+        BackupColumns.TRACKS_BACKUP_COLUMN_TYPES,
+        false);
+    DatabaseDumper waypointDumper = new DatabaseDumper(
+        BackupColumns.WAYPOINTS_BACKUP_COLUMNS,
+        BackupColumns.WAYPOINTS_BACKUP_COLUMN_TYPES,
+        false);
+    DatabaseDumper pointDumper = new DatabaseDumper(
+        BackupColumns.POINTS_BACKUP_COLUMNS,
+        BackupColumns.POINTS_BACKUP_COLUMN_TYPES,
+        false);
+
+    // Open the target for writing
+    FileOutputStream outputStream = new FileOutputStream(outputFile);
+    ZipOutputStream compressedStream = new ZipOutputStream(outputStream);
+    compressedStream.setLevel(COMPRESSION_LEVEL);
+    compressedStream.putNextEntry(new ZipEntry(ZIP_ENTRY_NAME));
+    DataOutputStream outWriter = new DataOutputStream(compressedStream);
+
+    try {
+      // Dump the entire contents of each table
+      ContentResolver contentResolver = context.getContentResolver();
+      Cursor tracksCursor = contentResolver.query(
+          TracksColumns.CONTENT_URI, null, null, null, null);
+      try {
+        trackDumper.writeAllRows(tracksCursor, outWriter);
+      } finally {
+        tracksCursor.close();
+      }
+
+      Cursor waypointsCursor = contentResolver.query(
+          WaypointsColumns.CONTENT_URI, null, null, null, null);
+      try {
+        waypointDumper.writeAllRows(waypointsCursor, outWriter);
+      } finally {
+        waypointsCursor.close();
+      }
+
+      Cursor pointsCursor = contentResolver.query(
+          TrackPointsColumns.CONTENT_URI, null, null, null, null);
+      try {
+        pointDumper.writeAllRows(pointsCursor, outWriter);
+      } finally {
+        pointsCursor.close();
+      }
+
+      // Dump preferences
+      SharedPreferences preferences =
+          context.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
+      preferencesHelper.exportPreferences(preferences, outWriter);
+    } catch (IOException e) {
+      // We tried to delete the partially created file, but do nothing
+      // if that also fails.
+      outputFile.delete();
+
+      throw e;
+    } finally {
+      compressedStream.closeEntry();
+      compressedStream.close();
+    }
+  }
+
+  /**
+   * Synchronously restores the backup from the given file.
+   */
+  private void restoreFromFile(File inputFile) throws IOException {
+    Log.d(MyTracksConstants.TAG,
+        "Restoring from file " + inputFile.getAbsolutePath());
+
+    PreferenceBackupHelper preferencesHelper = new PreferenceBackupHelper();
+    ContentResolver resolver = context.getContentResolver();
+    DatabaseImporter trackImporter =
+        new DatabaseImporter(TracksColumns.CONTENT_URI, resolver, false);
+    DatabaseImporter waypointImporter =
+        new DatabaseImporter(WaypointsColumns.CONTENT_URI, resolver, false);
+    DatabaseImporter pointImporter =
+        new DatabaseImporter(TrackPointsColumns.CONTENT_URI, resolver, false);
+
+    ZipFile zipFile = new ZipFile(inputFile, ZipFile.OPEN_READ);
+    ZipEntry zipEntry = zipFile.getEntry(ZIP_ENTRY_NAME);
+    if (zipEntry == null) {
+      throw new IOException("Invalid backup ZIP file");
+    }
+
+    InputStream compressedStream = zipFile.getInputStream(zipEntry);
+    DataInputStream reader = new DataInputStream(compressedStream);
+
+    try {
+      // Delete all previous contents of the tables and preferences.
+      resolver.delete(TracksColumns.CONTENT_URI, null, null);
+      resolver.delete(TrackPointsColumns.CONTENT_URI, null, null);
+      resolver.delete(WaypointsColumns.CONTENT_URI, null, null);
+
+      // Import the new contents of each table
+      trackImporter.importAllRows(reader);
+      waypointImporter.importAllRows(reader);
+      pointImporter.importAllRows(reader);
+
+      // Restore preferences
+      SharedPreferences preferences =
+          context.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
+      preferencesHelper.importPreferences(reader, preferences);
+    } finally {
+      compressedStream.close();
+      zipFile.close();
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/MyTracksBackupAgent.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+
+import android.app.backup.BackupAgent;
+import android.app.backup.BackupDataInput;
+import android.app.backup.BackupDataOutput;
+import android.content.SharedPreferences;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import java.io.IOException;
+
+/**
+ * Backup agent used to backup and restore all preferences.
+ * We use a regular {@link BackupAgent} instead of the convenient helpers in
+ * order to be future-proof (assuming we'll want to back up tracks later).
+ * 
+ * @author Rodrigo Damazio
+ */
+public class MyTracksBackupAgent extends BackupAgent {
+  private static final String PREFERENCES_ENTITY = "prefs";
+
+  @Override
+  public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
+      ParcelFileDescriptor newState) throws IOException {
+    Log.i(MyTracksConstants.TAG, "Performing backup");
+    SharedPreferences preferences = this.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+
+    backupPreferences(data, preferences);
+    Log.i(MyTracksConstants.TAG, "Backup complete");
+  }
+
+  private void backupPreferences(BackupDataOutput data,
+      SharedPreferences preferences) throws IOException {
+    PreferenceBackupHelper preferenceDumper = createPreferenceBackupHelper();
+    byte[] dumpedContents = preferenceDumper.exportPreferences(preferences);
+    data.writeEntityHeader(PREFERENCES_ENTITY, dumpedContents.length);
+    data.writeEntityData(dumpedContents, dumpedContents.length);
+  }
+
+  protected PreferenceBackupHelper createPreferenceBackupHelper() {
+    return new PreferenceBackupHelper();
+  }
+
+  @Override
+  public void onRestore(BackupDataInput data, int appVersionCode,
+      ParcelFileDescriptor newState) throws IOException {
+    Log.i(MyTracksConstants.TAG, "Restoring from backup");
+    while (data.readNextHeader()) {
+      String key = data.getKey();
+      Log.d(MyTracksConstants.TAG, "Restoring entity " + key);
+      if (key.equals(PREFERENCES_ENTITY)) {
+        restorePreferences(data);
+      } else {
+        Log.e(MyTracksConstants.TAG, "Found unknown backup entity: " + key);
+        data.skipEntityData();
+      }
+    }
+    Log.i(MyTracksConstants.TAG, "Done restoring from backup");
+  }
+
+  /**
+   * Restores all preferences from the backup.
+   * 
+   * @param data the backup data to read from
+   * @throws IOException if there are any errors while reading
+   */
+  private void restorePreferences(BackupDataInput data) throws IOException {
+    int dataSize = data.getDataSize();
+    byte[] dataBuffer = new byte[dataSize];
+    int read = data.readEntityData(dataBuffer, 0, dataSize);
+    if (read != dataSize) {
+      throw new IOException("Failed to read all the preferences data");
+    }
+
+    SharedPreferences preferences = this.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    PreferenceBackupHelper importer = createPreferenceBackupHelper();
+    importer.importPreferences(dataBuffer, preferences);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/backup/PreferenceBackupHelper.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.content.ContentTypeIds;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Helper for backing up and restoring shared preferences.
+ *
+ * @author Rodrigo Damazio
+ */
+class PreferenceBackupHelper {
+
+  private static final int BUFFER_SIZE = 2048;
+
+  /**
+   * Exports all shared preferences from the given object as a byte array.
+   *
+   * @param preferences the preferences to export
+   * @return the corresponding byte array
+   * @throws IOException if there are any errors while writing to the byte array
+   */
+  public byte[] exportPreferences(SharedPreferences preferences)
+      throws IOException {
+    ByteArrayOutputStream bufStream = new ByteArrayOutputStream(BUFFER_SIZE);
+    DataOutputStream outWriter = new DataOutputStream(bufStream);
+    exportPreferences(preferences, outWriter);
+
+    return bufStream.toByteArray();
+  }
+
+  /**
+   * Exports all shared preferences from the given object into the given output
+   * stream.
+   *
+   * @param preferences the preferences to export
+   * @param outWriter the stream to write them to
+   * @throws IOException if there are any errors while writing the output
+   */
+  public void exportPreferences(
+      SharedPreferences preferences,
+      DataOutputStream outWriter) throws IOException {
+    Map<String, ?> values = preferences.getAll();
+
+    outWriter.writeInt(values.size());
+    for (Map.Entry<String, ?> entry : values.entrySet()) {
+      writePreference(entry.getKey(), entry.getValue(), outWriter);
+    }
+    outWriter.flush();
+  }
+
+  /**
+   * Imports all preferences from the given byte array.
+   *
+   * @param data the byte array to read preferences from
+   * @param preferences the shared preferences to edit
+   * @return whether the preference change was successful
+   * @throws IOException if there are any errors while reading
+   */
+  public boolean importPreferences(byte[] data, SharedPreferences preferences)
+      throws IOException {
+    ByteArrayInputStream bufStream = new ByteArrayInputStream(data);
+    DataInputStream reader = new DataInputStream(bufStream);
+
+    return importPreferences(reader, preferences);
+  }
+
+  /**
+   * Imports all preferences from the given stream.
+   *
+   * @param reader the stream to read from
+   * @param preferences the shared preferences to edit
+   * @return whether the preference change was successful
+   * @throws IOException if there are any errors while reading
+   */
+  public boolean importPreferences(DataInputStream reader,
+      SharedPreferences preferences) throws IOException {
+    Editor editor = preferences.edit();
+    editor.clear();
+
+    int numPreferences = reader.readInt();
+    for (int i = 0; i < numPreferences; i++) {
+      String name = reader.readUTF();
+      byte typeId = reader.readByte();
+      readAndSetPreference(name, typeId, reader, editor);
+    }
+
+    return editor.commit();
+  }
+
+  /**
+   * Reads a single preference and sets it into the given editor.
+   *
+   * @param name the name of the preference to read
+   * @param typeId the type ID of the preference to read
+   * @param reader the reader to read from
+   * @param editor the editor to set the preference in
+   * @throws IOException if there are errors while reading
+   */
+  private void readAndSetPreference(String name, byte typeId,
+      DataInputStream reader, Editor editor) throws IOException {
+    switch (typeId) {
+      case ContentTypeIds.BOOLEAN_TYPE_ID:
+        editor.putBoolean(name, reader.readBoolean());
+        return;
+      case ContentTypeIds.LONG_TYPE_ID:
+        editor.putLong(name, reader.readLong());
+        return;
+      case ContentTypeIds.FLOAT_TYPE_ID:
+        editor.putFloat(name, reader.readFloat());
+        return;
+      case ContentTypeIds.INT_TYPE_ID:
+        editor.putInt(name, reader.readInt());
+        return;
+      case ContentTypeIds.STRING_TYPE_ID:
+        editor.putString(name, reader.readUTF());
+        return;
+    }
+  }
+
+  /**
+   * Writes a single preference.
+   *
+   * @param name the name of the preference to write
+   * @param value the correctly-typed value of the preference
+   * @param writer the writer to write to
+   * @throws IOException if there are errors while writing
+   */
+  private void writePreference(String name, Object value, DataOutputStream writer)
+      throws IOException {
+    writer.writeUTF(name);
+
+    if (value instanceof Boolean) {
+      writer.writeByte(ContentTypeIds.BOOLEAN_TYPE_ID);
+      writer.writeBoolean((Boolean) value);
+    } else if (value instanceof Integer) {
+      writer.writeByte(ContentTypeIds.INT_TYPE_ID);
+      writer.writeInt((Integer) value);
+    } else if (value instanceof Long) {
+      writer.writeByte(ContentTypeIds.LONG_TYPE_ID);
+      writer.writeLong((Long) value);
+    } else if (value instanceof Float) {
+      writer.writeByte(ContentTypeIds.FLOAT_TYPE_ID);
+      writer.writeFloat((Float) value);
+    } else if (value instanceof String) {
+      writer.writeByte(ContentTypeIds.STRING_TYPE_ID);
+      writer.writeUTF((String) value);
+    } else {
+      throw new IllegalArgumentException(
+          "Type " + value.getClass().getName() + " not supported");
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/docs/DocsHelper.java

@@ -0,0 +1,372 @@
+/*
+ * Copyright 2010 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.docs;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.AuthManager;
+import com.google.android.apps.mytracks.io.gdata.GDataWrapper;
+import com.google.android.apps.mytracks.io.gdata.GDataWrapper.QueryFunction;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.ResourceUtils;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.wireless.gdata.client.GDataServiceClient;
+import com.google.wireless.gdata.client.HttpException;
+import com.google.wireless.gdata.data.Entry;
+import com.google.wireless.gdata.docs.SpreadsheetsClient;
+import com.google.wireless.gdata.docs.SpreadsheetsClient.WorksheetEntry;
+import com.google.wireless.gdata.parser.GDataParser;
+import com.google.wireless.gdata.parser.ParseException;
+import com.google.wireless.gdata2.client.AuthenticationException;
+
+import android.content.Context;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * This class contains helper methods for interacting with Google Docs and
+ * Google Spreadsheets.
+ *
+ * @author Sandor Dornbush
+ * @author Matthew Simmons
+ */
+public class DocsHelper {
+  private static final String DOCS_FEED_URL =
+    "http://docs.google.com/feeds/documents/private/full";
+  private static final String DOCS_SPREADSHEET_URL =
+      "http://docs.google.com/feeds/documents/private/full/spreadsheet%3A";
+  private static final String DOCS_WORKSHEETS_URL_FORMAT =
+    "http://spreadsheets.google.com/feeds/worksheets/%s/private/full";
+  private static final String DOCS_MY_SPREADSHEETS_FEED_URL =
+    "http://docs.google.com/feeds/documents/private/full?category=mine,spreadsheet";
+  private static final String DOCS_SPREADSHEET_URL_FORMAT =
+    "http://spreadsheets.google.com/feeds/list/%s/%s/private/full";
+
+  private static final String CONTENT_TYPE_PARAM = "Content-Type";
+  private static final String OPENDOCUMENT_SPREADSHEET_MIME_TYPE =
+      "application/x-vnd.oasis.opendocument.spreadsheet";
+  private static final String ATOM_FEED_MIME_TYPE = "application/atom+xml";
+  
+  /**
+   * Creates a new MyTracks spreadsheet with the given name.
+   * 
+   * @param context The context associated with this request.
+   * @param docListWrapper The GData handle for the Document List service.
+   * @param name The name for the newly-created spreadsheet.
+   * @return The spreadsheet ID, if one is created.  {@code null} will be
+   *     returned if a GData error didn't occur, but no spreadsheet ID was
+   *     returned. 
+   */
+  public String createSpreadsheet(final Context context, 
+      final GDataWrapper<GDataServiceClient> docListWrapper, final String name) throws IOException {
+    final AtomicReference<String> idSaver = new AtomicReference<String>();
+
+    boolean result = docListWrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client) throws IOException,
+          GDataWrapper.AuthenticationException {
+        // Construct and send request
+        URL url = new URL(DOCS_FEED_URL);
+        URLConnection conn = url.openConnection();
+        conn.addRequestProperty(CONTENT_TYPE_PARAM,
+            OPENDOCUMENT_SPREADSHEET_MIME_TYPE);
+        conn.addRequestProperty("Slug", name);
+        conn.addRequestProperty("Authorization",
+            "GoogleLogin auth=" + 
+            docListWrapper.getAuthManager().getAuthToken());
+        conn.setDoOutput(true);
+        OutputStream os = conn.getOutputStream();
+        ResourceUtils.readBinaryFileToOutputStream(
+            context, R.raw.mytracks_empty_spreadsheet, os);
+
+        // Get the response
+        // TODO: The following is a horrible ugly hack.
+        //       Hopefully we can retire it when there is a proper gdata api.
+        BufferedReader rd = null;
+        String line;
+        StringBuilder resultBuilder = new StringBuilder();
+        try {
+          rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+          while ((line = rd.readLine()) != null) {
+            resultBuilder.append(line);
+          }
+          os.close();
+          rd.close();
+        } catch (FileNotFoundException e) {
+          // The GData API sometimes throws an error, even though creation of
+          // the document succeeded. In that case let's just return. The caller
+          // then needs to check if the doc actually exists.
+          return;
+        } finally {
+          os.close();
+          if (rd != null) {
+            rd.close();
+          }
+        }
+
+        String result = resultBuilder.toString();
+        // Try to find the id.
+        int idTagIndex = result.indexOf("<id>");
+        if (idTagIndex == -1) {
+          return;
+        }
+        int idTagCloseIndex = result.indexOf("</id>", idTagIndex);
+        if (idTagCloseIndex == -1) {
+          return;
+        }
+        int idStringStart = result.indexOf(DOCS_SPREADSHEET_URL, idTagIndex);
+        if (idStringStart == -1) {
+          return;
+        }
+        
+        String id = result.substring(
+            idStringStart + DOCS_SPREADSHEET_URL.length(), idTagCloseIndex);
+        Log.i(MyTracksConstants.TAG, "Created new spreadsheet: " + id);
+        idSaver.set(id);
+      }});
+    
+    if (!result) {
+      throw newIOException(docListWrapper, 
+          "Failed to create new spreadsheet.");
+    }
+    
+    return idSaver.get();
+  }
+
+  /**
+   * Retrieve the ID of a spreadsheet with the given name.
+   * 
+   * @param docListWrapper The GData handle for the Document List service.
+   * @param title The name of the spreadsheet whose ID is to be retrieved.
+   * @return The spreadsheet ID, if it can be retrieved.  {@code null} will
+   *     be returned if no spreadsheet exists by the given name.
+   * @throws IOException If an error occurs during the GData request.
+   */
+  public String requestSpreadsheetId(final GDataWrapper<GDataServiceClient> docListWrapper,
+      final String title) throws IOException {
+    final AtomicReference<String> idSaver = new AtomicReference<String>();
+
+    boolean result = docListWrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client)
+          throws IOException, GDataWrapper.ParseException, GDataWrapper.HttpException,
+          GDataWrapper.AuthenticationException {
+        GDataParser listParser;
+        try {
+          listParser = client.getParserForFeed(Entry.class,
+              DOCS_MY_SPREADSHEETS_FEED_URL, 
+              docListWrapper.getAuthManager().getAuthToken());
+          listParser.init();
+
+          while (listParser.hasMoreData()) {
+            Entry entry = listParser.readNextEntry(null);
+            String entryTitle = entry.getTitle();
+            Log.i(MyTracksConstants.TAG, "Found docs entry: " + entryTitle);
+            if (entryTitle.equals(title)) {
+              String entryId = entry.getId();
+              int lastSlash = entryId.lastIndexOf('/');
+              idSaver.set(entryId.substring(lastSlash + 15));
+              break;
+            }
+          }
+        } catch (ParseException e) {
+          throw new GDataWrapper.ParseException(e);
+        } catch (HttpException e) {
+          throw new GDataWrapper.HttpException(e.getStatusCode(), e.getMessage());
+        }
+      }
+    });
+
+    if (!result) {
+      throw newIOException(docListWrapper, 
+          "Failed to retrieve spreadsheet list.");
+    }
+    
+    return idSaver.get();
+  }
+
+  /**
+   * Retrieve the ID of the first worksheet in the named spreadsheet.
+   * 
+   * @param trixWrapper The GData handle for the spreadsheet service.
+   * @param spreadsheetId The GData ID for the given spreadsheet.
+   * @return The worksheet ID, if it can be retrieved.  {@code null} will be
+   *     returned if the GData request returns without error, but without an
+   *     ID.
+   * @throws IOException If an error occurs during the GData request. 
+   */
+  public String getWorksheetId(final GDataWrapper<GDataServiceClient> trixWrapper,
+      final String spreadsheetId) throws IOException {
+    final AtomicReference<String> idSaver = new AtomicReference<String>();
+
+    boolean result = trixWrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client)
+          throws GDataWrapper.AuthenticationException, IOException, GDataWrapper.ParseException, GDataWrapper.HttpException {
+        String uri = String.format(DOCS_WORKSHEETS_URL_FORMAT, spreadsheetId);
+        GDataParser sheetParser;
+        try {
+          sheetParser = ((SpreadsheetsClient) client).getParserForWorksheetsFeed(uri,
+              trixWrapper.getAuthManager().getAuthToken());
+          sheetParser.init();
+          if (!sheetParser.hasMoreData()) {
+            Log.i(MyTracksConstants.TAG, "Found no worksheets");
+            return;
+          }
+
+          // Grab the first worksheet.
+          WorksheetEntry worksheetEntry =
+              (WorksheetEntry) sheetParser.readNextEntry(new WorksheetEntry());
+
+          int lastSlash = worksheetEntry.getId().lastIndexOf('/');
+          idSaver.set(worksheetEntry.getId().substring(lastSlash + 1));
+        } catch (ParseException e) {
+          throw new GDataWrapper.ParseException(e);
+        } catch (AuthenticationException e) {
+          throw new GDataWrapper.AuthenticationException(e);
+        }
+      }
+    });
+    
+    if (!result) {
+      throw newIOException(trixWrapper, "Failed to retrieve worksheet ID.");
+    }
+    
+    return idSaver.get();
+  }
+  
+  /**
+   * Add a row to a worksheet containing the stats for a given track.
+   * 
+   * @param context The context associated with this request.
+   * @param trixAuth The GData authorization for the spreadsheet service.
+   * @param spreadsheetId The spreadsheet to be modified.
+   * @param worksheetId The worksheet to be modified.
+   * @param track The track whose stats are to be written.
+   * @param metricUnits True if metric units are to be used.  If false,
+   *     imperial units will be used.
+   * @throws IOException If an error occurs while updating the worksheet.
+   */
+  public void addTrackRow(Context context, AuthManager trixAuth, 
+      String spreadsheetId, String worksheetId, Track track, 
+      boolean metricUnits) throws IOException {
+    
+    String worksheetUri = String.format(DOCS_SPREADSHEET_URL_FORMAT,
+        spreadsheetId, worksheetId);
+    TripStatistics stats = track.getStatistics();
+    
+    String distanceUnit = context.getString(metricUnits ? 
+        R.string.kilometer : R.string.mile);
+    String speedUnit = context.getString(metricUnits ? 
+        R.string.kilometer_per_hour : R.string.mile_per_hour);
+    String elevationUnit = context.getString(metricUnits ?
+        R.string.meter : R.string.feet);
+
+    // Prepare the Post-Text we are going to send.
+    DocsTagBuilder tagBuilder = new DocsTagBuilder(metricUnits)
+        .append("name", track.getName())
+        .append("description", track.getDescription())
+        .append("date", String.format("%tc", stats.getStartTime()))
+        .append("totaltime", StringUtils.formatTimeAlwaysShowingHours(
+            stats.getTotalTime()))
+        .append("movingtime", StringUtils.formatTimeAlwaysShowingHours(
+            stats.getMovingTime()))
+        .appendLargeUnits("distance", stats.getTotalDistance() / 1000)
+        .append("distanceunit", distanceUnit)
+        .appendLargeUnits("averagespeed", stats.getAverageSpeed() * 3.6)
+        .appendLargeUnits("averagemovingspeed",
+            stats.getAverageMovingSpeed() * 3.6)
+        .appendLargeUnits("maxspeed", stats.getMaxSpeed() * 3.6)
+        .append("speedunit", speedUnit)
+        .appendSmallUnits("elevationgain", stats.getTotalElevationGain())
+        .appendSmallUnits("minelevation", stats.getMinElevation())
+        .appendSmallUnits("maxelevation", stats.getMaxElevation())
+        .append("elevationunit", elevationUnit);
+
+    if (track.getMapId().length() > 0) {
+      tagBuilder.append("map", String.format("%s?msa=0&msid=%s",
+          MyTracksConstants.MAPSHOP_BASE_URL, track.getMapId()));
+    }
+    
+    String postText = new StringBuilder()
+        .append("<entry xmlns='http://www.w3.org/2005/Atom' "
+            + "xmlns:gsx='http://schemas.google.com/spreadsheets/"
+            + "2006/extended'>")
+        .append(tagBuilder.build())
+        .append("</entry>")
+        .toString();
+
+    Log.i(MyTracksConstants.TAG,
+        "Inserting at: " + spreadsheetId + " => " + worksheetUri);
+
+    Log.i(MyTracksConstants.TAG, postText);
+    
+    writeRowData(trixAuth, worksheetUri, postText);
+
+    Log.i(MyTracksConstants.TAG, "Post finished.");
+  }
+
+  /**
+   * Writes spreadsheet row data to the indicated worksheet.
+   * 
+   * @param trixAuth The GData authorization for the spreadsheet service.
+   * @param worksheetUri The URI of the worksheet to be altered.
+   * @param postText The XML tags describing the change to be made.
+   * @throws IOException Thrown if an error occurs during the write.
+   */
+  protected void writeRowData(AuthManager trixAuth, String worksheetUri, 
+      String postText) throws IOException {
+    // No need for a wrapper because we know that the authorization was good
+    // enough to get this far.
+    URL url = new URL(worksheetUri);
+    URLConnection conn = url.openConnection();
+    conn.addRequestProperty(CONTENT_TYPE_PARAM, ATOM_FEED_MIME_TYPE);
+    conn.addRequestProperty("Authorization",
+        "GoogleLogin auth=" + trixAuth.getAuthToken());
+    conn.setDoOutput(true);
+    OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
+    wr.write(postText);
+    wr.flush();
+
+    // Get the response.
+    // TODO: Should we parse the response, rather than simply throwing it away?
+    BufferedReader rd =
+        new BufferedReader(new InputStreamReader(conn.getInputStream()));
+    String line;
+    while ((line = rd.readLine()) != null) {
+      // Process line.
+      Log.i(MyTracksConstants.TAG, "r: " + line);
+    }
+    wr.close();
+    rd.close();
+  }
+  
+  private static IOException newIOException(GDataWrapper wrapper, 
+      String message) {
+    return new IOException(String.format("%s: %d: %s", message, 
+        wrapper.getErrorType(), wrapper.getErrorMessage()));
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/docs/DocsTagBuilder.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2010 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.docs;
+
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.apps.mytracks.util.UnitConversions;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+
+/**
+ * <p>This class builds a string of XML tags used to talk to Docs using GData.
+ * 
+ * <p>Sample Usage:
+ * 
+ * <code>
+ *   String tags = new DocsTagBuilder(false)
+ *       .append("tagName", "tagValue")
+ *       .appendLargeUnits("bigTagName", 1.0)
+ *       .build();
+ * </code>
+ * 
+ * <p>results in:
+ * 
+ * <code>
+ *    <gsx:tagName><![CDATA[tagValue]]></gsx:tagName>
+ *    <gsx:bigTagName><![CDATA[1.00]]></gsx:bigTagName>
+ * </code>
+ * 
+ * @author Matthew Simmons
+ */
+class DocsTagBuilder {
+  // TODO(simmonmt): These formats aren't I18N-compatible.  Not everyone uses
+  // commas for thousands and dots for the decimal point.
+  private static final NumberFormat LARGE_UNIT_FORMAT =
+    new DecimalFormat("#,###,###.00");
+  private static final NumberFormat SMALL_UNIT_FORMAT =
+    new DecimalFormat("###,###");
+
+  protected final boolean metricUnits;
+  protected final StringBuilder stringBuilder;
+
+  /**
+   * @param metricUnits True if metric units are to be used.  If false,
+   *     imperial units will be used.
+   */
+  DocsTagBuilder(boolean metricUnits) {
+    this.metricUnits = metricUnits;
+    stringBuilder = new StringBuilder();
+  }
+
+  /** Appends a tag containing a string value */
+  DocsTagBuilder append(String name, String value) {
+    appendTag(name, value);
+    return this;
+  }
+
+  /** 
+   * Appends a tag containing a numeric value.  The value will be formatted
+   * according to the large distance of the specified measurement system (i.e.
+   * kilometers or miles).
+   * 
+   * @param name The tag name.
+   * @param d The value to be formatted, in kilometers. 
+   */
+  DocsTagBuilder appendLargeUnits(String name, double d) {
+    double value = metricUnits ? d : (d * UnitConversions.KM_TO_MI);
+    appendTag(name, LARGE_UNIT_FORMAT.format(value));
+    return this;
+  }
+
+  /**
+   * Appends a tag containing a numeric value.  The value will be formatted
+   * according to the small distance of the specified measurement system (i.e.
+   * meters or feet).
+   * 
+   * @param name The tag name.
+   * @param d The value to be formatted, in meters.
+   */
+  DocsTagBuilder appendSmallUnits(String name, double d) {
+    double value = metricUnits ? d : (d * UnitConversions.M_TO_FT);
+    appendTag(name, SMALL_UNIT_FORMAT.format(value));
+    return this;
+  }
+
+  /** Returns a string containing all tags which have been added. */
+  String build() {
+    return stringBuilder.toString();
+  }
+
+  private void appendTag(String name, String value) {
+    stringBuilder.append("<gsx:")
+        .append(name)
+        .append(">")
+        .append(StringUtils.stringAsCData(value))
+        .append("</gsx:")
+        .append(name)
+        .append(">");
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/gdata/AndroidGDataClient.java

@@ -0,0 +1,460 @@
+/*
+ * Copyright 2010 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.gdata;
+
+import com.google.wireless.gdata.client.GDataClient;
+import com.google.wireless.gdata.client.HttpException;
+import com.google.wireless.gdata.client.QueryParams;
+import com.google.wireless.gdata.data.StringUtils;
+import com.google.wireless.gdata.parser.ParseException;
+import com.google.wireless.gdata.serializer.GDataSerializer;
+
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+import org.apache.http.Header;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.entity.AbstractHttpEntity;
+import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.entity.InputStreamEntity;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URLEncoder;
+import java.util.zip.GZIPInputStream;
+
+/**
+ * Implementation of a GDataClient using GoogleHttpClient to make HTTP requests.
+ * Always issues GETs and POSTs, using the X-HTTP-Method-Override header when a
+ * PUT or DELETE is desired, to avoid issues with firewalls, etc., that do not
+ * allow methods other than GET or POST.
+ */
+public class AndroidGDataClient implements GDataClient {
+
+  private static final String TAG = "GDataClient";
+  private static final boolean DEBUG = false;
+  private static final boolean LOCAL_LOGV = DEBUG ? Config.LOGD : Config.LOGV;
+
+  private static final String X_HTTP_METHOD_OVERRIDE = "X-HTTP-Method-Override";
+
+  private static final int MAX_REDIRECTS = 10;
+
+  private final HttpClient httpClient;
+
+  /**
+   * Interface for creating HTTP requests. Used by
+   * {@link AndroidGDataClient#createAndExecuteMethod}, since HttpUriRequest
+   * does not allow for changing the URI after creation, e.g., when you want to
+   * follow a redirect.
+   */
+  private interface HttpRequestCreator {
+    HttpUriRequest createRequest(URI uri);
+  }
+
+  private static class GetRequestCreator implements HttpRequestCreator {
+    public HttpUriRequest createRequest(URI uri) {
+      return new HttpGet(uri);
+    }
+  }
+
+  private static class PostRequestCreator implements HttpRequestCreator {
+    private final String mMethodOverride;
+    private final HttpEntity mEntity;
+
+    public PostRequestCreator(String methodOverride, HttpEntity entity) {
+      mMethodOverride = methodOverride;
+      mEntity = entity;
+    }
+
+    public HttpUriRequest createRequest(URI uri) {
+      HttpPost post = new HttpPost(uri);
+      if (mMethodOverride != null) {
+        post.addHeader(X_HTTP_METHOD_OVERRIDE, mMethodOverride);
+      }
+      post.setEntity(mEntity);
+      return post;
+    }
+  }
+
+  // MAJOR TODO: make this work across redirects (if we can reset the
+  // InputStream).
+  // OR, read the bits into a local buffer (yuck, the media could be large).
+  private static class MediaPutRequestCreator implements HttpRequestCreator {
+    private final InputStream mMediaInputStream;
+    private final String mContentType;
+
+    public MediaPutRequestCreator(InputStream mediaInputStream,
+        String contentType) {
+      mMediaInputStream = mediaInputStream;
+      mContentType = contentType;
+    }
+
+    public HttpUriRequest createRequest(URI uri) {
+      HttpPost post = new HttpPost(uri);
+      post.addHeader(X_HTTP_METHOD_OVERRIDE, "PUT");
+      InputStreamEntity entity =
+          new InputStreamEntity(mMediaInputStream, -1 /* read until EOF */);
+      entity.setContentType(mContentType);
+      post.setEntity(entity);
+      return post;
+    }
+  }
+
+  /**
+   * Creates a new AndroidGDataClient.
+   */
+  public AndroidGDataClient() {
+    httpClient = new DefaultHttpClient();
+  }
+
+  public void close() {
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see GDataClient#encodeUri(java.lang.String)
+   */
+  public String encodeUri(String uri) {
+    String encodedUri;
+    try {
+      encodedUri = URLEncoder.encode(uri, "UTF-8");
+    } catch (UnsupportedEncodingException uee) {
+      // should not happen.
+      Log.e("JakartaGDataClient", "UTF-8 not supported -- should not happen.  "
+          + "Using default encoding.", uee);
+      encodedUri = URLEncoder.encode(uri);
+    }
+    return encodedUri;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see com.google.wireless.gdata.client.GDataClient#createQueryParams()
+   */
+  public QueryParams createQueryParams() {
+    return new QueryParamsImpl();
+  }
+
+  // follows redirects
+  private InputStream createAndExecuteMethod(HttpRequestCreator creator,
+      String uriString, String authToken) throws HttpException, IOException {
+
+    HttpResponse response = null;
+    int status = 500;
+    int redirectsLeft = MAX_REDIRECTS;
+
+    URI uri;
+    try {
+      uri = new URI(uriString);
+    } catch (URISyntaxException use) {
+      Log.w(TAG, "Unable to parse " + uriString + " as URI.", use);
+      throw new IOException("Unable to parse " + uriString + " as URI: "
+          + use.getMessage());
+    }
+
+    // we follow redirects ourselves, since we want to follow redirects even on
+    // POSTs, which
+    // the HTTP library does not do. following redirects ourselves also allows
+    // us to log
+    // the redirects using our own logging.
+    while (redirectsLeft > 0) {
+
+      HttpUriRequest request = creator.createRequest(uri);
+      request.addHeader("Accept-Encoding", "gzip");
+
+      // only add the auth token if not null (to allow for GData feeds that do
+      // not require
+      // authentication.)
+      if (!TextUtils.isEmpty(authToken)) {
+        request.addHeader("Authorization", "GoogleLogin auth=" + authToken);
+      }
+      if (LOCAL_LOGV) {
+        for (Header h : request.getAllHeaders()) {
+          Log.v(TAG, h.getName() + ": " + h.getValue());
+        }
+        Log.d(TAG, "Executing " + request.getRequestLine().toString());
+      }
+
+      response = null;
+
+      try {
+        response = httpClient.execute(request);
+      } catch (IOException ioe) {
+        Log.w(TAG, "Unable to execute HTTP request." + ioe);
+        throw ioe;
+      }
+
+      StatusLine statusLine = response.getStatusLine();
+      if (statusLine == null) {
+        Log.w(TAG, "StatusLine is null.");
+        throw new NullPointerException(
+            "StatusLine is null -- should not happen.");
+      }
+
+      if (Log.isLoggable(TAG, Log.DEBUG)) {
+        Log.d(TAG, response.getStatusLine().toString());
+        for (Header h : response.getAllHeaders()) {
+          Log.d(TAG, h.getName() + ": " + h.getValue());
+        }
+      }
+      status = statusLine.getStatusCode();
+
+      HttpEntity entity = response.getEntity();
+
+      if ((status >= 200) && (status < 300) && entity != null) {
+        return getUngzippedContent(entity);
+      }
+
+      // TODO: handle 301, 307?
+      // TODO: let the http client handle the redirects, if we can be sure we'll
+      // never get a
+      // redirect on POST.
+      if (status == 302) {
+        // consume the content, so the connection can be closed.
+        entity.consumeContent();
+        Header location = response.getFirstHeader("Location");
+        if (location == null) {
+          if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "Redirect requested but no Location " + "specified.");
+          }
+          break;
+        }
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+          Log.d(TAG, "Following redirect to " + location.getValue());
+        }
+        try {
+          uri = new URI(location.getValue());
+        } catch (URISyntaxException use) {
+          if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, "Unable to parse " + location.getValue() + " as URI.",
+                use);
+            throw new IOException("Unable to parse " + location.getValue()
+                + " as URI.");
+          }
+          break;
+        }
+        --redirectsLeft;
+      } else {
+        break;
+      }
+    }
+
+    if (Log.isLoggable(TAG, Log.VERBOSE)) {
+      Log.v(TAG, "Received " + status + " status code.");
+    }
+    String errorMessage = null;
+    HttpEntity entity = response.getEntity();
+    try {
+      if (response != null && entity != null) {
+        InputStream in = entity.getContent();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte[] buf = new byte[8192];
+        int bytesRead = -1;
+        while ((bytesRead = in.read(buf)) != -1) {
+          baos.write(buf, 0, bytesRead);
+        }
+        // TODO: use appropriate encoding, picked up from Content-Type.
+        errorMessage = new String(baos.toByteArray());
+        if (Log.isLoggable(TAG, Log.VERBOSE)) {
+          Log.v(TAG, errorMessage);
+        }
+      }
+    } finally {
+      if (entity != null) {
+        entity.consumeContent();
+      }
+    }
+    String exceptionMessage = "Received " + status + " status code";
+    if (errorMessage != null) {
+      exceptionMessage += (": " + errorMessage);
+    }
+    throw new HttpException(exceptionMessage, status, null /* InputStream */);
+  }
+
+  /**
+   * Gets the input stream from a response entity.  If the entity is gzipped
+   * then this will get a stream over the uncompressed data.
+   *
+   * @param entity the entity whose content should be read
+   * @return the input stream to read from
+   * @throws IOException
+   */
+  private static InputStream getUngzippedContent(HttpEntity entity)
+      throws IOException {
+    InputStream responseStream = entity.getContent();
+    if (responseStream == null) {
+      return responseStream;
+    }
+    Header header = entity.getContentEncoding();
+    if (header == null) {
+      return responseStream;
+    }
+    String contentEncoding = header.getValue();
+    if (contentEncoding == null) {
+      return responseStream;
+    }
+    if (contentEncoding.contains("gzip")){
+      responseStream = new GZIPInputStream(responseStream);
+    }
+    return responseStream;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see GDataClient#getFeedAsStream(java.lang.String, java.lang.String)
+   */
+  public InputStream getFeedAsStream(String feedUrl, String authToken)
+      throws HttpException, IOException {
+
+    InputStream in =
+        createAndExecuteMethod(new GetRequestCreator(), feedUrl, authToken);
+    if (in != null) {
+      return in;
+    }
+    throw new IOException("Unable to access feed.");
+  }
+
+  public InputStream getMediaEntryAsStream(String mediaEntryUrl,
+      String authToken) throws HttpException, IOException {
+
+    InputStream in =
+        createAndExecuteMethod(new GetRequestCreator(), mediaEntryUrl,
+            authToken);
+
+    if (in != null) {
+      return in;
+    }
+    throw new IOException("Unable to access media entry.");
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see GDataClient#createEntry
+   */
+  public InputStream createEntry(String feedUrl, String authToken,
+      GDataSerializer entry) throws HttpException, IOException {
+
+    HttpEntity entity =
+        createEntityForEntry(entry, GDataSerializer.FORMAT_CREATE);
+    InputStream in =
+        createAndExecuteMethod(new PostRequestCreator(null /* override */,
+            entity), feedUrl, authToken);
+    if (in != null) {
+      return in;
+    }
+    throw new IOException("Unable to create entry.");
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see GDataClient#updateEntry
+   */
+  public InputStream updateEntry(String editUri, String authToken,
+      GDataSerializer entry) throws HttpException, IOException {
+    HttpEntity entity =
+        createEntityForEntry(entry, GDataSerializer.FORMAT_UPDATE);
+    InputStream in =
+        createAndExecuteMethod(new PostRequestCreator("PUT", entity), editUri,
+            authToken);
+    if (in != null) {
+      return in;
+    }
+    throw new IOException("Unable to update entry.");
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see GDataClient#deleteEntry
+   */
+  public void deleteEntry(String editUri, String authToken)
+      throws HttpException, IOException {
+    if (StringUtils.isEmpty(editUri)) {
+      throw new IllegalArgumentException(
+          "you must specify an non-empty edit url");
+    }
+    InputStream in =
+        createAndExecuteMethod(
+            new PostRequestCreator("DELETE", null /* entity */), editUri,
+            authToken);
+    if (in == null) {
+      throw new IOException("Unable to delete entry.");
+    }
+    try {
+      in.close();
+    } catch (IOException ioe) {
+      // ignore
+    }
+  }
+
+  public InputStream updateMediaEntry(String editUri, String authToken,
+      InputStream mediaEntryInputStream, String contentType)
+      throws HttpException, IOException {
+    InputStream in =
+        createAndExecuteMethod(new MediaPutRequestCreator(
+            mediaEntryInputStream, contentType), editUri, authToken);
+    if (in != null) {
+      return in;
+    }
+    throw new IOException("Unable to write media entry.");
+  }
+
+  private HttpEntity createEntityForEntry(GDataSerializer entry, int format)
+      throws IOException {
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    try {
+      entry.serialize(baos, format);
+    } catch (IOException ioe) {
+      Log.e(TAG, "Unable to serialize entry.", ioe);
+      throw ioe;
+    } catch (ParseException pe) {
+      Log.e(TAG, "Unable to serialize entry.", pe);
+      throw new IOException("Unable to serialize entry: " + pe.getMessage());
+    }
+
+    byte[] entryBytes = baos.toByteArray();
+
+    if (entryBytes != null && Log.isLoggable(TAG, Log.DEBUG)) {
+      try {
+        Log.d(TAG, "Serialized entry: " + new String(entryBytes, "UTF-8"));
+      } catch (UnsupportedEncodingException uee) {
+        // should not happen
+        throw new IllegalStateException("UTF-8 should be supported!", uee);
+      }
+    }
+
+    AbstractHttpEntity entity = new ByteArrayEntity(entryBytes);
+    entity.setContentType(entry.getContentType());
+    return entity;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/gdata/GDataClientFactory.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010 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.gdata;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.wireless.gdata.client.GDataClient;
+
+import android.content.Context;
+import android.util.Log;
+
+/**
+ * This factory will fetch the right class for the platform.
+ * 
+ * @author Sandor Dornbush
+ */
+public class GDataClientFactory {
+
+  private GDataClientFactory() { }
+
+  /**
+   * Creates a new GData client.
+   * This factory will fetch the right class for the platform.
+   * @return A GDataClient appropriate for this platform
+   */
+  public static GDataClient getGDataClient(Context context) {
+    try {
+      // Try to use the official unbundled gdata client implementation.
+      // This should work on Froyo and beyond.
+      return new com.google.android.common.gdata.AndroidGDataClient(context);
+    } catch (LinkageError e) {
+      // On all other platforms use the client implementation packaged in the
+      // apk.
+      Log.i(MyTracksConstants.TAG, "Using mytracks AndroidGDataClient.", e);
+      return new com.google.android.apps.mytracks.io.gdata.AndroidGDataClient();
+    }
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/gdata/GDataWrapper.java

@@ -0,0 +1,300 @@
+/*
+ * 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.gdata;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.io.AuthManager;
+
+import android.util.Log;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+
+/**
+ * GDataWrapper provides a wrapper around GData operations that maintains the
+ * GData client, and provides a method to run GData queries with proper error
+ * handling. After a query is run, the wrapper can be queried about the error
+ * that occurred.
+ *
+ * @param C the GData service client
+ * @author Sandor Dornbush
+ */
+public class GDataWrapper<C> {
+
+  public static class AuthenticationException extends Exception {
+    private Exception exception;
+    private static final long serialVersionUID = 1L;
+    public AuthenticationException(Exception caught) {
+      this.exception = caught;
+    }
+    public Exception getException() {
+      return exception;
+    }
+  };
+
+  public static class ParseException extends Exception {
+    private Exception exception;
+    private static final long serialVersionUID = 1L;
+    public ParseException(Exception caught) {
+      this.exception = caught;
+    }
+    public Exception getException() {
+      return exception;
+    }
+  };
+
+  public static class ConflictDetectedException extends Exception {
+    private Exception exception;
+    private static final long serialVersionUID = 1L;
+    public ConflictDetectedException(Exception caught) {
+      this.exception = caught;
+    }
+    public Exception getException() {
+      return exception;
+    }
+  };
+
+  public static class HttpException extends Exception {
+    private static final long serialVersionUID = 1L;
+    private int statusCode;
+    private String statusMessage;
+    public HttpException(int statusCode, String statusMessage) {
+      super();
+      this.statusCode = statusCode;
+      this.statusMessage = statusMessage;
+    }
+    public int getStatusCode() {
+      return statusCode;
+    }
+    public String getStatusMessage() {
+      return statusMessage;
+    }
+  };
+
+  /**
+   * A QueryFunction is passed in when executing a query. The query function of
+   * the class is called with the GData client as a parameter. The function
+   * should execute whatever operations it desires on the client without concern
+   * for whether the client will throw an error.
+   */
+  public interface QueryFunction<C> {
+    public abstract void query(C client)
+        throws AuthenticationException, IOException, ParseException,
+        ConflictDetectedException, HttpException;
+  }
+
+  /**
+   * A AuthenticatedFunction is passed in when executing the google
+   * authenticated service. The authenticated function of the class is called
+   * with the current authentication token for the service. The function should
+   * execute whatever operations with the google service without concern for
+   * whether the client will throw an error.
+   */
+  public interface AuthenticatedFunction {
+    public abstract void run(String authenticationToken)
+        throws AuthenticationException, IOException;
+  }
+
+  // The types of error that may be encountered
+  // No error occurred.
+  public static final int ERROR_NO_ERROR = 0;
+  // There was an authentication error, the auth token may be invalid.
+  public static final int ERROR_AUTH = 1;
+  // There was an internal error on the server side.
+  public static final int ERROR_INTERNAL = 2;
+  // There was an error connecting to the server.
+  public static final int ERROR_CONNECTION = 3;
+  // The item queried did not exit.
+  public static final int ERROR_NOT_FOUND = 4;
+  // There was an error parsing or serializing locally.
+  public static final int ERROR_LOCAL = 5;
+  // There was a conflict, update the entry and try again.
+  public static final int ERROR_CONFLICT = 6;
+  // A query was run after cleaning up the wrapper, so the client was invalid.
+  public static final int ERROR_CLEANED_UP = 7;
+  // An unknown error occurred.
+  public static final int ERROR_UNKNOWN = 100;
+  
+  private static final int AUTH_TOKEN_INVALIDATE_REFRESH_NUM_RETRIES = 1;
+  private static final int AUTH_TOKEN_INVALIDATE_REFRESH_TIMEOUT = 5000;
+
+  private String errorMessage;
+  private int errorType;
+  private C gdataServiceClient;
+  private AuthManager auth;
+  private boolean retryOnAuthFailure;
+  
+  public GDataWrapper() {
+    errorType = ERROR_NO_ERROR;
+    errorMessage = null;
+    auth = null;
+    retryOnAuthFailure = false;
+  }
+
+  public void setClient(C gdataServiceClient) {
+    this.gdataServiceClient = gdataServiceClient;
+  }
+
+  public boolean runAuthenticatedFunction(
+      final AuthenticatedFunction function) {
+    return runCommon(function, null);
+  }
+
+  public boolean runQuery(final QueryFunction<C> query) {
+    return runCommon(null, query);
+  }
+
+  /**
+   * Runs an arbitrary piece of code.
+   */
+  private boolean runCommon(final AuthenticatedFunction function,
+      final QueryFunction<C> query) {
+    for (int i = 0; i <= AUTH_TOKEN_INVALIDATE_REFRESH_NUM_RETRIES; i++) {
+      runOne(function, query);
+      if (errorType == ERROR_NO_ERROR) {
+        return true;
+      }
+
+      Log.d(MyTracksConstants.TAG, "GData error encountered: " + errorMessage);
+      if (errorType == ERROR_AUTH && auth != null) {
+        if (!retryOnAuthFailure || !invalidateAndRefreshAuthToken()) {
+          return false;
+        }
+      }
+      
+      Log.d(MyTracksConstants.TAG, "retrying function/query");
+    }
+    return false;
+  }
+
+  /**
+   * Execute a given function or query.  If one is executed, errorType and
+   * errorMessage will contain the result/status of the function/query.
+   */
+  private void runOne(final AuthenticatedFunction function, 
+      final QueryFunction<C> query) {
+    try {
+      if (function != null) {
+        function.run(this.auth.getAuthToken());
+      } else if (query != null) {
+        query.query(gdataServiceClient);
+      } else {
+        throw new IllegalArgumentException(
+            "invalid invocation of runOne; one of function/query " +
+            "must be non-null");
+      }
+
+      errorType = ERROR_NO_ERROR;
+      errorMessage = null;
+
+    } catch (AuthenticationException e) {
+      Log.e(MyTracksConstants.TAG, "AuthenticationException", e);
+      errorType = ERROR_AUTH;
+      errorMessage = e.getMessage();
+    } catch (HttpException e) {
+      Log.e(MyTracksConstants.TAG, 
+          "HttpException, code " + e.getStatusCode() + " message " + e.getMessage(), e);
+      errorMessage = e.getMessage();
+      if (e.getStatusCode() == 401) {
+        errorType = ERROR_AUTH;
+      } else {
+        errorType = ERROR_CONNECTION;
+      }
+    } catch (FileNotFoundException e) {
+      Log.e(MyTracksConstants.TAG, "Exception", e);
+      errorType = ERROR_AUTH;
+      errorMessage = e.getMessage();
+    } catch (IOException e) {
+      Log.e(MyTracksConstants.TAG, "Exception", e);
+      errorMessage = e.getMessage();
+      if (errorMessage != null && errorMessage.contains("503")) {
+        errorType = ERROR_INTERNAL;
+      } else {
+        errorType = ERROR_CONNECTION;
+      }
+    } catch (ParseException e) {
+      Log.e(MyTracksConstants.TAG, "Exception", e);
+      errorType = ERROR_LOCAL;
+      errorMessage = e.getMessage();
+    } catch (ConflictDetectedException e) {
+      Log.e(MyTracksConstants.TAG, "Exception", e);
+      errorType = ERROR_CONFLICT;
+      errorMessage = e.getMessage();
+    }
+  }
+
+  /** 
+   * Invalidates and refreshes the auth token.  Blocks until the refresh has
+   * completed or until we deem the refresh as having timed out.
+   * 
+   * @return true If the invalidate/refresh succeeds, false if it fails or
+   *   times out.
+   */
+  private boolean invalidateAndRefreshAuthToken() {
+    Log.d(MyTracksConstants.TAG, "Retrying due to auth failure");
+    // This FutureTask doesn't do anything -- it exists simply to be
+    // blocked upon using get().
+    FutureTask<?> whenFinishedFuture = new FutureTask<Object>(new Runnable() {
+      public void run() {}
+    }, null);
+
+    auth.invalidateAndRefresh(whenFinishedFuture);
+
+    try {
+      Log.d(MyTracksConstants.TAG, "waiting for invalidate");
+      whenFinishedFuture.get(AUTH_TOKEN_INVALIDATE_REFRESH_TIMEOUT, 
+          TimeUnit.MILLISECONDS);
+      Log.d(MyTracksConstants.TAG, "invalidate finished");
+      return true;
+
+    } catch (InterruptedException e) {
+      Log.e(MyTracksConstants.TAG, "Failed to invalidate", e);
+    } catch (ExecutionException e) {
+      Log.e(MyTracksConstants.TAG, "Failed to invalidate", e);
+    } catch (TimeoutException e) {
+      Log.e(MyTracksConstants.TAG, "Invalidate didn't complete in time", e);
+    } finally {
+      whenFinishedFuture.cancel(false);
+    }
+    
+    return false;
+  }
+
+  public int getErrorType() {
+    return errorType;
+  }
+
+  public String getErrorMessage() {
+    return errorMessage;
+  }
+
+  public void setAuthManager(AuthManager auth) {
+    this.auth = auth;
+  }
+  
+  public AuthManager getAuthManager() {
+    return auth;
+  }
+  
+  public void setRetryOnAuthFailure(boolean retry) {
+    retryOnAuthFailure = retry;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/io/gdata/QueryParamsImpl.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010 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.gdata;
+
+import com.google.wireless.gdata.client.QueryParams;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Simple implementation of the QueryParams interface.
+ */
+// TODO: deal with categories
+public class QueryParamsImpl extends QueryParams {
+
+  private final Map<String, String> mParams = new HashMap<String, String>();
+
+  @Override
+  public void clear() {
+    setEntryId(null);
+    mParams.clear();
+  }
+
+  @Override
+  public String generateQueryUrl(String feedUrl) {
+
+    if (TextUtils.isEmpty(getEntryId()) && mParams.isEmpty()) {
+      // nothing to do
+      return feedUrl;
+    }
+
+    // handle entry IDs
+    if (!TextUtils.isEmpty(getEntryId())) {
+      if (!mParams.isEmpty()) {
+        throw new IllegalStateException("Cannot set both an entry ID "
+            + "and other query paramters.");
+      }
+      return feedUrl + '/' + getEntryId();
+    }
+
+    // otherwise, append the querystring params.
+    StringBuilder sb = new StringBuilder();
+    sb.append(feedUrl);
+    Set<String> params = mParams.keySet();
+    boolean first = true;
+    if (feedUrl.contains("?")) {
+      first = false;
+    } else {
+      sb.append('?');
+    }
+    for (String param : params) {
+      if (first) {
+        first = false;
+      } else {
+        sb.append('&');
+      }
+      sb.append(param);
+      sb.append('=');
+      String value = mParams.get(param);
+      String encodedValue = null;
+
+      try {
+        encodedValue = URLEncoder.encode(value, "UTF-8");
+      } catch (UnsupportedEncodingException uee) {
+        // should not happen.
+        Log.w("QueryParamsImpl", "UTF-8 not supported -- should not happen.  "
+            + "Using default encoding.", uee);
+        encodedValue = URLEncoder.encode(value);
+      }
+      sb.append(encodedValue);
+    }
+    return sb.toString();
+  }
+
+  @Override
+  public String getParamValue(String param) {
+    if (!(mParams.containsKey(param))) {
+      return null;
+    }
+    return mParams.get(param);
+  }
+
+  @Override
+  public void setParamValue(String param, String value) {
+    mParams.put(param, value);
+  }
+}