New: Export feature

- Generic export framework for caches
- Refactored Field Notes export and moved to export framework
- Created experimental GPX exporter

TODO:
- GPX export: Logs, Waypoints, Attributes, correct type/size strings
- Field Notes: upload, only new logs

1 files changed, 223 insertions, 0 deletions

diff --git a/main/src/cgeo/geocaching/export/FieldnoteExport.java b/main/src/cgeo/geocaching/export/FieldnoteExport.java
new file mode 100644
index 0000000..e00a8b0
--- /dev/null
+++ b/main/src/cgeo/geocaching/export/FieldnoteExport.java
@@ -0,0 +1,223 @@
+package cgeo.geocaching.export;
+
+import cgeo.geocaching.R;
+import cgeo.geocaching.Settings;
+import cgeo.geocaching.cgCache;
+import cgeo.geocaching.cgLog;
+import cgeo.geocaching.cgeoapplication;
+import cgeo.geocaching.activity.ActivityMixin;
+import cgeo.geocaching.activity.Progress;
+import cgeo.geocaching.enumerations.LogType;
+import cgeo.geocaching.utils.Log;
+
+import org.apache.commons.lang3.StringUtils;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.os.AsyncTask;
+import android.os.Environment;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CheckBox;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class FieldnoteExport extends AbstractExport {
+    private static final File exportLocation = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/field-notes");
+    private static final SimpleDateFormat fieldNoteDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+
+    public FieldnoteExport() {
+        super(getString(R.string.export_fieldnotes));
+    }
+
+    private class ExportOptionsDialog extends AlertDialog {
+        public ExportOptionsDialog(final List<cgCache> caches, final Activity activity) {
+            super(activity);
+
+            View layout = activity.getLayoutInflater().inflate(R.layout.fieldnote_export_dialog, null);
+            setView(layout);
+
+            ((Button) layout.findViewById(R.id.export)).setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    dismiss();
+                    new ExportTask(
+                            caches,
+                            activity,
+                            ((CheckBox) findViewById(R.id.upload)).isChecked(),
+                            ((CheckBox) findViewById(R.id.onlynew)).isChecked())
+                            .execute((Void) null);
+                }
+            });
+        }
+    }
+
+    @Override
+    public void export(final List<cgCache> caches, final Activity activity) {
+        new ExportOptionsDialog(caches, activity).show();
+    }
+
+    private class ExportTask extends AsyncTask<Void, Integer, Boolean> {
+        private final List<cgCache> caches;
+        private final Activity activity;
+        private final boolean upload;
+        private final boolean onlyNew;
+        private final Progress progress = new Progress();
+        private File exportFile;
+
+        private static final int STATUS_UPLOAD = -1;
+
+        public ExportTask(final List<cgCache> caches, final Activity activity, final boolean upload, final boolean onlyNew) {
+            this.caches = caches;
+            this.activity = activity;
+            this.upload = upload;
+            this.onlyNew = onlyNew;
+        }
+
+        @Override
+        protected void onPreExecute() {
+            progress.show(activity, null, getString(R.string.export) + ": " + getName(), ProgressDialog.STYLE_HORIZONTAL, null);
+            progress.setMaxProgressAndReset(caches.size());
+        }
+
+        @Override
+        protected Boolean doInBackground(Void... params) {
+            final StringBuilder fieldNoteBuffer = new StringBuilder();
+
+            // We need our own HashMap because LogType will give us localized and maybe
+            // different strings than gc.com expects in the field note
+            // We only need such logtypes that are possible to log via c:geo
+            Map<LogType, String> logTypes = new HashMap<LogType, String>();
+            logTypes.put(LogType.LOG_FOUND_IT, "Found it");
+            logTypes.put(LogType.LOG_DIDNT_FIND_IT, "Didn't find it");
+            logTypes.put(LogType.LOG_NOTE, "Write Note");
+            logTypes.put(LogType.LOG_NEEDS_ARCHIVE, "Needs archived");
+            logTypes.put(LogType.LOG_NEEDS_MAINTENANCE, "Needs Maintenance");
+            logTypes.put(LogType.LOG_WILL_ATTEND, "Will Attend");
+            logTypes.put(LogType.LOG_ATTENDED, "Attended");
+            logTypes.put(LogType.LOG_WEBCAM_PHOTO_TAKEN, "Webcam Photo Taken");
+
+            for (int i = 0; i < caches.size(); i++) {
+                try {
+                    final cgCache cache = caches.get(i);
+                    if (cache.isLogOffline()) {
+                        cgLog log = cgeoapplication.getInstance().loadLogOffline(cache.getGeocode());
+                        if (null != logTypes.get(log.type)) {
+                            fieldNoteBuffer.append(cache.getGeocode())
+                                    .append(',')
+                                    .append(fieldNoteDateFormat.format(new Date(log.date)))
+                                    .append(',')
+                                    .append(logTypes.get(log.type))
+                                    .append(",\"")
+                                    .append(StringUtils.replaceChars(log.log, '"', '\''))
+                                    .append("\"\n");
+                        }
+                    }
+                    publishProgress(i + 1);
+                } catch (Exception e) {
+                    Log.e(Settings.tag, "FieldnoteExport.ExportTask generation", e);
+                    return false;
+                }
+            }
+
+            fieldNoteBuffer.append("\n");
+
+            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+                exportLocation.mkdirs();
+
+                SimpleDateFormat fileNameDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+                exportFile = new File(exportLocation + "/" + fileNameDateFormat.format(new Date()) + ".txt");
+
+                OutputStream os = null;
+                Writer fw = null;
+                try {
+                    os = new FileOutputStream(exportFile);
+                    fw = new OutputStreamWriter(os, "ISO-8859-1"); // TODO: gc.com doesn't support UTF-8
+                    fw.write(fieldNoteBuffer.toString());
+                } catch (IOException e) {
+                    Log.e(Settings.tag, "FieldnoteExport.ExportTask export", e);
+                    return false;
+                } finally {
+                    if (fw != null) {
+                        try {
+                            fw.close();
+                        } catch (IOException e) {
+                            Log.e(Settings.tag, "FieldnoteExport.ExportTask export", e);
+                            return false;
+                        }
+                    }
+                }
+            } else {
+                return false;
+            }
+
+            /*
+             * if (upload) {
+             * TODO Use multipart POST request for uploading
+             * publishProgress(STATUS_UPLOAD);
+             *
+             * final Parameters uploadParams = new Parameters(
+             * "__EVENTTARGET", "",
+             * "__EVENTARGUMENT", "",
+             * "__VIEWSTATE", "",
+             * //TODO "ctl00$ContentBody$chkSuppressDate", "on",
+             * "ctl00$ContentBody$FieldNoteLoader", fieldNoteBuffer.toString(),
+             * "ctl00$ContentBody$btnUpload", "Upload Field Note");
+             * final String uri = "http://www.geocaching.com/my/uploadfieldnotes.aspx";
+             *
+             * String page = Network.getResponseData(Network.postRequest(uri, uploadParams));
+             * if (!Login.getLoginStatus(page)) {
+             * final StatusCode loginState = Login.login();
+             * if (loginState == StatusCode.NO_ERROR) {
+             * page = Network.getResponseData(Network.postRequest(uri, uploadParams));
+             * } else {
+             * Log.e(Settings.tag, "FieldnoteExport.ExportTask upload: No login (error: " + loginState + ")");
+             * return false;
+             * }
+             * }
+             *
+             * if (StringUtils.isBlank(page)) {
+             * Log.e(Settings.tag, "FieldnoteExport.ExportTask upload: No data from server");
+             * return false;
+             * }
+             * }
+             */
+
+            return true;
+        }
+
+        @Override
+        protected void onPostExecute(Boolean result) {
+            progress.dismiss();
+
+            if (result) {
+                if (onlyNew) {
+                    // update last export time in settings
+                }
+                ActivityMixin.showToast(activity, getName() + " " + getString(R.string.export_exportedto) + ": " + exportFile.toString());
+            } else {
+                ActivityMixin.showToast(activity, getString(R.string.export_failed));
+            }
+        }
+
+        @Override
+        protected void onProgressUpdate(Integer... status) {
+            if (STATUS_UPLOAD == status[0]) {
+                progress.setMessage(getString(R.string.export_fieldnotes_uploading));
+            } else {
+                progress.setProgress(status[0]);
+            }
+        }
+    }
+}