Migrating tasks to use BgTask

Author: jamo

tmc-plugin/src/fi/helsinki/cs/tmc/actions/CheckForNewExercisesOrUpdates.java

@@ -1,41 +1,41 @@
 package fi.helsinki.cs.tmc.actions;
 
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+import static java.util.logging.Level.INFO;
+
 import fi.helsinki.cs.tmc.core.domain.Course;
 import fi.helsinki.cs.tmc.model.CourseDb;
 import fi.helsinki.cs.tmc.model.LocalExerciseStatus;
 import fi.helsinki.cs.tmc.model.ObsoleteClientException;
-import fi.helsinki.cs.tmc.model.NBTmcSettings;
-import fi.helsinki.cs.tmc.model.ServerAccess;
+import fi.helsinki.cs.tmc.model.NbTmcSettings;
 import fi.helsinki.cs.tmc.model.TmcCoreSingleton;
 import fi.helsinki.cs.tmc.ui.DownloadOrUpdateExercisesDialog;
 import fi.helsinki.cs.tmc.ui.ConvenientDialogDisplayer;
 import fi.helsinki.cs.tmc.ui.TmcNotificationDisplayer;
 import fi.helsinki.cs.tmc.utilities.Inflector;
 import fi.helsinki.cs.tmc.utilities.TmcStringUtils;
 import fi.helsinki.cs.tmc.core.TmcCore;
-import fi.helsinki.cs.tmc.core.domain.Exercise;
-import fi.helsinki.cs.tmc.core.exceptions.TmcCoreException;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.net.URI;
-import java.util.ArrayList;
-import javax.swing.AbstractAction;
-import javax.swing.Icon;
-import javax.swing.SwingUtilities;
+import fi.helsinki.cs.tmc.utilities.BgTask;
+import fi.helsinki.cs.tmc.utilities.BgTaskListener;
+import fi.helsinki.cs.tmc.utilities.CancellableCallable;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
 import org.apache.commons.lang3.StringUtils;
-import org.netbeans.api.progress.ProgressHandle;
-import org.netbeans.api.progress.ProgressHandleFactory;
+
 import org.openide.awt.ActionID;
 import org.openide.awt.ActionReference;
 import org.openide.awt.ActionReferences;
 import org.openide.awt.ActionRegistration;
-import org.openide.util.Exceptions;
 import org.openide.util.ImageUtilities;
 import org.openide.util.NbBundle.Messages;
 
+import java.util.logging.Logger;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import javax.swing.AbstractAction;
+import javax.swing.Icon;
+
 @ActionID(category = "TMC",
         id = "fi.helsinki.cs.tmc.actions.CheckForNewExercisesOrUpdates")
 @ActionRegistration(displayName = "#CTL_CheckForNewExercisesOrUpdates")
@@ -52,14 +52,16 @@ public static void startTimer() {
         timer.start();
     }
 
+    private static final Logger logger = Logger.getLogger(CheckForNewExercisesOrUpdates.class.getName());
+
     private static final TmcNotificationDisplayer.SingletonToken notifierToken = TmcNotificationDisplayer.createSingletonToken();
 
     private CourseDb courseDb;
     private TmcNotificationDisplayer notifier;
     private ConvenientDialogDisplayer dialogs;
     private boolean beQuiet;
     private boolean backgroundCheck;
