Support uploading of tracks to fusion tables. Remove support for maps data api.

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,155 @@
+/*
+ * 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.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+/**
+ * Log of one track.
+ *
+ * @author Sandor Dornbush
+ */
+public class GpxTrackWriter 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 PrintWriter pw = null;
+  private Track track;
+
+  @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.println("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ");
+      pw.println("standalone=\"yes\"?>");
+      pw.println("<?xml-stylesheet type=\"text/xsl\" href=\"details.xsl\"?>");
+      pw.println("<gpx");
+      pw.println(" version=\"1.0\"");
+      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/0\"");
+      pw.print(" xmlns:topografix=\"http://www.topografix.com/GPX/Private/"
+          + "TopoGrafix/0/1\"");
+      pw.print(" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 ");
+      pw.print("http://www.topografix.com/GPX/1/0/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("<topografix:color>c0c0c0</topografix:color>");
+    }
+  }
+
+  @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 lat=\"" + l.getLatitude() + "\" lon=\""
+          + l.getLongitude() + "\">");
+      Date d = new Date(l.getTime());
+      pw.println("<ele>" + l.getAltitude() + "</ele>");
+      pw.println("<time>" + TIMESTAMP_FORMAT.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) {
+      // TODO: The gpx spec says waypoints should come *before* tracks
+      Location l = waypoint.getLocation();
+      if (l != null) {
+        pw.println("<wpt lat=\"" + l.getLatitude() + "\" lon=\""
+            + l.getLongitude() + "\">");
+        pw.println("<name>" + StringUtils.stringAsCData(waypoint.getName())
+            + "</name>");
+        pw.println("<desc>"
+            + StringUtils.stringAsCData(waypoint.getDescription()) + "</desc>");
+        pw.println("<time>" + TIMESTAMP_FORMAT.format(l.getTime()) + "</time>");
+        pw.println("<ele>" + l.getAltitude() + "</ele>");
+        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,540 @@
+/*
+ * 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.gdata.GDataClientFactory;
+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.apps.mytracks.util.UnitConversions;
+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.client.GDataServiceClient;
+import com.google.wireless.gdata.client.HttpException;
+import com.google.wireless.gdata.data.Entry;
+import com.google.wireless.gdata.docs.DocumentsClient;
+import com.google.wireless.gdata.docs.SpreadsheetsClient;
+import com.google.wireless.gdata.docs.SpreadsheetsClient.WorksheetEntry;
+import com.google.wireless.gdata.maps.xml.XmlMapsGDataParserFactory;
+import com.google.wireless.gdata.parser.GDataParser;
+import com.google.wireless.gdata.parser.ParseException;
+import com.google.wireless.gdata2.client.AuthenticationException;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.os.Handler;
+import android.os.HandlerThread;
+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.text.DecimalFormat;
+import java.text.NumberFormat;
+
+/**
+ * A helper class used to transmit tracks statistics to Google Docs/Trix.
+ *
+ * @author Sandor Dornbush
+ */
+public class SendToDocs {
+  private static final NumberFormat LARGE_UNIT_FORMAT =
+      new DecimalFormat("#,###,###.00");
+  private static final NumberFormat SMALL_UNIT_FORMAT =
+      new DecimalFormat("###,###");
+  private static final String DOCS_FEED_URL =
+      "http://docs.google.com/feeds/documents/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 =
+      "http://docs.google.com/feeds/documents/private/full/spreadsheet%3A";
+  private static final String DOCS_SPREADSHEET_URL_FORMAT =
+       "http://spreadsheets.google.com/feeds/list/%s/%s/private/full";
+  protected static final String DOCS_WORKSHEETS_URL_FORMAT =
+      "http://spreadsheets.google.com/feeds/worksheets/%s/private/full";
+  private static final String CONTENT_TYPE_PARAM = "Content-Type";
+  private static final String ATOM_FEED_MIME_TYPE = "application/atom+xml";
+  private static final String OPENDOCUMENT_SPREADSHEET_MIME_TYPE =
+      "application/x-vnd.oasis.opendocument.spreadsheet";
+
+  private final Activity activity;
+  private final AuthManager wiseAuth;
+  private final AuthManager writelyAuth;
+  private final long trackId;
+  private final boolean metricUnits;
+  private final HandlerThread handlerThread;
+  private final Handler handler;
+
+  private boolean createdNewSpreadSheet = false;
+
+  private String spreadSheetId = null;
+  private String workSheetId = null;
+
+  private boolean success = true;
+  private String statusMessage = "";
+  private Runnable onCompletion = null;
+
+  public SendToDocs(Activity activity, AuthManager wiseAuth,
+      AuthManager writelyAuth, long trackId) {
+    this.activity = activity;
+    this.wiseAuth = wiseAuth;
+    this.writelyAuth = writelyAuth;
+    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_mymap);
+    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> wiseWrapper = new GDataWrapper<GDataServiceClient>();
+    wiseWrapper.setAuthManager(wiseAuth);
+    wiseWrapper.setRetryOnAuthFailure(true);
+
+    GDataWrapper<GDataServiceClient> writelyWrapper = new GDataWrapper<GDataServiceClient>();
+    writelyWrapper.setAuthManager(writelyAuth);
+    writelyWrapper.setRetryOnAuthFailure(true);
+
+    GDataClient androidClient = null;
+    try {
+      androidClient = GDataClientFactory.getGDataClient(activity);
+      SpreadsheetsClient gdataClient = new SpreadsheetsClient(androidClient,
+          new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+      wiseWrapper.setClient(gdataClient);
+      Log.d(MyTracksConstants.TAG,
+          "GData connection prepared: " + this.writelyAuth);
+      String sheetTitle = "My Tracks";
+
+      if (track.getCategory() != null && !track.getCategory().equals("")) {
+        sheetTitle += "-" + track.getCategory();
+      }
+
+      DocumentsClient docsGdataClient = new DocumentsClient(androidClient,
+          new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+      writelyWrapper.setClient(docsGdataClient);
+
+      // First try to find the spreadsheet:
+      if (!getSpreadsheetId(writelyWrapper, sheetTitle)) {
+        Log.i(MyTracksConstants.TAG, "Spreadsheet lookup failed.");
+        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);
+        }
+        if (!getSpreadsheetId(writelyWrapper, sheetTitle)) {
+          Log.i(MyTracksConstants.TAG, "2nd spreadsheet lookup failed.");
+          return false;
+        }
+      }
+
+      MyTracks.getInstance().setProgressValue(70);
+      if (spreadSheetId == null) {
+        Log.i(MyTracksConstants.TAG, "Creating new spreadsheet: " + sheetTitle);
+
+        if (!createSpreadSheet(writelyWrapper, sheetTitle)) {
+          return false;
+        }
+        MyTracks.getInstance().setProgressValue(80);
+
+        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);
+          }
+          if (!getSpreadsheetId(writelyWrapper, sheetTitle)) {
+            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);
+            }
+            if (!getSpreadsheetId(writelyWrapper, sheetTitle)) {
+              return false;
+            }
+          }
+          if (spreadSheetId == null) {
+            Log.i(MyTracksConstants.TAG,
+                "Creating new spreadsheet really failed.");
+            return false;
+          }
+        }
+      }
+
+      if (!getWorkSheetId(wiseWrapper)) {
+        Log.i(MyTracksConstants.TAG, "Looking up worksheet id failed.");
+        return false;
+      }
+
+      MyTracks.getInstance().setProgressValue(90);
+
+      insertRowNet(track, spreadSheetId, workSheetId);
+      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;
+  }
+
+  private boolean getSpreadsheetId(GDataWrapper<GDataServiceClient> wrapper, final String title) {
+    spreadSheetId = null;
+    return wrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client)
+          throws IOException, GDataWrapper.ParseException, GDataWrapper.HttpException {
+        GDataParser listParser;
+        try {
+          listParser = client.getParserForFeed(Entry.class,
+              DOCS_MY_SPREADSHEETS_FEED_URL, writelyAuth.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('/');
+              spreadSheetId = entryId.substring(lastSlash + 15);
+              break;
+            }
+          }
+    	  } catch (ParseException e) {
+          throw new GDataWrapper.ParseException();
+        } catch (HttpException e) {
+          throw new GDataWrapper.HttpException(e.getStatusCode(), e.getMessage());
+        }
+      }
+    });
+  }
+
+  private boolean getWorkSheetId(GDataWrapper<GDataServiceClient> wrapper) {
+    workSheetId = null;
+    return wrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client)
+          throws GDataWrapper.AuthenticationException, IOException, GDataWrapper.ParseException {
+        String uri = String.format(DOCS_WORKSHEETS_URL_FORMAT, spreadSheetId);
+        GDataParser sheetParser;
+				try {
+					sheetParser = ((SpreadsheetsClient) client).getParserForWorksheetsFeed(uri,
+					    wiseAuth.getAuthToken());
+	        sheetParser.init();
+	        if (!sheetParser.hasMoreData()) {
+	          Log.i(MyTracksConstants.TAG, "Found no worksheets");
+	          return; // failure
+	        }
+
+	        // just grab the first.
+	        WorksheetEntry worksheetEntry =
+	            (WorksheetEntry) sheetParser.readNextEntry(new WorksheetEntry());
+
+	        int lastSlash = worksheetEntry.getId().lastIndexOf('/');
+	        workSheetId = worksheetEntry.getId().substring(lastSlash + 1);
+
+				} catch (AuthenticationException e) {
+					throw new GDataWrapper.AuthenticationException();
+				} catch (ParseException e) {
+					throw new GDataWrapper.ParseException();
+				}
+      }
+    });
+  }
+
+  /**
+   * Creates a new MyTracks spreadsheet with the given name.
+   */
+  private boolean createSpreadSheet(GDataWrapper<GDataServiceClient> writelyWrapper,
+      final String name) {
+    spreadSheetId = null;
+
+    return writelyWrapper.runQuery(new QueryFunction<GDataServiceClient>() {
+      @Override
+      public void query(GDataServiceClient client) throws IOException {
+        // Construct data
+        // Send data
+        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=" + writelyAuth.getAuthToken());
+        conn.setDoOutput(true);
+        OutputStream os = conn.getOutputStream();
+        ResourceUtils.readBinaryFileToOutputStream(
+            activity, 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;
+        }
+        spreadSheetId = result.substring(
+            idStringStart + DOCS_SPREADSHEET_URL.length(), idTagCloseIndex);
+        Log.i(MyTracksConstants.TAG, "Created new spreadsheet: " + spreadSheetId);
+      }});
+  }
+
+  private void insertRowNet(Track track, String spreadsheetId,
+      String worksheetId) throws IOException {
+    String worksheetUri = String.format(DOCS_SPREADSHEET_URL_FORMAT,
+        spreadsheetId, worksheetId);
+    TripStatistics stats = track.getStatistics();
+
+    /* Prepare the Post-Text we are going to send. */
+    StringBuilder sb = new StringBuilder();
+    sb.append("<entry xmlns='http://www.w3.org/2005/Atom' ");
+    sb.append("xmlns:gsx='http://schemas.google.com/spreadsheets/"
+        + "2006/extended'>");
+    appendTag("name", track.getName(), sb);
+    appendTag("description", track.getDescription(), sb);
+    appendTag("date", String.format("%tc", stats.getStartTime()), sb);
+    appendTag("totaltime", StringUtils.formatTimeAlwaysShowingHours(
+        stats.getTotalTime()), sb);
+    appendTag("movingtime", StringUtils.formatTimeAlwaysShowingHours(
+        stats.getMovingTime()), sb);
+    appendLargeUnitsTag("distance", stats.getTotalDistance() / 1000, sb);
+    appendTag("distanceunit",
+        metricUnits
+            ? activity.getString(R.string.kilometer)
+            : activity.getString(R.string.mile),
+        sb);
+    appendLargeUnitsTag("averagespeed", stats.getAverageSpeed() * 3.6, sb);
+    appendLargeUnitsTag("averagemovingspeed",
+        stats.getAverageMovingSpeed() * 3.6, sb);
+    appendLargeUnitsTag("maxspeed", stats.getMaxSpeed() * 3.6, sb);
+    appendTag("speedunit",
+        metricUnits
+            ? activity.getString(R.string.kilometer_per_hour)
+            : activity.getString(R.string.mile_per_hour),
+        sb);
+    appendSmallUnitsTag("elevationgain", stats.getTotalElevationGain(), sb);
+    appendSmallUnitsTag("minelevation", stats.getMinElevation(), sb);
+    appendSmallUnitsTag("maxelevation", stats.getMaxElevation(), sb);
+    appendTag("elevationunit",
+        metricUnits
+        ? activity.getString(R.string.meter)
+        : activity.getString(R.string.feet),
+        sb);
+    if (track.getMapId().length() > 0) {
+      appendTag("map", SendToFusionTables.getMapVisualizationUrl(track), sb);
+    }
+    sb.append("</entry>");
+    Log.i(MyTracksConstants.TAG,
+        "Inserting at: " + spreadsheetId + " => " + worksheetUri);
+
+    String postText = sb.toString();
+    Log.i(MyTracksConstants.TAG, postText);
+
+    // Send data
+    // 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=" + wiseAuth.getAuthToken());
+    conn.setDoOutput(true);
+    OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
+    wr.write(postText);
+    wr.flush();
+
+    // Get the response
+    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();
+
+    Log.i(MyTracksConstants.TAG, "Post finished.");
+  }
+
+  private void appendTag(String name, String value, StringBuilder sb) {
+    sb.append("<gsx:");
+    sb.append(name);
+    sb.append('>');
+    sb.append(StringUtils.stringAsCData(value));
+    sb.append("</gsx:");
+    sb.append(name);
+    sb.append('>');
+  }
+
+  private void appendLargeUnitsTag(String name, double d, StringBuilder sb) {
+    double value = metricUnits ? d : (d * UnitConversions.KM_TO_MI);
+    appendTag(name, LARGE_UNIT_FORMAT.format(value), sb);
+  }
+
+  private void appendSmallUnitsTag(String name, double d, StringBuilder sb) {
+    double value = metricUnits ? d : (d * UnitConversions.M_TO_FT);
+    appendTag(name, SMALL_UNIT_FORMAT.format(value), sb);
+  }
+}

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

