Synchronize TagViewActivity with the v2 sync provider

astrid/plugin-src/com/todoroo/astrid/actfm/TagViewActivity.java

@@ -2,13 +2,10 @@ package com.todoroo.astrid.actfm;
 
 import greendroid.widget.AsyncImageView;
 
-import java.io.IOException;
-
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import android.app.ProgressDialog;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -16,7 +13,6 @@ import android.content.IntentFilter;
 import android.os.Bundle;
 import android.text.TextUtils;
 import android.util.DisplayMetrics;
-import android.util.Log;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MotionEvent;
@@ -50,9 +46,9 @@ import com.todoroo.astrid.core.SortHelper;
 import com.todoroo.astrid.dao.TaskDao.TaskCriteria;
 import com.todoroo.astrid.data.TagData;
 import com.todoroo.astrid.data.Task;
+import com.todoroo.astrid.helper.ProgressBarSyncResultCallback;
 import com.todoroo.astrid.service.TagDataService;
 import com.todoroo.astrid.tags.TagFilterExposer;
-import com.todoroo.astrid.tags.TagService;
 import com.todoroo.astrid.tags.TagService.Tag;
 import com.todoroo.astrid.welcome.HelpInfoPopover;
 
@@ -71,7 +67,7 @@ public class TagViewActivity extends TaskListActivity {
 
     private static final int REQUEST_CODE_SETTINGS = 0;
 
-    public static final String TOKEN_START_ACTIVITY = "startActivity";
+    public static final String TOKEN_START_ACTIVITY = "startActivity"; //$NON-NLS-1$
 
     private TagData tagData;
 
@@ -214,17 +210,6 @@ public class TagViewActivity extends TaskListActivity {
             cursor.close();
         }
 
-        if(tagData.getValue(TagData.REMOTE_ID) > 0) {
-            String fetchKey = LAST_FETCH_KEY + tagData.getId();
-            long lastFetchDate = Preferences.getLong(fetchKey, 0);
-            if(DateUtilities.now() > lastFetchDate + 300000L) {
-                refreshData(false, false);
-                Preferences.setLong(fetchKey, DateUtilities.now());
-            }
-        } else {
-            ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.TLA_no_items);
-        }
-
         setUpMembersGallery();
 
         super.onNewIntent(intent);
@@ -258,81 +243,33 @@ public class TagViewActivity extends TaskListActivity {
 
     // --------------------------------------------------------- refresh data
 
-    /** refresh the list with latest data from the web */
-    private void refreshData(final boolean manual, boolean bypassTagShow) {
-        final boolean noRemoteId = tagData.getValue(TagData.REMOTE_ID) == 0;
-
-        final ProgressDialog progressDialog;
-        if(manual && !noRemoteId)
-            progressDialog = DialogUtilities.progressDialog(this, getString(R.string.DLG_please_wait));
-        else
-            progressDialog = null;
 
-        Thread tagShowThread = new Thread(new Runnable() {
+    @Override
-            @SuppressWarnings("nls")
+    protected void initiateAutomaticSync() {
-            @Override
+        long lastAutoSync = Preferences.getLong(LAST_FETCH_KEY + tagData.getId(), 0);
-            public void run() {
+        if(DateUtilities.now() - lastAutoSync > DateUtilities.ONE_HOUR)
-                try {
+            refreshData(false);
-                    String oldName = tagData.getValue(TagData.NAME);
+    }
-                    actFmSyncService.fetchTag(tagData);
-
-                    DialogUtilities.dismissDialog(TagViewActivity.this, progressDialog);
-                    runOnUiThread(new Runnable() {
-                        @Override
-                        public void run() {
-                            if(noRemoteId && tagData.getValue(TagData.REMOTE_ID) > 0)
-                                refreshData(manual, true);
-                        }
-                    });
-
-                    if(!oldName.equals(tagData.getValue(TagData.NAME))) {
-                        TagService.getInstance().rename(oldName,
-                                tagData.getValue(TagData.NAME));
-                    }
-
-                } catch (IOException e) {
-                    Log.e("tag-view-activity", "error-fetching-task-io", e);
-                } catch (JSONException e) {
-                    Log.e("tag-view-activity", "error-fetching-task", e);
-                }
-            }
-        });
-        if(!bypassTagShow)
-            tagShowThread.start();
 
-        if(noRemoteId) {
+    /** refresh the list with latest data from the web */
-            ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.TLA_no_items);
+    private void refreshData(final boolean manual) {
-            return;
+        ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.DLG_loading);
-        }
 
-        setUpMembersGallery();
+        syncService.synchronizeList(tagData, manual, new ProgressBarSyncResultCallback(this,
-        actFmSyncService.fetchTasksForTag(tagData, manual, new Runnable() {
+                R.id.progressBar, new Runnable() {
             @Override
             public void run() {
-                runOnUiThread(new Runnable() {
+                setUpMembersGallery();
-                    @Override
+                loadTaskListContent(true);
-                    public void run() {
+                ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.TLA_no_items);
-                        loadTaskListContent(true);
-                        ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.TLA_no_items);
-                        DialogUtilities.dismissDialog(TagViewActivity.this, progressDialog);
-                    }
-                });
             }
-        });
+        }));
+        Preferences.setLong(LAST_FETCH_KEY + tagData.getId(), DateUtilities.now());
 