-    private TmcCore tmcCore;
+    private final TmcCore tmcCore;
 
     public CheckForNewExercisesOrUpdates() {
         this(false, false);
@@ -76,118 +78,80 @@ public CheckForNewExercisesOrUpdates(boolean beQuiet, boolean backgroundCheck) {
 
     @Override
     public void actionPerformed(ActionEvent e) {
+        logger.info("action performed");
         run();
     }
 
     public void run() {
-        try {
-            final Course currentCourseBeforeUpdate = courseDb.getCurrentCourse();
-            if (backgroundProcessingOrNoCurrentCourse(currentCourseBeforeUpdate)) {
-                return;
-            }
-            ProgressHandle exerciseRefresh = ProgressHandleFactory.createSystemHandle(
-                    "Checking for new exercises");
-            exerciseRefresh.start();
-            ListenableFuture<Course> currentCourseFuture = this.tmcCore.getCourse(
-                    detailUrl(currentCourseBeforeUpdate)
-            );
-            Futures.addCallback(currentCourseFuture, new UpdateCourseForExerciseUpdate(exerciseRefresh));
-        } catch (TmcCoreException ex) {
-            Exceptions.printStackTrace(ex);
-        }
-    }
+        final Course currentCourseBeforeUpdate = courseDb.getCurrentCourse();
 
-    private URI detailUrl(final Course currentCourseBeforeUpdate) {
-        return URI.create(new ServerAccess().addApiCallQueryParameters(
-                currentCourseBeforeUpdate.getDetailsUrl()));
-    }
-
-    /**
-     * If there is something at background or no current course is chosen,
-     * return true.
-     */
-    private boolean backgroundProcessingOrNoCurrentCourse(final Course currentCourseBeforeUpdate) {
-        if (backgroundCheck && !NBTmcSettings.getDefault().isCheckingForUpdatesInTheBackground()) {
-            return true;
+        if (backgroundCheck && !NbTmcSettings.getDefault().isCheckingForUpdatesInTheBackground()) {
+            return;
         }
+
         if (currentCourseBeforeUpdate == null) {
             if (!beQuiet) {
                 dialogs.displayMessage("Please select a course in TMC -> Settings.");
             }
-            return true;
+            return;
         }
-        return false;
-    }
 
-    class UpdateCourseForExerciseUpdate implements FutureCallback<Course> {
+        BgTaskListener bgTaskListener = new BgTaskListener<Course>() {
+            @Override
+            public void bgTaskReady(Course receivedCourse) {
+                if (receivedCourse != null) {
 
-        private ProgressHandle lastAction;
+                    courseDb.putDetailedCourse(receivedCourse);
 
-        /**
-         * This should be attached to listenableFuture. When future is ready,
-         * receivedCourse will be saved to courseDb and view will be updated.
-         */
-        public UpdateCourseForExerciseUpdate(ProgressHandle lastAction) {
-            this.lastAction = lastAction;
-        }
+                    final LocalExerciseStatus status = LocalExerciseStatus.get(receivedCourse.getExercises());
 
-        @Override
-        public void onSuccess(final Course receivedCourse) {
-            SwingUtilities.invokeLater(new Runnable() {
-
-                @Override
-                public void run() {
-                    lastAction.finish();
-                    if (receivedCourse != null) {
-                        setCourseNameToAllExercises(receivedCourse);
-                        courseDb.putDetailedCourse(receivedCourse);
-                        final LocalExerciseStatus status = LocalExerciseStatus.get(receivedCourse.getExercises());
-                        updateGUI(status);
+                    if (status.thereIsSomethingToDownload(false)) {
+                        if (beQuiet) {
+                            displayNotification(status, new ActionListener() {
+                                @Override
+                                public void actionPerformed(ActionEvent e) {
+                                    DownloadOrUpdateExercisesDialog.display(status.unlockable, status.downloadableUncompleted, status.updateable);
+                                }
+                            });
+                        } else {
+                            DownloadOrUpdateExercisesDialog.display(status.unlockable, status.downloadableUncompleted, status.updateable);
+                        }
+                    } else if (!beQuiet) {
+                        dialogs.displayMessage("No new exercises or updates to download.");
                     }
                 }
+            }
 
-            });
-
-        }
-
-        private void setCourseNameToAllExercises(Course receivedCourse) {
-            for (Exercise exercise : receivedCourse.getExercises()) {
-                exercise.setCourseName(receivedCourse.getName());
+            @Override
+            public void bgTaskCancelled() {
             }
-        }
 
-        private void updateGUI(final LocalExerciseStatus status) {
-            boolean thereIsSomethingToDownload = status.thereIsSomethingToDownload(false);
-            if (thereIsSomethingToDownload) {
-                if (beQuiet) {
-                    displayNotification(status, new ActionListener() {
-                        @Override
-                        public void actionPerformed(ActionEvent e) {
-                            DownloadOrUpdateExercisesDialog.display(status.unlockable, status.downloadableUncompleted, status.updateable);
-                        }
-                    });
-                } else {
-                    DownloadOrUpdateExercisesDialog.display(status.unlockable, status.downloadableUncompleted, status.updateable);
+            @Override
+            public void bgTaskFailed(Throwable ex) {
+                if (!beQuiet || ex instanceof ObsoleteClientException) {
+                    dialogs.displayError("Failed to check for new exercises.\n" + ServerErrorHelper.getServerExceptionMsg(ex));
                 }
-            } else if (!beQuiet) {
-                dialogs.displayMessage("No new exercises or updates to download.");
             }
-        }
+        };
 
-        @Override
-        public void onFailure(final Throwable ex) {
-            SwingUtilities.invokeLater(new Runnable() {
+        BgTask.start("Checking for new exercises", new CancellableCallable<Course>() {
+            ListenableFuture<Course> currentCourseFuture;
 
-                @Override
-                public void run() {
-                    lastAction.finish();
-                    if (!beQuiet || ex instanceof ObsoleteClientException) {
-                        dialogs.displayError("Failed to check for new exercises.\n" + ServerErrorHelper.getServerExceptionMsg(ex));
-                    }
-                }
+            @Override
+            public Course call() throws Exception {
+                logger.info("1Downloading course to refresh cache");
+
+                currentCourseFuture = tmcCore.getCourse(currentCourseBeforeUpdate.getDetailsUrlAsUri());
+                return currentCourseFuture.get();
+            }
+
+            @Override
+            public boolean cancel() {
+                logger.log(INFO, "Get course (refresh list) cancelled.");
+                return currentCourseFuture.cancel(true);
+            }
+        }, bgTaskListener);
 
-            });
-        }
     }
 
     private void displayNotification(LocalExerciseStatus status, ActionListener action) {
@@ -224,4 +188,4 @@ private void displayNotification(LocalExerciseStatus status, ActionListener acti
     private Icon getNotificationIcon() {
         return ImageUtilities.loadImageIcon("fi/helsinki/cs/tmc/smile.gif", false);
     }
-}
+}

tmc-plugin/src/fi/helsinki/cs/tmc/actions/CheckForNewReviews.java

@@ -6,7 +6,7 @@
 import fi.helsinki.cs.tmc.core.domain.Course;
 import fi.helsinki.cs.tmc.core.domain.Review;
 import fi.helsinki.cs.tmc.model.CourseDb;
-import fi.helsinki.cs.tmc.model.NBTmcSettings;
+import fi.helsinki.cs.tmc.model.NbTmcSettings;
 import fi.helsinki.cs.tmc.model.ReviewDb;
 import fi.helsinki.cs.tmc.model.TmcCoreSingleton;
 import fi.helsinki.cs.tmc.ui.ConvenientDialogDisplayer;
@@ -79,6 +79,7 @@ public void actionPerformed(ActionEvent e) {
 
     @Override
     public void run() {
+        // TODO(jamo): use bg task
         if (resetNotifications) {
             reviewDb.forgetReviewsNotifiedAbout();
         }

tmc-plugin/src/fi/helsinki/cs/tmc/actions/CheckForUnopenedExercises.java

@@ -4,7 +4,7 @@
 import fi.helsinki.cs.tmc.model.CourseDb;
 import fi.helsinki.cs.tmc.model.ProjectMediator;
 import fi.helsinki.cs.tmc.model.TmcProjectInfo;
-import fi.helsinki.cs.tmc.model.NBTmcSettings;
+import fi.helsinki.cs.tmc.model.NbTmcSettings;
 import fi.helsinki.cs.tmc.ui.TmcNotificationDisplayer;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -16,7 +16,7 @@
 
 public class CheckForUnopenedExercises implements ActionListener {
     public static boolean shouldRunOnStartup() {
-        return NBTmcSettings.getDefault().isCheckingForUnopenedAtStartup();
+        return NbTmcSettings.getDefault().isCheckingForUnopenedAtStartup();
     }
 
     private static final TmcNotificationDisplayer.SingletonToken notifierToken = TmcNotificationDisplayer.createSingletonToken();
@@ -37,6 +37,7 @@ public void actionPerformed(ActionEvent e) {
     }
 
     public void run() {
+        // TODO(jamo): use bg task
         projects.callWhenProjectsCompletelyOpened(new Runnable() {
             @Override
             public void run() {

tmc-plugin/src/fi/helsinki/cs/tmc/actions/DownloadCompletedExercises.java

@@ -40,6 +40,7 @@ public DownloadCompletedExercises() {
 
     @Override
     public void actionPerformed(ActionEvent e) {
+        // TODO(jamo): use bg task
         final Course currentCourse = courseDb.getCurrentCourse();
         if (currentCourse == null) {
             dialogs.displayMessage("Please select a course in TMC -> Settings.");
@@ -48,10 +49,10 @@ public void actionPerformed(ActionEvent e) {
 
         RefreshCoursesAction action = new RefreshCoursesAction();
         action.addDefaultListener(true, true);
-        action.addListener(new FutureCallback<List<Course>>() {
+        action.addListener(new BgTaskListener<List<Course>>() {
 
             @Override
-            public void onSuccess(List<Course> receivedCourseList) {
+            public void bgTaskReady(List<Course> result) {
                 LocalExerciseStatus status = LocalExerciseStatus.get(courseDb.getCurrentCourseExercises());
                 if (!status.downloadableCompleted.isEmpty()) {
                     List<Exercise> emptyList = Collections.emptyList();
@@ -62,10 +63,14 @@ public void onSuccess(List<Course> receivedCourseList) {
             }
 
             @Override
-            public void onFailure(Throwable ex) {
+            public void bgTaskCancelled() {
+            }
+
+            @Override
+            public void bgTaskFailed(Throwable ex) {
                 dialogs.displayError("Failed to check for new exercises.\n" + ServerErrorHelper.getServerExceptionMsg(ex));
             }
         });
         action.run();
     }
-}
+}