@@ -0,0 +1,633 @@
+/*
+ * 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.MyTracks;
+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.GoogleTransport;
+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.HttpTransport;
+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.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 {
+
+  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 base url for viewing a fusion table. */
+  public static final String FUSIONTABLES_TABLE_URL = "http://www.google.com/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 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;
+
+  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);
+    transport = GoogleTransport.create();
+    GoogleHeaders headers = (GoogleHeaders) transport.defaultHeaders;
+    headers.setApplicationName("Google-MyTracks-" + MyTracks.getMyTracksVersion(context));
+    headers.gdataVersion = "2";
+  }
+
+  @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.
+    Location start = track.getLocations().get(0);
+    double lat = start != null ? start.getLatitude() : 37.0;
+    double lng = start != null ? start.getLongitude() : -121.0;
+    int z = 15;
+  	return String.format(FUSIONTABLES_MAP, track.getTableId(), lat, lng, z);
+  }
+
+  private void doUpload() {
+    ((GoogleHeaders) transport.defaultHeaders).setGoogleLogin(auth.getAuthToken());
+    int statusMessageId = R.string.error_sending_to_fusiontables;
+    boolean success = true;
+    try {
+      progressIndicator.setProgressValue(1);
+      progressIndicator.setProgressMessage(R.string.progress_message_reading_track);
+
+      // Get the track meta-data
+      Track track = providerUtils.getTrack(trackId);
+      String originalDescription = track.getDescription();
+
+      // Create a new table:
+      progressIndicator.setProgressMessage(R.string.progress_message_creating_fusiontable);
+      success = createNewTable(track);
+
+      // Upload all of the segments of the track plus start/end markers
+      if (success) {
+        success = uploadAllTrackPoints(track, originalDescription);
+      }
+
+      // Upload all the waypoints.
+      if (success) {
+        success = uploadWaypoints(track);
+        statusMessageId = R.string.status_new_fusiontable_has_been_created;
+      }
+      Log.d(MyTracksConstants.TAG, "SendToFusionTables: Done: " + success);
+      progressIndicator.setProgressValue(100);
+    } 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 '" + track.getName() +
+        "' (name:STRING,description:STRING,geometry:LOCATION,marker:STRING)";
+    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++) {
+  	  builder.append('\'');
+      builder.append(values[i].replaceAll("'", "xxx"));
+      builder.append('\'');
+      if (i < values.length - 1) {
+  	  	builder.append(',');
+  	  }
+  	}
+  	builder.append(')');
+  	return builder.toString();
+  }
+
+  /**
+   * 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);
+      progressIndicator.setProgressMessage(R.string.progress_message_reading_track);
+      Location lastLocation = null;
+      do {
+        if (totalLocationsRead % 100 == 0) {
+          updateProgress();
+        }
+  
+        Location loc = providerUtils.createLocation(locationsCursor);
+        locations.add(loc);
+  
+        if (totalLocationsRead == 0) {
+          // Put a marker at the first point of the first valid segment:
+          createNewPoint(track.getName(), track.getDescription(), loc, "large_green");
+        }
+  
+        // Add to the elevation profile.
+        if (loc != null && MyTracksUtils.isValidLocation(loc)) {
+          // All points go into the smoothing buffer...
+          elevationBuffer.setNext(metricUnits ? loc.getAltitude()
+              : loc.getAltitude() * UnitConversions.M_TO_FT);
+          if (lastLocation != null) {
+            double dist = lastLocation.distanceTo(loc);
+            totalDistance += dist;
+          }
+  
+          // ...but only a few points are really used to keep the url short.
+          if (totalLocationsRead % elevationSamplingFrequency == 0) {
+            distances.add(totalDistance);
+            elevations.add(elevationBuffer.getAverage());
+          }
+        }
+  
+        // If the location was not valid, it's a segment split, so make sure the
+        // distance between the previous segment and the new one is not accounted
+        // for in the next iteration.
+        lastLocation = loc;
+  
+        // Every now and then, upload the accumulated points
+        if (totalLocationsRead % MAX_POINTS_PER_UPLOAD
+            == MAX_POINTS_PER_UPLOAD - 1) {
+          if (!prepareAndUploadPoints(track, locations)) {
+            return false;
+          }
+        }
+  
+        totalLocationsRead++;
+      } while (locationsCursor.moveToNext());
+  
+      // Do a final upload with what's left
+      if (!prepareAndUploadPoints(track, locations)) {
+        return false;
+      }
+  
+      // Put an end marker at the last point of the last valid segment:
+      if (lastLocation != null) {
+        track.setDescription("<p>" + originalDescription + "</p><p>"
+            + stringUtils.generateTrackDescription(
+                track, distances, elevations)
+            + "</p>");
+        return createNewPoint(track.getName(), track.getDescription(), lastLocation, "large_red");
+      }
+  
+      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) {
+    progressIndicator.setProgressMessage(R.string.progress_message_preparing_track);
+    updateProgress();
+  
+    int numLocations = locations.size();
+    if (numLocations < 2) {
+      Log.d(MyTracksConstants.TAG, "Not preparing/uploading too few points");
+      totalLocationsUploaded += numLocations;
+      return true;
+    }
+  
+    // Prepare/pre-process the points
+    ArrayList<Track> splitTracks = prepareLocations(track, locations);
+  
+    // Start uploading them
+    progressIndicator.setProgressMessage(R.string.progress_message_sending_fusiontables);
+    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;
+    updateProgress();
+    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) {
+        updateProgress();
+      }
+      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;
+    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(),
+          		"large_yellow");
+          if (!success) {
+          	break;
+          }
+        }
+      }
+    }
+    if (!success) {
+      Log.w(MyTracksConstants.TAG, "SendToFusionTables: upload waypoints failed.");
+    }
+    return success;
+  }
+
+  /**
+   * Sets the current upload progress.
+   */
+  private void updateProgress() {
+    // The percent of the total that represents the completed part of this
+    // segment.
+    int totalPercentage =
+        (totalLocationsRead + totalLocationsPrepared + totalLocationsUploaded)
+        / (totalLocations * 3);
+    totalPercentage = Math.min(99, totalPercentage);
+    progressIndicator.setProgressValue(totalPercentage);
+  }
+
+  /**
+   * 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 {
+        HttpRequest request = transport.buildPostRequest();
+        request.headers.contentType = "application/x-www-form-urlencoded";
+        String sql = "sql=" + URLEncoder.encode(query, "UTF-8");
+        GenericUrl url = new GenericUrl(FUSIONTABLES_BASE_FEED_URL + "?" + sql);
+        request.url = url;
+        //OutputStream outputStream = new ByteArrayOutputStream();
+        //outputStream.write(Strings.toBytesUtf8(sql));
+        //outputStream.flush();
+        //request.content.writeTo(outputStream);
+        Log.d(MyTracksConstants.TAG, "Running update query: " + url.toString());
+        HttpResponse response = request.execute();
+        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,218 @@
+/*
+ * 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.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.println("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>");
+    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,327 @@
+/*
+ * 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.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+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();
+    // TODO: Fix ordering (in GPX waypoints should come first)
+    writeLocations();
+    writeWaypoints(track.getId());
+    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;
+    Location lastLoc = null, loc = null;
+    boolean isLastValid = false;
+    Cursor locationsCursor =
+        providerUtils.getLocationsCursor(track.getId(), 0, -1, false);
+    
+    if (locationsCursor == null || !locationsCursor.moveToFirst()) {
+      Log.w(MyTracksConstants.TAG, "Unable to get any points to write");
+      return;
+    }
+
+    do {
+      if (loc == null) loc = new Location("");
+      providerUtils.fillLocation(locationsCursor, loc);
+
+      boolean isValid = MyTracksUtils.isValidLocation(loc);
+      boolean validSegment = isValid && isLastValid;
+      if (!wroteFirst && validSegment) {
+        // Found the first two consecutive points which are valid
+        writer.writeBeginTrack(lastLoc);
+        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(lastLoc);
+        }
+
+        // Write the current point
+        writer.writeLocation(loc);
+      } else {
+        if (segmentOpen) {
+          writer.writeCloseSegment();
+          segmentOpen = false;
+        }
+      }
+
+      // Swap loc and lastLoc (so lastLoc is reused)
+      Location tmp = lastLoc;
+      lastLoc = loc;
+      loc = tmp;
+      if (loc != null) loc.reset();
+
+      isLastValid = isValid;
+    } while (locationsCursor.moveToNext());
+
+    if (segmentOpen) {
+      writer.writeCloseSegment();
+      segmentOpen = false;
+    }
+    if (wroteFirst) {
+      writer.writeEndTrack(lastLoc);
+    }
+  }
+}

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,67 @@
+/*
+ * 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 };
+  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 };
+
+  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 };
+  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 };
+
+  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,236 @@
+/*
+ * 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 columnType 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;
+      default:
+        throw new IllegalArgumentException(
+            "Type " + columnTypeId + " not supported");
+    }
+  }
+
+  /**
+   * Writes a dummy cell value to the output.
+   *
+   * @param columnType 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;
+      default:
+        throw new IllegalArgumentException(
+            "Type " + columnTypeId + " not supported");
+    }
+  }
+}

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

@@ -0,0 +1,180 @@
+/*
+ * 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;
+      }
+      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/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,274 @@
+/*
+ * 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 static final long serialVersionUID = 1L;
+  };
+
+	public static class ParseException extends Exception {
+		private static final long serialVersionUID = 1L;
+  };
+
+  public static class ConflictDetectedException extends Exception {
+		private static final long serialVersionUID = 1L;
+  };
+
+	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, "Exception", e);
+      errorType = ERROR_AUTH;
+      errorMessage = e.getMessage();
+    } catch (HttpException e) {
+      Log.e(MyTracksConstants.TAG, "HttpException", e);
+      errorMessage = e.getMessage();
+      if (errorMessage.contains("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.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 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);
+  }
+}