-        actFmSyncService.fetchUpdatesForTag(tagData, manual, new Runnable() {
+        final boolean noRemoteId = tagData.getValue(TagData.REMOTE_ID) == 0;
-            @Override
-            public void run() {
-                runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        //refreshUpdatesList();
-                        DialogUtilities.dismissDialog(TagViewActivity.this, progressDialog);
-                    }
-                });
-            }
-        });
 
+        if(noRemoteId && !manual)
+            ((TextView)taskListView.findViewById(android.R.id.empty)).setText(R.string.TLA_no_items);
     }
 
     private void setUpMembersGallery() {
@@ -479,7 +416,7 @@ public class TagViewActivity extends TaskListActivity {
                     //refreshUpdatesList();
                 }
             });
-            refreshData(false, true);
+            refreshData(false);
 
             NotificationManager nm = new AndroidNotificationManager(ContextManager.getContext());
             nm.cancel(tagData.getValue(TagData.REMOTE_ID).intValue());
@@ -528,7 +465,7 @@ public class TagViewActivity extends TaskListActivity {
         // handle my own menus
         switch (item.getItemId()) {
         case MENU_REFRESH_ID:
-            refreshData(true, false);
+            refreshData(true);
             return true;
         }
 

astrid/plugin-src/com/todoroo/astrid/actfm/sync/ActFmSyncV2Provider.java

@@ -16,12 +16,14 @@ import com.todoroo.andlib.sql.Criterion;
 import com.todoroo.andlib.sql.Query;
 import com.todoroo.andlib.utility.Preferences;
 import com.todoroo.astrid.dao.TaskDao.TaskCriteria;
+import com.todoroo.astrid.data.TagData;
 import com.todoroo.astrid.data.Task;
 import com.todoroo.astrid.service.AstridDependencyInjector;
 import com.todoroo.astrid.service.StartupService;
 import com.todoroo.astrid.service.SyncV2Service.SyncResultCallback;
 import com.todoroo.astrid.service.SyncV2Service.SyncV2Provider;
 import com.todoroo.astrid.service.TaskService;
+import com.todoroo.astrid.tags.TagService;
 
 /**
  * Exposes sync action
@@ -52,30 +54,30 @@ public class ActFmSyncV2Provider implements SyncV2Provider {
 
     private static final String LAST_TAG_FETCH_TIME = "actfm_lastTag"; //$NON-NLS-1$
 
-    // --- synchronize active
+    // --- synchronize active tasks
 
     @Override
     public void synchronizeActiveTasks(boolean manual,
             final SyncResultCallback callback) {
 
-        if(!manual)
-            return;
-
         callback.started();
-        callback.incrementMax(50);
+        callback.incrementMax(100);
 
         final AtomicInteger finisher = new AtomicInteger(2);
 
-        new Thread(tagFetcher(callback, finisher)).start();
+        startTagFetcher(callback, finisher);
 
         startTaskFetcher(manual, callback, finisher);
 
         pushQueued(callback, finisher);
+
+        callback.incrementProgress(50);
     }
 
-    private Runnable tagFetcher(final SyncResultCallback callback,
+    /** fetch changes to tags */
+    private void startTagFetcher(final SyncResultCallback callback,
             final AtomicInteger finisher) {
-        return new Runnable() {
+        new Thread(new Runnable() {
             @Override
             public void run() {
                 int time = Preferences.getInt(LAST_TAG_FETCH_TIME, 0);
@@ -92,9 +94,10 @@ public class ActFmSyncV2Provider implements SyncV2Provider {
                         callback.finished();
                 }
             }
-        };
+        }).start();
     }
 
+    /** @return runnable to fetch changes to tags */
     private void startTaskFetcher(final boolean manual, final SyncResultCallback callback,
             final AtomicInteger finisher) {
         actFmSyncService.fetchActiveTasks(manual, new Runnable() {
@@ -142,4 +145,90 @@ public class ActFmSyncV2Provider implements SyncV2Provider {
         }
     }
 
+    // --- synchronize list
+
+    @Override
+    public void synchronizeList(Object list, boolean manual,
+            final SyncResultCallback callback) {
+
+        if(!(list instanceof TagData))
+            return;
+
+        TagData tagData = (TagData) list;
+        final boolean noRemoteId = tagData.getValue(TagData.REMOTE_ID) == 0;
+
+        if(noRemoteId && !manual)
+            return;
+
+        callback.started();
+        callback.incrementMax(100);
+
+        final AtomicInteger finisher = new AtomicInteger(3);
+
+        fetchTagData(tagData, noRemoteId, manual, callback, finisher);
+
+        if(!noRemoteId) {
+            fetchTasksForTag(tagData, manual, callback, finisher);
+            fetchUpdatesForTag(tagData, manual, callback, finisher);
+        }
+
+        callback.incrementProgress(50);
+    }
+
+    private void fetchTagData(final TagData tagData, final boolean noRemoteId,
+            final boolean manual, final SyncResultCallback callback,
+            final AtomicInteger finisher) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                String oldName = tagData.getValue(TagData.NAME);
+                try {
+                    actFmSyncService.fetchTag(tagData);
+
+                    if(noRemoteId) {
+                        fetchTasksForTag(tagData, manual, callback, finisher);
+                        fetchUpdatesForTag(tagData, manual, callback, finisher);
+                    }
+
+                    if(!oldName.equals(tagData.getValue(TagData.NAME))) {
+                        TagService.getInstance().rename(oldName,
+                                tagData.getValue(TagData.NAME));
+                    }
+                } catch (IOException e) {
+                    exceptionService.reportError("sync-io", e); //$NON-NLS-1$
+                } catch (JSONException e) {
+                    exceptionService.reportError("sync-json", e); //$NON-NLS-1$
+                } finally {
+                    callback.incrementProgress(20);
+                    if(finisher.decrementAndGet() == 0)
+                        callback.finished();
+                }
+            }
+        }).start();
+    }
+
+    private void fetchUpdatesForTag(TagData tagData, boolean manual, final SyncResultCallback callback,
+            final AtomicInteger finisher) {
+        actFmSyncService.fetchUpdatesForTag(tagData, manual, new Runnable() {
+            @Override
+            public void run() {
+                callback.incrementProgress(20);
+                if(finisher.decrementAndGet() == 0)
+                    callback.finished();
+            }
+        });
+    }
+
+    private void fetchTasksForTag(TagData tagData, boolean manual, final SyncResultCallback callback,
+            final AtomicInteger finisher) {
+        actFmSyncService.fetchTasksForTag(tagData, manual, new Runnable() {
+            @Override
+            public void run() {
+                callback.incrementProgress(30);
+                if(finisher.decrementAndGet() == 0)
+                    callback.finished();
+            }
+        });
+    }
+
 }

