fix: fix progress callbacks is missing for DownloadListener1, Downloa…

…dListener4, DownloadListener4WithSpeed when you re-attach one of them to UnifiedListenerManager manually

closes #52

okdownload/src/main/java/com/liulishuo/okdownload/UnifiedListenerManager.java

@@ -23,6 +23,7 @@
 import com.liulishuo.okdownload.core.breakpoint.BreakpointInfo;
 import com.liulishuo.okdownload.core.cause.EndCause;
 import com.liulishuo.okdownload.core.cause.ResumeFailedCause;
+import com.liulishuo.okdownload.core.listener.assist.ListenerAssist;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -91,6 +92,9 @@ public synchronized void attachListener(@NonNull DownloadTask task,
 
         if (!listenerList.contains(listener)) {
             listenerList.add(listener);
+            if (listener instanceof ListenerAssist) {
+                ((ListenerAssist) listener).setAlwaysRecoverAssistModelIfNotSet(true);
+            }
         }
     }
 

okdownload/src/main/java/com/liulishuo/okdownload/core/listener/DownloadListener1.java

@@ -25,6 +25,7 @@
 import com.liulishuo.okdownload.core.cause.EndCause;
 import com.liulishuo.okdownload.core.cause.ResumeFailedCause;
 import com.liulishuo.okdownload.core.listener.assist.Listener1Assist;
+import com.liulishuo.okdownload.core.listener.assist.ListenerAssist;
 
 import java.util.List;
 import java.util.Map;
@@ -33,7 +34,7 @@
  * taskStart->(retry)->connect->progress<-->progress(currentOffset)->taskEnd
  */
 public abstract class DownloadListener1 implements DownloadListener,
-        Listener1Assist.Listener1Callback {
+        Listener1Assist.Listener1Callback, ListenerAssist {
     final Listener1Assist assist;
 
     DownloadListener1(Listener1Assist assist) {
@@ -45,6 +46,18 @@ public DownloadListener1() {
         this(new Listener1Assist());
     }
 
+    @Override public boolean isAlwaysRecoverAssistModel() {
+        return assist.isAlwaysRecoverAssistModel();
+    }
+
+    @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) {
+        assist.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel);
+    }
+
+    @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) {
+        assist.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel);
+    }
+
     @Override public final void taskStart(@NonNull DownloadTask task) {
         assist.taskStart(task);
     }
@@ -66,7 +79,7 @@ public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull Breakpoin
 
     @Override
     public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) {
-        assist.downloadFromBreakpoint(task.getId(), info);
+        assist.downloadFromBreakpoint(task, info);
     }
 
     @Override public void connectStart(@NonNull DownloadTask task, int blockIndex,
@@ -95,6 +108,5 @@ public final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
                               @Nullable Exception realCause) {
         assist.taskEnd(task, cause, realCause);
     }
-
 }
 

okdownload/src/main/java/com/liulishuo/okdownload/core/listener/DownloadListener4.java

@@ -25,6 +25,8 @@
 import com.liulishuo.okdownload.core.cause.EndCause;
 import com.liulishuo.okdownload.core.cause.ResumeFailedCause;
 import com.liulishuo.okdownload.core.listener.assist.Listener4Assist;
+import com.liulishuo.okdownload.core.listener.assist.ListenerAssist;
+import com.liulishuo.okdownload.core.listener.assist.ListenerModelHandler;
 
 import java.util.List;
 import java.util.Map;
@@ -45,7 +47,7 @@
  * ->blockEnd->taskEnd
  */
 public abstract class DownloadListener4 implements DownloadListener,
