Java tutorial
/* * Copyright (C) 2012 - 2013 jonas.oreland@gmail.com * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package export; import android.annotation.TargetApi; import android.app.Activity; import android.app.AlertDialog; import android.app.ProgressDialog; import android.content.ContentValues; import android.content.Context; import android.content.DialogInterface; import android.content.DialogInterface.OnClickListener; import android.content.Intent; import android.content.SharedPreferences; import android.content.res.Resources; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.os.AsyncTask; import android.os.Build; import android.preference.PreferenceManager; import android.text.InputType; import android.util.Pair; import android.view.LayoutInflater; import android.view.View; import android.widget.CheckBox; import android.widget.CompoundButton; import android.widget.CompoundButton.OnCheckedChangeListener; import android.widget.TextView; import org.json.JSONException; import org.json.JSONObject; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import db.DBHelper; import export.Uploader.AuthMethod; import export.Uploader.Status; import feed.FeedList; import us.theramsays.bikebadger.app2.BuildConfig; import us.theramsays.bikebadger.app2.R; import util.Constants; import util.Encryption; @TargetApi(Build.VERSION_CODES.FROYO) public class UploadManager { public static final int CONFIGURE_REQUEST = 1; private DBHelper mDBHelper = null; private SQLiteDatabase mDB = null; private Activity activity = null; private Context context = null; private Map<String, Uploader> uploaders = new HashMap<String, Uploader>(); private Map<Long, Uploader> uploadersById = new HashMap<Long, Uploader>(); private ProgressDialog mSpinner = null; public interface Callback { void run(String uploader, Uploader.Status status); }; public UploadManager(Activity activity) { this.activity = activity; this.context = activity; mDBHelper = new DBHelper(activity); mDB = mDBHelper.getWritableDatabase(); mSpinner = new ProgressDialog(activity); mSpinner.setCancelable(false); } public UploadManager(Context context) { this.activity = null; this.context = context; mDBHelper = new DBHelper(context); mDB = mDBHelper.getWritableDatabase(); mSpinner = new ProgressDialog(context); mSpinner.setCancelable(false); } public synchronized void close() { if (mDB != null) { mDB.close(); mDB = null; } if (mDBHelper != null) { mDBHelper.close(); mDBHelper = null; } } public synchronized boolean isClosed() { return mDB == null; } public void remove(String uploaderName) { Uploader u = uploaders.get(uploaderName); uploaders.remove(uploaderName); if (u != null) { this.uploadersById.remove(u.getId()); } } public void clear() { uploaders.clear(); uploadersById.clear(); } public long load(String uploaderName) { String from[] = new String[] { "_id", Constants.DB.ACCOUNT.NAME, Constants.DB.ACCOUNT.AUTH_CONFIG, Constants.DB.ACCOUNT.FLAGS }; String args[] = { uploaderName }; Cursor c = mDB.query(Constants.DB.ACCOUNT.TABLE, from, Constants.DB.ACCOUNT.NAME + " = ?", args, null, null, null, null); long id = -1; if (c.moveToFirst()) { ContentValues config = DBHelper.get(c); id = config.getAsLong("_id"); add(config); } c.close(); return id; } @SuppressWarnings("null") public Uploader add(ContentValues config) { if (config == null) { System.err.println("Add null!"); //assert (false); return null; } String uploaderName = config.getAsString(Constants.DB.ACCOUNT.NAME); if (uploaderName == null) { System.err.println("name not found!"); return null; } if (uploaders.containsKey(uploaderName)) { return uploaders.get(uploaderName); } Uploader uploader = null; //if (uploaderName.contentEquals(RunKeeperUploader.NAME)) { // uploader = new RunKeeperUploader(this); if (uploaderName.contentEquals(GarminUploader.NAME)) { uploader = new GarminUploader(this); //} else if (uploaderName.contentEquals(FunBeatUploader.NAME)) { // uploader = new FunBeatUploader(this); } else if (uploaderName.contentEquals(MapMyRunUploader.NAME)) { uploader = new MapMyRunUploader(this); } else if (uploaderName.contentEquals(NikePlus.NAME)) { uploader = new NikePlus(this); //} else if (uploaderName.contentEquals(JoggSE.NAME)) { // uploader = new JoggSE(this); // } else if (uploaderName.contentEquals(Endomondo.NAME)) { // uploader = new Endomondo(this); //} else if (uploaderName.contentEquals(RunningAHEAD.NAME)) { // uploader = new RunningAHEAD(this); //} else if (uploaderName.contentEquals(RunnerUpLive.NAME)) { // uploader = new RunnerUpLive(this); // } else if (uploaderName.contentEquals(DigifitUploader.NAME)) { // uploader = new DigifitUploader(this); } else if (uploaderName.contentEquals(Strava.NAME)) { uploader = new Strava(this); } else if (uploaderName.contentEquals(Facebook.NAME)) { uploader = new Facebook(context, this); } else if (uploaderName.contentEquals(GooglePlus.NAME)) { uploader = new GooglePlus(this); } if (uploader != null) { if (!config.containsKey(Constants.DB.ACCOUNT.FLAGS)) { if (BuildConfig.DEBUG) { String s = null; s.charAt(3); } } uploader.init(config); uploaders.put(uploaderName, uploader); uploadersById.put(uploader.getId(), uploader); } return uploader; } public boolean isConfigured(final String name) { Uploader l = uploaders.get(name); if (l == null) { return true; } return l.isConfigured(); } public Uploader getUploader(long id) { return uploadersById.get(id); } public void connect(final Callback callback, final String name, final boolean uploading) { Uploader l = uploaders.get(name); if (l == null) { callback.run(name, Uploader.Status.INCORRECT_USAGE); return; } Status s = l.connect(); switch (s) { case OK: callback.run(name, s); return; case CANCEL: case SKIP: case INCORRECT_USAGE: case ERROR: l.reset(); callback.run(name, s); return; case NEED_AUTH: mSpinner.show(); handleAuth(new Callback() { @Override public void run(String uploader, Status status) { mSpinner.dismiss(); callback.run(uploader, status); } }, l, s.authMethod); return; } } Uploader authUploader = null; Callback authCallback = null; private void handleAuth(Callback callback, Uploader l, AuthMethod authMethod) { authUploader = l; authCallback = callback; switch (authMethod) { case OAUTH2: activity.startActivityForResult(l.getAuthIntent(activity), CONFIGURE_REQUEST); return; case USER_PASS: askUsernamePassword(l, false); return; } } private void handleAuthComplete(Uploader uploader, Status s) { Callback cb = authCallback; authCallback = null; authUploader = null; switch (s) { case CANCEL: case ERROR: case INCORRECT_USAGE: case SKIP: uploader.reset(); cb.run(uploader.getName(), s); return; case OK: { ContentValues tmp = new ContentValues(); tmp.put("_id", uploader.getId()); tmp.put(Constants.DB.ACCOUNT.AUTH_CONFIG, uploader.getAuthConfig()); String args[] = { Long.toString(uploader.getId()) }; mDB.update(Constants.DB.ACCOUNT.TABLE, tmp, "_id = ?", args); cb.run(uploader.getName(), s); return; } case NEED_AUTH: handleAuth(cb, uploader, s.authMethod); return; } } private JSONObject newObj(String str) { try { return new JSONObject(str); } catch (JSONException e) { e.printStackTrace(); } return null; } private void askUsernamePassword(final Uploader l, boolean showPassword) { AlertDialog.Builder builder = new AlertDialog.Builder(activity); builder.setTitle(l.getName()); // Get the layout inflater LayoutInflater inflater = activity.getLayoutInflater(); final View view = inflater.inflate(R.layout.userpass, null); final CheckBox cb = (CheckBox) view.findViewById(R.id.showpass); final TextView tv1 = (TextView) view.findViewById(R.id.username); final TextView tv2 = (TextView) view.findViewById(R.id.password_input); String authConfigStr = l.getAuthConfig(); final JSONObject authConfig = newObj(authConfigStr); String username = authConfig.optString("username", ""); String password = authConfig.optString("password", ""); tv1.setText(username); tv2.setText(password); cb.setChecked(showPassword); tv2.setInputType(InputType.TYPE_CLASS_TEXT | (showPassword ? 0 : InputType.TYPE_TEXT_VARIATION_PASSWORD)); cb.setOnCheckedChangeListener(new OnCheckedChangeListener() { @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { tv2.setInputType( InputType.TYPE_CLASS_TEXT | (isChecked ? 0 : InputType.TYPE_TEXT_VARIATION_PASSWORD)); } }); // Inflate and set the layout for the dialog // Pass null as the parent view because its going in the dialog layout builder.setView(view); builder.setPositiveButton("OK", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { try { authConfig.put("username", tv1.getText()); authConfig.put("password", tv2.getText()); } catch (JSONException e) { e.printStackTrace(); } testUserPass(l, authConfig, cb.isChecked()); } }); builder.setNeutralButton("Skip", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { handleAuthComplete(l, Status.SKIP); } }); builder.setNegativeButton("Cancel", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { handleAuthComplete(l, Status.SKIP); } }); final AlertDialog dialog = builder.create(); dialog.show(); } private void testUserPass(final Uploader l, final JSONObject authConfig, final boolean showPassword) { mSpinner.setTitle("Testing login " + l.getName()); new AsyncTask<Uploader, String, Uploader.Status>() { ContentValues config = new ContentValues(); @Override protected Uploader.Status doInBackground(Uploader... params) { config.put(Constants.DB.ACCOUNT.AUTH_CONFIG, authConfig.toString()); config.put("_id", l.getId()); l.init(config); try { return params[0].connect(); } catch (Exception ex) { ex.printStackTrace(); return Uploader.Status.ERROR; } } @Override protected void onPostExecute(Uploader.Status result) { handleAuthComplete(l, result); } }.execute(l); } private long mID = 0; private Callback uploadCallback = null; private HashSet<String> pendingUploaders = null; public void startUploading(Callback callback, HashSet<String> uploaders, long id) { mID = id; uploadCallback = callback; pendingUploaders = uploaders; mSpinner.setTitle("Uploading (" + pendingUploaders.size() + ")"); mSpinner.show(); nextUploader(); } private void nextUploader() { if (pendingUploaders.isEmpty()) { doneUploading(); return; } mSpinner.setTitle("Uploading (" + pendingUploaders.size() + ")"); final Uploader uploader = uploaders.get(pendingUploaders.iterator().next()); pendingUploaders.remove(uploader.getName()); doUpload(uploader); } private void doUpload(final Uploader uploader) { final ProgressDialog copySpinner = mSpinner; final SQLiteDatabase copyDB = mDBHelper.getWritableDatabase(); copySpinner.setMessage("Uploading " + uploader.getName()); new AsyncTask<Uploader, String, Uploader.Status>() { @Override protected Uploader.Status doInBackground(Uploader... params) { try { return params[0].upload(copyDB, mID); } catch (Exception ex) { ex.printStackTrace(); return Uploader.Status.ERROR; } } @Override protected void onPostExecute(Uploader.Status result) { switch (result) { case CANCEL: disableUploader(disableUploaderCallback, uploader, false); return; case SKIP: case ERROR: case INCORRECT_USAGE: nextUploader(); return; case OK: uploadOK(uploader, copySpinner, copyDB, mID); nextUploader(); return; case NEED_AUTH: // should be handled inside connect "loop" handleAuth(new Callback() { @Override public void run(String uploaderName, Uploader.Status status) { switch (status) { case CANCEL: disableUploader(disableUploaderCallback, uploader, false); return; case SKIP: case ERROR: case INCORRECT_USAGE: case NEED_AUTH: // should be handled inside // connect "loop" nextUploader(); return; case OK: doUpload(uploader); return; } } }, uploader, result.authMethod); return; } } }.execute(uploader); } private Callback disableUploaderCallback = new Callback() { @Override public void run(String uploader, Status status) { nextUploader(); } }; private void uploadOK(Uploader uploader, ProgressDialog copySpinner, SQLiteDatabase copyDB, long id) { copySpinner.setMessage("Saving"); ContentValues tmp = new ContentValues(); tmp.put(Constants.DB.EXPORT.ACCOUNT, uploader.getId()); tmp.put(Constants.DB.EXPORT.ACTIVITY, id); tmp.put(Constants.DB.EXPORT.STATUS, 0); copyDB.insert(Constants.DB.EXPORT.TABLE, null, tmp); } private void doneUploading() { mSpinner.dismiss(); final Callback cb = uploadCallback; uploadCallback = null; if (cb != null) cb.run(null, null); } public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode != CONFIGURE_REQUEST) return; handleAuthComplete(authUploader, authUploader.getAuthResult(resultCode, data)); } public void disableUploader(Callback disconnectCallback, String uploader, boolean clearUploads) { disableUploader(disconnectCallback, uploaders.get(uploader), clearUploads); } public void disableUploader(Callback callback, Uploader uploader, boolean clearUploads) { resetDB(callback, uploader, clearUploads); } void resetDB(final Callback callback, final Uploader uploader, final boolean clearUploads) { final String args[] = { Long.toString(uploader.getId()) }; ContentValues config = new ContentValues(); config.putNull(Constants.DB.ACCOUNT.AUTH_CONFIG); mDB.update(Constants.DB.ACCOUNT.TABLE, config, "_id = ?", args); if (clearUploads) { mDB.delete(Constants.DB.EXPORT.TABLE, Constants.DB.EXPORT.ACCOUNT + " = ?", args); } uploader.reset(); callback.run(uploader.getName(), Uploader.Status.OK); } public void clearUploads(Callback callback, String uploader) { final String args[] = { uploader }; mDB.delete(Constants.DB.EXPORT.TABLE, Constants.DB.EXPORT.ACCOUNT + " = ?", args); callback.run(uploader, Uploader.Status.OK); } public void clearUpload(String name, long id) { Uploader uploader = uploaders.get(name); if (uploader != null) { final String args[] = { Long.toString(uploader.getId()), Long.toString(id) }; mDB.delete(Constants.DB.EXPORT.TABLE, Constants.DB.EXPORT.ACCOUNT + " = ? AND " + Constants.DB.EXPORT.ACTIVITY + " = ?", args); } } public static class WorkoutRef { public WorkoutRef(String uploader, String key, String name) { this.uploader = uploader; this.workoutKey = key; this.workoutName = name; } public final String uploader; public final String workoutKey; public final String workoutName; }; Callback listWorkoutCallback = null; HashSet<String> pendingListWorkout = null; ArrayList<WorkoutRef> workoutRef = null; public void loadWorkoutList(ArrayList<WorkoutRef> workoutRef, Callback callback, HashSet<String> uploaders) { listWorkoutCallback = callback; pendingListWorkout = uploaders; this.workoutRef = workoutRef; mSpinner.setTitle("Loading workout list (" + pendingListWorkout.size() + ")"); mSpinner.show(); nextListWorkout(); } public void nextListWorkout() { if (pendingListWorkout.isEmpty()) { doneListing(); return; } mSpinner.setTitle("Loading workout list (" + pendingListWorkout.size() + ")"); Uploader uploader = uploaders.get(pendingListWorkout.iterator().next()); pendingListWorkout.remove(uploader.getName()); mSpinner.setMessage("Configure " + uploader.getName()); if (!uploader.isConfigured()) { nextListWorkout(); return; } doListWorkout(uploader); } protected void doListWorkout(final Uploader uploader) { final ProgressDialog copySpinner = mSpinner; copySpinner.setMessage("Listing from " + uploader.getName()); final ArrayList<Pair<String, String>> list = new ArrayList<Pair<String, String>>(); new AsyncTask<Uploader, String, Uploader.Status>() { @Override protected Uploader.Status doInBackground(Uploader... params) { try { return params[0].listWorkouts(list); } catch (Exception ex) { ex.printStackTrace(); return Uploader.Status.ERROR; } } @Override protected void onPostExecute(Uploader.Status result) { switch (result) { case CANCEL: case ERROR: case INCORRECT_USAGE: case SKIP: break; case OK: for (Pair<String, String> w : list) { workoutRef.add(new WorkoutRef(uploader.getName(), w.first, w.second)); } break; case NEED_AUTH: handleAuth(new Callback() { @Override public void run(String uploaderName, export.Uploader.Status status) { switch (status) { case CANCEL: case SKIP: case ERROR: case INCORRECT_USAGE: case NEED_AUTH: // should be handled inside // connect "loop" nextListWorkout(); break; case OK: doListWorkout(uploader); break; } } }, uploader, result.authMethod); return; } nextListWorkout(); } }.execute(uploader); } private void doneListing() { mSpinner.dismiss(); Callback cb = listWorkoutCallback; listWorkoutCallback = null; if (cb != null) cb.run(null, Status.OK); } public void loadWorkouts(final HashSet<WorkoutRef> pendingWorkouts, final Callback callback) { int cnt = pendingWorkouts.size(); mSpinner.setTitle("Downloading workouts (" + cnt + ")"); mSpinner.show(); new AsyncTask<String, String, Uploader.Status>() { @Override protected void onProgressUpdate(String... values) { mSpinner.setMessage("Loading " + values[0] + " from " + values[1]); } @Override protected Uploader.Status doInBackground(String... params0) { for (WorkoutRef ref : pendingWorkouts) { publishProgress(ref.workoutName, ref.uploader); Uploader uploader = uploaders.get(ref.uploader); //TODO Add back in from runnerup // File f = ActivitySerializer.getFile(context, ref.workoutName); //File w = f; //if (f.exists()) { //w = ActivitySerializer.getFile(context, ref.workoutName + ".tmp"); //} try { // uploader.downloadWorkout(w, ref.workoutKey); //if (w != f) { // if (compareFiles(w, f) != true) { // System.err.println("overwriting " + f.getPath() + " with " // + w.getPath()); // TODO dialog //f.delete(); //w.renameTo(f); //} else { // System.err.println("file identical...deleting temporary " // + w.getPath()); //w.delete(); //} //} } catch (Exception e) { e.printStackTrace(); //w.delete(); } } return Uploader.Status.OK; } @Override protected void onPostExecute(Uploader.Status result) { mSpinner.dismiss(); if (callback != null) { callback.run(null, Uploader.Status.OK); } } }.execute("string"); } public static boolean compareFiles(File w, File f) { if (w.length() != f.length()) return false; boolean cmp = true; FileInputStream f1 = null; FileInputStream f2 = null; try { f1 = new FileInputStream(w); f2 = new FileInputStream(f); byte buf1[] = new byte[1024]; byte buf2[] = new byte[1024]; do { int cnt1 = f1.read(buf1); int cnt2 = f2.read(buf2); if (cnt1 <= 0 || cnt2 <= 0) break; if (!java.util.Arrays.equals(buf1, buf2)) { cmp = false; break; } } while (true); } catch (Exception ex) { } if (f1 != null) { try { f1.close(); } catch (IOException e) { e.printStackTrace(); } } if (f2 != null) { try { f2.close(); } catch (IOException e) { e.printStackTrace(); } } return cmp; } /** * Load uploader private data * * @param uploader * @return * @throws Exception */ String loadData(Uploader uploader) throws Exception { InputStream in = context.getAssets().open(uploader.getName() + ".data"); ByteArrayOutputStream out = new ByteArrayOutputStream(); String key = Encryption.calculateRFC2104HMAC("RunnerUp", uploader.getName()); Encryption.decrypt(in, out, key); return out.toString(); } /** * Get preferences * * @return */ public SharedPreferences getPreferences(Uploader uploader) { if (uploader == null) return PreferenceManager.getDefaultSharedPreferences(context); else return context.getSharedPreferences(uploader.getName(), Context.MODE_PRIVATE); } public Resources getResources() { return context.getResources(); } public Context getContext() { return context; } /** * Upload set of activities for a specific uploader */ ArrayList<Long> uploadActivities = null; Callback uploadWorkoutsCallback = null; StringBuffer cancelUploading = null; public void uploadWorkouts(Callback uploadCallback, String uploaderName, ArrayList<Long> list, final StringBuffer cancel) { mSpinner.setTitle("Uploading activities to " + uploaderName); mSpinner.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { synchronized (cancel) { cancel.append('t'); } mSpinner.setMessage("Cancelling...please wait"); } }); mSpinner.setCancelable(false); mSpinner.setCanceledOnTouchOutside(false); mSpinner.setMax(list.size()); load(uploaderName); final Uploader uploader = uploaders.get(uploaderName); if (uploader == null) { uploadCallback.run(uploaderName, Status.INCORRECT_USAGE); return; } cancelUploading = cancel; uploadWorkoutsCallback = uploadCallback; uploadActivities = list; mSpinner.show(); mSpinner.getButton(DialogInterface.BUTTON_NEGATIVE).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { synchronized (cancel) { cancel.append('t'); } mSpinner.setMessage("Cancelling...please wait"); } }); uploadNextActivity(uploader); } protected boolean checkCancel(StringBuffer cancel) { synchronized (cancel) { return cancel.length() > 0; } } void uploadNextActivity(final Uploader uploader) { if (checkCancel(cancelUploading)) { mSpinner.cancel(); uploadWorkoutsCallback.run(uploader.getName(), Uploader.Status.CANCEL); return; } if (uploadActivities.size() == 0) { mSpinner.cancel(); uploadWorkoutsCallback.run(uploader.getName(), Uploader.Status.OK); return; } mSpinner.setProgress(uploadActivities.size()); long id = uploadActivities.get(0); uploadActivities.remove(0); doUploadMulti(uploader, id); } private void doUploadMulti(final Uploader uploader, final long id) { final ProgressDialog copySpinner = mSpinner; final SQLiteDatabase copyDB = mDBHelper.getWritableDatabase(); copySpinner.setMessage(Long.toString(1 + uploadActivities.size()) + " remaining"); new AsyncTask<Uploader, String, Uploader.Status>() { @Override protected Uploader.Status doInBackground(Uploader... params) { try { return uploader.upload(copyDB, id); } catch (Exception ex) { ex.printStackTrace(); return Uploader.Status.ERROR; } } @Override protected void onPostExecute(Uploader.Status result) { switch (result) { case CANCEL: case ERROR: case INCORRECT_USAGE: case SKIP: break; case OK: uploadOK(uploader, copySpinner, copyDB, id); break; case NEED_AUTH: handleAuth(new Callback() { @Override public void run(String uploaderName, export.Uploader.Status status) { switch (status) { case CANCEL: case SKIP: case ERROR: case INCORRECT_USAGE: case NEED_AUTH: // should be handled inside // connect "loop" uploadActivities.clear(); uploadNextActivity(uploader); break; case OK: doUploadMulti(uploader, id); break; } } }, uploader, result.authMethod); break; } uploadNextActivity(uploader); } }.execute(uploader); } Callback feedCallback = null; Set<String> feedUploaders = null; FeedList feedList = null; StringBuffer feedCancel = null; public void syncronizeFeed(Callback cb, Set<String> uploaders, FeedList dst, StringBuffer cancel) { feedCallback = cb; feedUploaders = uploaders; feedList = dst; feedCancel = cancel; nextSyncFeed(); } void nextSyncFeed() { if (checkCancel(feedCancel)) { feedUploaders.clear(); } if (feedUploaders.isEmpty()) { Callback cb = feedCallback; feedCallback = null; cb.run(null, Uploader.Status.OK); return; } final String uploaderName = feedUploaders.iterator().next(); feedUploaders.remove(uploaderName); final Uploader uploader = uploaders.get(uploaderName); syncFeed(uploader); } void syncFeed(final Uploader uploader) { if (uploader == null) { nextSyncFeed(); return; } final FeedList.FeedUpdater feedUpdater = feedList.getUpdater(); feedUpdater.start(uploader.getName()); new AsyncTask<Uploader, String, Uploader.Status>() { @Override protected Uploader.Status doInBackground(Uploader... params) { try { return params[0].getFeed(feedUpdater); } catch (Exception ex) { ex.printStackTrace(); return Uploader.Status.ERROR; } } @Override protected void onPostExecute(Uploader.Status result) { if (result == Uploader.Status.OK) { feedUpdater.complete(); } else if (result == Uploader.Status.NEED_AUTH) { handleAuth(new Callback() { @Override public void run(String uploaderName, Uploader.Status s2) { if (s2 == Uploader.Status.OK) { syncFeed(uploader); } else { nextSyncFeed(); } } }, uploader, result.authMethod); return; } else { if (result.ex != null) result.ex.printStackTrace(); } nextSyncFeed(); } }.execute(uploader); } public void loadLiveLoggers(List<Uploader> liveLoggers) { liveLoggers.clear(); Resources res = getResources(); String key = "live update active"; if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(key, false) == false) { return; } String from[] = new String[] { "_id", Constants.DB.ACCOUNT.NAME, Constants.DB.ACCOUNT.AUTH_CONFIG, Constants.DB.ACCOUNT.FLAGS }; Cursor c = mDB.query(Constants.DB.ACCOUNT.TABLE, from, "( " + Constants.DB.ACCOUNT.FLAGS + "&" + (1 << Constants.DB.ACCOUNT.FLAG_LIVE) + ") != 0", null, null, null, null, null); if (c.moveToFirst()) { do { ContentValues config = DBHelper.get(c); Uploader u = add(config); if (u.isConfigured() && u.checkSupport(Uploader.Feature.LIVE)) { liveLoggers.add(u); } } while (c.moveToNext()); } c.close(); } }