astrid/src/com/todoroo/astrid/activity/TaskListActivity.java

@@ -42,7 +42,6 @@ import android.view.View.OnLongClickListener;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowManager;
-import android.view.animation.AlphaAnimation;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.AbsListView;
@@ -54,7 +53,6 @@ import android.widget.ImageButton;
 import android.widget.ImageView;
 import android.widget.ListView;
 import android.widget.PopupWindow.OnDismissListener;
-import android.widget.ProgressBar;
 import android.widget.TextView;
 import android.widget.TextView.OnEditorActionListener;
 import android.widget.Toast;
@@ -96,6 +94,7 @@ import com.todoroo.astrid.data.Metadata;
 import com.todoroo.astrid.data.Task;
 import com.todoroo.astrid.gcal.GCalHelper;
 import com.todoroo.astrid.helper.MetadataHelper;
+import com.todoroo.astrid.helper.ProgressBarSyncResultCallback;
 import com.todoroo.astrid.helper.TaskListContextMenuExtensionLoader;
 import com.todoroo.astrid.helper.TaskListContextMenuExtensionLoader.ContextMenuItem;
 import com.todoroo.astrid.reminders.ReminderDebugContextActions;
@@ -106,7 +105,6 @@ import com.todoroo.astrid.service.StartupService;
 import com.todoroo.astrid.service.StatisticsConstants;
 import com.todoroo.astrid.service.StatisticsService;
 import com.todoroo.astrid.service.SyncV2Service;
