forked from upstream-mirrors/OpenTracks
Rodrigo Damazio
526 lines
19 KiB
Java
526 lines
19 KiB
Java
/*
|
|
* Copyright 2008 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
|
* the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*/
|
|
package com.google.android.apps.mytracks.io;
|
|
|
|
import com.google.android.apps.mymaps.MyMapsConstants;
|
|
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.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(MyTracksSettings.METRIC_UNITS, 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 wiseWrapper = new GDataWrapper();
|
|
wiseWrapper.setAuthManager(wiseAuth);
|
|
wiseWrapper.setRetryOnAuthFailure(true);
|
|
|
|
GDataWrapper writelyWrapper = new GDataWrapper();
|
|
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(androidClient, 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(androidClient, 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 wrapper, final String title) {
|
|
spreadSheetId = null;
|
|
return wrapper.runQuery(new QueryFunction() {
|
|
@Override
|
|
public void query(GDataServiceClient client)
|
|
throws IOException, ParseException, HttpException {
|
|
GDataParser listParser;
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private boolean getWorkSheetId(GDataWrapper wrapper) {
|
|
workSheetId = null;
|
|
return wrapper.runQuery(new QueryFunction() {
|
|
@Override
|
|
public void query(GDataServiceClient client)
|
|
throws AuthenticationException, IOException, ParseException {
|
|
String uri = String.format(DOCS_WORKSHEETS_URL_FORMAT, spreadSheetId);
|
|
GDataParser 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);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates a new MyTracks spreadsheet with the given name.
|
|
*/
|
|
private boolean createSpreadSheet(GDataWrapper writelyWrapper,
|
|
final String name) {
|
|
spreadSheetId = null;
|
|
|
|
return writelyWrapper.runQuery(new QueryFunction() {
|
|
@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);
|
|
|
|
/* 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", track.getStartTime()), sb);
|
|
appendTag("totaltime", StringUtils.formatTimeAlwaysShowingHours(
|
|
track.getTotalTime()), sb);
|
|
appendTag("movingtime", StringUtils.formatTimeAlwaysShowingHours(
|
|
track.getMovingTime()), sb);
|
|
appendLargeUnitsTag("distance", track.getTotalDistance() / 1000, sb);
|
|
appendTag("distanceunit",
|
|
metricUnits
|
|
? activity.getString(R.string.kilometer)
|
|
: activity.getString(R.string.mile),
|
|
sb);
|
|
appendLargeUnitsTag("averagespeed", track.getAverageSpeed() * 3.6, sb);
|
|
appendLargeUnitsTag("averagemovingspeed",
|
|
track.getAverageMovingSpeed() * 3.6, sb);
|
|
appendLargeUnitsTag("maxspeed", track.getMaxSpeed() * 3.6, sb);
|
|
appendTag("speedunit",
|
|
metricUnits
|
|
? activity.getString(R.string.kilometer_per_hour)
|
|
: activity.getString(R.string.mile_per_hour),
|
|
sb);
|
|
appendSmallUnitsTag("elevationgain", track.getTotalElevationGain(), sb);
|
|
appendSmallUnitsTag("minelevation", track.getMinElevation(), sb);
|
|
appendSmallUnitsTag("maxelevation", track.getMaxElevation(), sb);
|
|
appendTag("elevationunit",
|
|
metricUnits
|
|
? activity.getString(R.string.meter)
|
|
: activity.getString(R.string.feet),
|
|
sb);
|
|
if (track.getMapId().length() > 0) {
|
|
appendTag("map", MyMapsConstants.MAPSHOP_BASE_URL + "?msa=0&msid="
|
|
+ track.getMapId(), 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);
|
|
}
|
|
}
|