-        Listener4Assist.Listener4Callback {
+        Listener4Assist.Listener4Callback, ListenerAssist {
 
     final Listener4Assist assist;
 
@@ -55,13 +57,25 @@ public abstract class DownloadListener4 implements DownloadListener,
     }
 
     public DownloadListener4() {
-        this(new Listener4Assist());
+        this(new Listener4Assist<>(new Listener4ModelCreator()));
     }
 
     public void setAssistExtend(@NonNull Listener4Assist.AssistExtend assistExtend) {
         this.assist.setAssistExtend(assistExtend);
     }
 
+    @Override public boolean isAlwaysRecoverAssistModel() {
+        return assist.isAlwaysRecoverAssistModel();
+    }
+
+    @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) {
+        assist.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel);
+    }
+
+    @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) {
+        assist.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel);
+    }
+
     @Override
     public void connectTrialStart(@NonNull DownloadTask task,
                                   @NonNull Map<String, List<String>> requestHeaderFields) {
@@ -74,12 +88,12 @@ public void connectTrialStart(@NonNull DownloadTask task,
     @Override public final void downloadFromBeginning(@NonNull DownloadTask task,
                                                       @NonNull BreakpointInfo info,
                                                       @NonNull ResumeFailedCause cause) {
-        initData(task, info, false);
+        assist.infoReady(task, info, false);
     }
 
     @Override public final void downloadFromBreakpoint(@NonNull DownloadTask task,
                                                        @NonNull BreakpointInfo info) {
-        initData(task, info, true);
+        assist.infoReady(task, info, true);
     }
 
     @Override
@@ -102,8 +116,10 @@ public final void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause,
         assist.taskEnd(task, cause, realCause);
     }
 
-    private void initData(@NonNull DownloadTask task, @NonNull BreakpointInfo info,
-                          boolean fromBreakpoint) {
-        assist.infoReady(task, info, fromBreakpoint);
+    static class Listener4ModelCreator implements
+            ListenerModelHandler.ModelCreator<Listener4Assist.Listener4Model> {
+        @Override public Listener4Assist.Listener4Model create(int id) {
+            return new Listener4Assist.Listener4Model(id);
+        }
     }
 }

okdownload/src/main/java/com/liulishuo/okdownload/core/listener/DownloadListener4WithSpeed.java

@@ -25,11 +25,14 @@
 import com.liulishuo.okdownload.core.cause.EndCause;
 import com.liulishuo.okdownload.core.listener.assist.Listener4Assist;
 import com.liulishuo.okdownload.core.listener.assist.Listener4SpeedAssistExtend;
+import com.liulishuo.okdownload.core.listener.assist.ListenerModelHandler;
 
 public abstract class DownloadListener4WithSpeed extends DownloadListener4
         implements Listener4SpeedAssistExtend.Listener4SpeedCallback {
 
-    DownloadListener4WithSpeed(Listener4SpeedAssistExtend assistExtend) {
+    private DownloadListener4WithSpeed(Listener4SpeedAssistExtend assistExtend) {
+        super(new Listener4Assist<>(new Listener4WithSpeedModelCreator()));
+
         assistExtend.setCallback(this);
         setAssistExtend(assistExtend);
     }
@@ -53,4 +56,12 @@ public final void progressBlock(DownloadTask task, int blockIndex, long currentB
     @Override
     public final void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause,
                               @NonNull Listener4Assist.Listener4Model model) { }
+
+    private static class Listener4WithSpeedModelCreator implements
+            ListenerModelHandler.ModelCreator<Listener4SpeedAssistExtend.Listener4SpeedModel> {
+        @Override public Listener4SpeedAssistExtend.Listener4SpeedModel create(int id) {
+            return new Listener4SpeedAssistExtend.Listener4SpeedModel(id);
+        }
+    }
+
 }

okdownload/src/main/java/com/liulishuo/okdownload/core/listener/assist/Listener1Assist.java

@@ -19,7 +19,6 @@
 import android.support.annotation.IntRange;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
-import android.util.SparseArray;
 
 import com.liulishuo.okdownload.DownloadTask;
 import com.liulishuo.okdownload.core.breakpoint.BreakpointInfo;
@@ -28,66 +27,39 @@
 
 import java.util.concurrent.atomic.AtomicLong;
 
-public class Listener1Assist {
-    private Listener1Model singleTaskModel;
-    private final SparseArray<Listener1Model> modelList = new SparseArray<>();
-
+public class Listener1Assist implements ListenerAssist,
+        ListenerModelHandler.ModelCreator<Listener1Assist.Listener1Model> {
+    private final ListenerModelHandler<Listener1Model> modelHandler;
     private Listener1Callback callback;
 
+    public Listener1Assist() {
+        this.modelHandler = new ListenerModelHandler<>(this);
+    }
+
+    Listener1Assist(ListenerModelHandler<Listener1Model> handler) {
+        this.modelHandler = handler;
+    }
+
     public void setCallback(@NonNull Listener1Callback callback) {
         this.callback = callback;
     }
 
     public void taskStart(DownloadTask task) {
-        final int id = task.getId();
-        final Listener1Model model = new Listener1Model(id);
-        synchronized (this) {
-            if (singleTaskModel == null) {
-                singleTaskModel = model;
-            } else {
-                modelList.put(id, model);
-            }
-        }
-
+        final Listener1Model model = modelHandler.addAndGetModel(task, null);
         if (callback != null) callback.taskStart(task, model);
     }
 
     public void taskEnd(DownloadTask task, EndCause cause, @Nullable Exception realCause) {
-        final int id = task.getId();
-        Listener1Model model;
-
-        synchronized (this) {
-            if (singleTaskModel != null && singleTaskModel.id == id) {
-                model = singleTaskModel;
-                singleTaskModel = null;
-            } else {
-                model = modelList.get(id);
-                modelList.remove(id);
-            }
-        }
-
-        if (model == null) {
-            model = new Listener1Model(task.getId());
-        }
-
+        Listener1Model model = modelHandler.removeOrCreate(task, task.getInfo());
         if (callback != null) callback.taskEnd(task, cause, realCause, model);
     }
 
-    @Nullable public Listener1Model getSingleTaskModel() {
-        return singleTaskModel;
-    }
-
-    public Listener1Model findModel(int id) {
-        if (singleTaskModel != null && singleTaskModel.id == id) return singleTaskModel;
-
-        return modelList.get(id);
-    }
-
     public void downloadFromBeginning(DownloadTask task,
                                       @NonNull BreakpointInfo info,
                                       ResumeFailedCause cause) {
-        final Listener1Model model = assignModelIfNeed(task.getId(), info);
+        final Listener1Model model = modelHandler.getOrRecoverModel(task, info);
         if (model == null) return;
+        model.onInfoValid(info);
 
         if (model.isStarted && callback != null) {
             callback.retry(task, cause);
@@ -98,28 +70,19 @@ public void downloadFromBeginning(DownloadTask task,
         model.isFirstConnect = true;
     }
 
-    public void downloadFromBreakpoint(int id, @NonNull BreakpointInfo info) {
-        final Listener1Model model = assignModelIfNeed(id, info);
+    public void downloadFromBreakpoint(DownloadTask task, @NonNull BreakpointInfo info) {
+        final Listener1Model model = modelHandler.getOrRecoverModel(task, info);
         if (model == null) return;
+        model.onInfoValid(info);
 
         model.isStarted = true;
         model.isFromResumed = true;
         model.isFirstConnect = true;
     }
 
-    @Nullable private Listener1Model assignModelIfNeed(int id, @NonNull BreakpointInfo info) {
-        final Listener1Model model = findModel(id);
-        if (model == null) return null;
-
-        model.blockCount = info.getBlockCount();
-        model.totalLength = info.getTotalLength();
-        model.currentOffset.set(info.getTotalOffset());
-
-        return model;
-    }
 
     public void connectEnd(DownloadTask task) {
-        final Listener1Model model = findModel(task.getId());
+        final Listener1Model model = modelHandler.getOrRecoverModel(task, task.getInfo());
         if (model == null) return;
 
         if (model.isFromResumed && model.isFirstConnect) {
@@ -133,20 +96,35 @@ public void connectEnd(DownloadTask task) {
     }
 
     public void fetchProgress(DownloadTask task, long increaseBytes) {
-        final Listener1Model model = findModel(task.getId());
+        final Listener1Model model = modelHandler.getOrRecoverModel(task, task.getInfo());
         if (model == null) return;
 
         model.currentOffset.addAndGet(increaseBytes);
         if (callback != null) callback.progress(task, model.currentOffset.get(), model.totalLength);
     }
 
+    @Override public boolean isAlwaysRecoverAssistModel() {
+        return modelHandler.isAlwaysRecoverAssistModel();
+    }
+
+    @Override public void setAlwaysRecoverAssistModel(boolean isAlwaysRecoverAssistModel) {
+        modelHandler.setAlwaysRecoverAssistModel(isAlwaysRecoverAssistModel);
+    }
+
+    @Override public void setAlwaysRecoverAssistModelIfNotSet(boolean isAlwaysRecoverAssistModel) {
+        modelHandler.setAlwaysRecoverAssistModelIfNotSet(isAlwaysRecoverAssistModel);
+    }
+
+    @Override public Listener1Model create(int id) {
+        return new Listener1Model(id);
+    }
 
-    public static class Listener1Model {
+    public static class Listener1Model implements ListenerModelHandler.ListenerModel {
         final int id;
-        boolean isStarted;
-        boolean isFromResumed;
+        Boolean isStarted;
+        Boolean isFromResumed;
 
-        volatile boolean isFirstConnect;
+        volatile Boolean isFirstConnect;
 
         int blockCount;
         long totalLength;
@@ -160,9 +138,19 @@ public long getTotalLength() {
             return totalLength;
         }
 
-        public int getId() {
+        @Override public int getId() {
             return id;
         }
+
+        @Override public void onInfoValid(@NonNull BreakpointInfo info) {
+            blockCount = info.getBlockCount();
+            totalLength = info.getTotalLength();
+            currentOffset.set(info.getTotalOffset());
+
+            if (isStarted == null) isStarted = false;
+            if (isFromResumed == null) isFromResumed = currentOffset.get() > 0;
+            if (isFirstConnect == null) isFirstConnect = true;
+        }
     }
 
     public interface Listener1Callback {