-import com.todoroo.astrid.service.SyncV2Service.SyncResultCallback;
 import com.todoroo.astrid.service.TagDataService;
 import com.todoroo.astrid.service.TaskService;
 import com.todoroo.astrid.service.ThemeService;
@@ -599,9 +597,7 @@ public class TaskListActivity extends ListActivity implements OnScrollListener,
             Preferences.setBoolean(R.string.p_showed_lists_help, true);
         }
 
-        if (filter.title != null && filter.title.equals(getString(R.string.BFE_Active))) {
+        initiateAutomaticSync();
-            initiateAutomaticSync();
-        }
     }
 
     @Override
@@ -1119,99 +1115,30 @@ public class TaskListActivity extends ListActivity implements OnScrollListener,
         }
     }
 
-    private class TaskListSyncResultCallback implements SyncResultCallback {
-
-        private final ProgressBar progressBar;
-        private int providers = 0;
-
-        public TaskListSyncResultCallback() {
-            progressBar = (ProgressBar) findViewById(R.id.progressBar);
-            progressBar.setProgress(0);
-            progressBar.setMax(0);
-        }
-
-        @Override
-        public void finished() {
-            providers--;
-            if(providers == 0) {
-                runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        progressBar.setMax(100);
-                        progressBar.setProgress(100);
-                        AlphaAnimation animation = new AlphaAnimation(1, 0);
-                        animation.setFillAfter(true);
-                        animation.setDuration(1000L);
-                        progressBar.startAnimation(animation);
-
-                        loadTaskListContent(true);
-                    }
-                });
-                new Thread() {
-                    @Override
-                    public void run() {
-                        AndroidUtilities.sleepDeep(1000);
-                        runOnUiThread(new Runnable() {
-                            @Override
-                            public void run() {
-                                progressBar.setVisibility(View.GONE);
-                            }
-                        });
-                    }
-                }.start();
-            }
-        }
-
-        @Override
-        public void incrementMax(final int incrementBy) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    progressBar.setMax(progressBar.getMax() + incrementBy);
-                }
-            });
-        }
-
-        @Override
-        public void incrementProgress(final int incrementBy) {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    progressBar.incrementProgressBy(incrementBy);
-                }
-            });
-        }
-
-        @Override
-        public void started() {
-            if(providers == 0) {
-                runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        progressBar.setVisibility(View.VISIBLE);
-                        AlphaAnimation animation = new AlphaAnimation(0, 1);
-                        animation.setFillAfter(true);
-                        animation.setDuration(1000L);
-                        progressBar.startAnimation(animation);
-                    }
-                });
-            }
-
-            providers++;
-        }
-    }
-
     private static final String PREF_LAST_AUTO_SYNC = "taskListLastAutoSync"; //$NON-NLS-1$
 
