Docks for RefreshCoursesAction.

Author: samutamm

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

@@ -30,7 +30,6 @@ public final class RefreshCoursesAction {
     private CourseDb courseDb;
     private ConvenientDialogDisplayer dialogs;
 
-    //private BgTaskListenerList<List<Course>> listeners;
     private FutureCallbackList<List<Course>> callbacks;
     private final TmcCore tmcCore;
     private final NBTmcSettings tmcSettings;
@@ -61,47 +60,62 @@ public RefreshCoursesAction addListener(FutureCallback<List<Course>> callbacks)
         return this;
     }
 
-    //HUOM metodissa oldRun on vanha toteutus. Se hakee palvelmelta nykyisen kurssin "fullcourse info".
+    /**
+     * Starts downloading course-jsons from TMC-server.
+     * Url of TMC-server is defined in TmcSettings object.
+     * TmcCore includes all logic, callbacks here are run after core-futures are ready.
+     */
     public void run() {
         try {
             ListenableFuture<List<Course>> listCourses = this.tmcCore.listCourses(tmcSettings);
-            Futures.addCallback(listCourses, new FutureCallback<List<Course>>() {
-                @Override
-                public void onSuccess(final List<Course> courses) {
-                    Course currentCourse = CourseListUtils.getCourseByName(courses, courseDb.getCurrentCourseName());
-                    if (currentCourse != null) {
-                        try {
-                            ListenableFuture<Course> courseFuture = tmcCore.getCourse(tmcSettings, currentCourse.getDetailsUrl());
-                            Futures.addCallback(courseFuture, new UpdateCourse(courses));
-                        } catch (TmcCoreException ex) {
-                            Exceptions.printStackTrace(ex);
-                            callbacks.onFailure(ex);
-                        }
-                    } else {
-                        callbacks.onSuccess(courses);
-                    }
-                }
+            Futures.addCallback(listCourses, new LoadCourses());
+        } catch (TmcCoreException ex) {
+            Exceptions.printStackTrace(ex);
+            callbacks.onFailure(ex);
+        }
+    }
 
-                @Override
-                public void onFailure(Throwable ex) {
-                    log.log(Level.INFO, "Failed to download current course info.", ex);
+    /**
+     * This callBack is run when ListenableFuture (to witch this is attached) is done.
+     * On success method takes list of Course-objects, searches the current course and starts uploading
+     * the details of the course.
+     * If no currentCourse found, no need to update details.
+     */
+    class LoadCourses implements FutureCallback<List<Course>> {
+        @Override
+        public void onSuccess(final List<Course> courses) {
+            Course currentCourse = CourseListUtils.getCourseByName(courses, courseDb.getCurrentCourseName());
+            if (currentCourse != null) {
+                try {
+                    ListenableFuture<Course> courseFuture = tmcCore.getCourse(tmcSettings, currentCourse.getDetailsUrl());
+                    Futures.addCallback(courseFuture, new UpdateCourse(courses));
+                } catch (TmcCoreException ex) {
+                    Exceptions.printStackTrace(ex);
                     callbacks.onFailure(ex);
                 }
+            } else {
+                callbacks.onSuccess(courses);
             }
-            );
-        } catch (TmcCoreException ex) {
-            Exceptions.printStackTrace(ex);
+        }
+
+        @Override
+        public void onFailure(Throwable ex) {
+            log.log(Level.INFO, "Failed to download current course info.", ex);
             callbacks.onFailure(ex);
         }
     }
 
+    /**
+     * When detailed current course is present, courses will be given to FutureCallbackList,
+     * that shares the result to every callback that is attached to that list.
+     */
     class UpdateCourse implements FutureCallback<Course> {
-        
         List<Course> courses;
-        public UpdateCourse(List<Course> courses){
+        
+        public UpdateCourse(List<Course> courses) {
             this.courses = courses;
         }
-        
+
         @Override
         public void onSuccess(Course detailedCourse) {
             detailedCourse.setExercisesLoaded(true);
@@ -123,6 +137,9 @@ public void onFailure(Throwable ex) {
         }
     }
 
+    /**
+     * Updates the courseDb after all course-jsons are downloaded.
+     */
     private class DefaultListener implements FutureCallback<List<Course>> {
 
         private final boolean showDialogOnError;
@@ -132,7 +149,7 @@ public DefaultListener(boolean showDialogOnError, boolean updateCourseDb) {
             this.showDialogOnError = showDialogOnError;
             this.updateCourseDb = updateCourseDb;
         }
-        
+
         @Override
         public void onSuccess(List<Course> result) {
             if (updateCourseDb) {

tmc-plugin/src/fi/helsinki/cs/tmc/utilities/FutureCallbackList.java

@@ -2,11 +2,16 @@
 package fi.helsinki.cs.tmc.utilities;
 
 import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
 import java.util.List;
 
-
+/**
+ * When multiple listeners/callback are needed for one action, they should be added to 
+ * FutureCallbackList.
+ * Then the first callback can execute the rest by onSuccess method.
+ * 
+ * @param <T> can be any Object defined by the return value of the ListenableFuture.
+ */
 public class FutureCallbackList<T> {
 
     private List<FutureCallback<T>> callbacks;
@@ -19,12 +24,19 @@ public void addListener(FutureCallback<T> callback) {
         this.callbacks.add(callback);
     }
 
+    /**
+     * Calls the onSuccess of all callbacks.
+     * @param result that should be shared to all callbacks.
+     */
     public void onSuccess(T result) {
         for (FutureCallback<T> callback : callbacks) {
             callback.onSuccess(result);
         }
     }
 
+    /**
+     * Calls the onFailure of all callbacks.
+     */
     public void onFailure(Throwable ex) {
         for (FutureCallback<T> callback : callbacks) {
             callback.onFailure(ex);