-    private void initiateAutomaticSync() {
+    protected void initiateAutomaticSync() {
+        if (filter.title == null || !filter.title.equals(getString(R.string.BFE_Active)))
+            return;
+
         long lastAutoSync = Preferences.getLong(PREF_LAST_AUTO_SYNC, 0);
         if(DateUtilities.now() - lastAutoSync > DateUtilities.ONE_HOUR) {
-            syncService.synchronizeActiveTasks(false, new TaskListSyncResultCallback());
+            performSyncServiceV2Sync(false);
-            Preferences.setLong(PREF_LAST_AUTO_SYNC, DateUtilities.now());
         }
     }
 
-    private void performSyncAction() {
+    protected void performSyncServiceV2Sync(boolean manual) {
+        syncService.synchronizeActiveTasks(manual, new ProgressBarSyncResultCallback(this,
+                R.id.progressBar, new Runnable() {
+            @Override
+            public void run() {
+                loadTaskListContent(true);
+            }
+        }));
+        Preferences.setLong(PREF_LAST_AUTO_SYNC, DateUtilities.now());
+    }
+
+    protected void performSyncAction() {
         if (syncActions.size() == 0 && !syncService.isActive()) {
             String desiredCategory = getString(R.string.SyP_label);
 
@@ -1254,8 +1181,7 @@ public class TaskListActivity extends ListActivity implements OnScrollListener,
             showSyncOptionMenu(actions, listener);
         }
         else {
-            syncService.synchronizeActiveTasks(true, new TaskListSyncResultCallback());
+            performSyncServiceV2Sync(true);
-            Preferences.setLong(PREF_LAST_AUTO_SYNC, DateUtilities.now());
 
             if(syncActions.size() > 0) {
                 for(SyncAction syncAction : syncActions) {

astrid/src/com/todoroo/astrid/helper/ProgressBarSyncResultCallback.java

@@ -0,0 +1,96 @@
+package com.todoroo.astrid.helper;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.animation.AlphaAnimation;
+import android.widget.ProgressBar;
+
+import com.todoroo.andlib.utility.AndroidUtilities;
+import com.todoroo.astrid.service.SyncV2Service.SyncResultCallback;
+
+public class ProgressBarSyncResultCallback implements SyncResultCallback {
+
+    private final ProgressBar progressBar;
+    private final Activity activity;
+    private final Runnable onFinished;
+
+    private final AtomicInteger providers = new AtomicInteger(0);
+
+    public ProgressBarSyncResultCallback(Activity activity,
+            int progressBarId, Runnable onFinished) {
+        this.progressBar = (ProgressBar) activity.findViewById(progressBarId);
+        this.activity = activity;
+        this.onFinished = onFinished;
+        progressBar.setProgress(0);
+        progressBar.setMax(0);
+    }
+
+    @Override
+    public void finished() {
+        if(providers.decrementAndGet() == 0) {
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    progressBar.setMax(100);
+                    progressBar.setProgress(100);
+                    AlphaAnimation animation = new AlphaAnimation(1, 0);
+                    animation.setFillAfter(true);
+                    animation.setDuration(1000L);
+                    progressBar.startAnimation(animation);
+
+                    onFinished.run();
+                }
+            });
+            new Thread() {
+                @Override
+                public void run() {
+                    AndroidUtilities.sleepDeep(1000);
+                    activity.runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            progressBar.setVisibility(View.GONE);
+                        }
+                    });
+                }
+            }.start();
+        }
+    }
+
+    @Override
+    public void incrementMax(final int incrementBy) {
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                progressBar.setMax(progressBar.getMax() + incrementBy);
+            }
+        });
+    }
+
+    @Override
+    public void incrementProgress(final int incrementBy) {
+        activity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                progressBar.incrementProgressBy(incrementBy);
+            }
+        });
+    }
+
+    @Override
+    public void started() {
+        if(providers.incrementAndGet() == 1) {
+            activity.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    progressBar.setVisibility(View.VISIBLE);
+                    AlphaAnimation animation = new AlphaAnimation(0, 1);
+                    animation.setFillAfter(true);
+                    animation.setDuration(1000L);
+                    progressBar.startAnimation(animation);
+                }
+            });
+        }
+    }
+}

astrid/src/com/todoroo/astrid/service/SyncV2Service.java

@@ -38,6 +38,7 @@ public class SyncV2Service {
     public interface SyncV2Provider {
         public boolean isActive();
         public void synchronizeActiveTasks(boolean manual, SyncResultCallback callback);
+        public void synchronizeList(Object list, boolean manual, SyncResultCallback callback);
     }
 
     /*
@@ -75,4 +76,18 @@ public class SyncV2Service {
         }
     }
 
+    /**
+     * Initiate synchronization of task list
+     *
+     * @param list list object
+     * @param manual if manual sync
+     * @param callback result callback
+     */
+    public void synchronizeList(Object list, boolean manual, SyncResultCallback callback) {
+        for(SyncV2Provider provider : providers) {
+            if(provider.isActive())
+                provider.synchronizeList(list, manual, callback);
+        }
+    }
+
 }