public FileDownloadSerialQueue() { this(new DownloadSerialQueue(), new UnifiedListenerManager()); }
/** * Get the count of tasks which is waiting on this queue. * * @return the count of waiting tasks on this queue. */ public int getWaitingTaskCount() { return serialQueue.getWaitingTaskCount(); }
/** * Returns the identify of the working task, if there is task is working, you will receive * {@link DownloadSerialQueue#ID_INVALID}. * * @return the identify of the working task */ public int getWorkingTaskId() { return serialQueue.getWorkingTaskId(); }
@Test public void resume_notPaused() { serialQueue = spy(new DownloadSerialQueue()); serialQueue.paused = false; serialQueue.resume(); verify(serialQueue, never()).startNewLooper(); }
@Test public void resume_listNotEmpty_unpark() { doNothing().when(serialQueue).startNewLooper(); serialQueue.paused = true; taskList.add(task1); serialQueue.resume(); verify(serialQueue).startNewLooper(); }
@Test public void enqueue_newLooper() { doNothing().when(serialQueue).startNewLooper(); serialQueue.paused = true; serialQueue.enqueue(task1); verify(serialQueue, never()).startNewLooper(); serialQueue.looping = true; serialQueue.enqueue(task1); verify(serialQueue, never()).startNewLooper(); serialQueue.paused = false; serialQueue.looping = false; serialQueue.enqueue(task1); verify(serialQueue).startNewLooper(); assertThat(serialQueue.looping).isTrue(); }
/** * Pause the queue. * * @see #resume() */ public void pause() { serialQueue.pause(); }
public FileDownloadSerialQueue(@NonNull DownloadSerialQueue serialQueue, @NonNull UnifiedListenerManager listenerManager) { this.serialQueue = serialQueue; this.listenerManager = listenerManager; this.serialQueue.setListener(this.listenerManager.getHostListener()); }
/** * Attempts to stop the working task, halts the processing of waiting tasks, and returns a list * of the tasks that were awaiting execution. These tasks are drained (removed) from the task * queue upon return from this method. */ public List<BaseDownloadTask> shutdown() { DownloadTask[] tasks = serialQueue.shutdown(); List<BaseDownloadTask> notRunningTasks = new ArrayList<>(); for (DownloadTask task : tasks) { final DownloadTaskAdapter notRunningTask = FileDownloadUtils.findDownloadTaskAdapter(task); if (notRunningTask != null) { notRunningTasks.add(notRunningTask); FileDownloadList.getImpl().remove(notRunningTask); } } return notRunningTasks; } }
/** * Resume the queue if the queue is paused. * * @see #pause() */ public void resume() { serialQueue.resume(); }
/** * Enqueues the given task sometime in the serial queue. If the {@code task} is in the head of * the serial queue, the {@code task} will be started automatically. */ public void enqueue(BaseDownloadTask task) { final DownloadTaskAdapter downloadTaskAdapter = (DownloadTaskAdapter) task; downloadTaskAdapter.assembleDownloadTask(); FileDownloadList.getImpl().addIndependentTask(downloadTaskAdapter); serialQueue.enqueue(downloadTaskAdapter.getDownloadTask()); listenerManager.addAutoRemoveListenersWhenTaskEnd(downloadTaskAdapter.getId()); listenerManager.attachListener(downloadTaskAdapter.getDownloadTask(), downloadTaskAdapter.getCompatListener()); }
/** * Enqueues the given task sometime in the serial queue. If the {@code task} is in the head of * the serial queue, the {@code task} will be started automatically. */ public synchronized void enqueue(DownloadTask task) { taskList.add(task); Collections.sort(taskList); if (!paused && !looping) { looping = true; startNewLooper(); } }
@Test public void run() { // empty serialQueue.looping = true; serialQueue.run(); assertThat(serialQueue.looping).isFalse(); // non empty but paused serialQueue.looping = true; taskList.add(task1); taskList.add(task2); serialQueue.paused = true; serialQueue.run(); verify(task1, never()).execute(any(DownloadListener.class)); verify(task2, never()).execute(any(DownloadListener.class)); verify(taskList, never()).remove(anyInt()); assertThat(serialQueue.looping).isFalse(); // non empty and non paused serialQueue.looping = true; serialQueue.paused = false; serialQueue.run(); verify(task1).execute(any(DownloadListener.class)); verify(task2).execute(any(DownloadListener.class)); verify(taskList, times(2)).remove(eq(0)); assertThat(serialQueue.looping).isFalse(); }
@Test public void resume() { serialQueue.paused = true; serialQueue.looping = false; doNothing().when(serialQueue).startNewLooper(); taskList.add(mock(DownloadTask.class)); serialQueue.resume(); verify(serialQueue).startNewLooper(); assertThat(serialQueue.paused).isFalse(); assertThat(serialQueue.looping).isTrue(); }
@Test public void enqueue() { doNothing().when(serialQueue).startNewLooper(); // order when(task1.compareTo(task2)).thenReturn(-1); serialQueue.enqueue(task2); serialQueue.enqueue(task1); verify(taskList).add(eq(task1)); verify(taskList).add(eq(task2)); assertThat(taskList).containsExactly(task1, task2); }
@Test public void pause() { serialQueue.pause(); assertThat(serialQueue.paused).isTrue(); }
@Test public void setListener() { assertThat(serialQueue.listenerBunch.contain(listener)).isTrue(); final DownloadListener anotherListener = mock(DownloadListener.class); serialQueue.setListener(anotherListener); assertThat(serialQueue.listenerBunch.contain(listener)).isFalse(); assertThat(serialQueue.listenerBunch.contain(anotherListener)).isTrue(); }
@Test public void shutdown() { taskList.add(task1); serialQueue.runningTask = task2; final DownloadTask[] tasks = serialQueue.shutdown(); verify(task2).cancel(); assertThat(serialQueue.shutedDown).isTrue(); assertThat(tasks).containsExactly(task1); }
/** * Resume the queue if the queue is paused. * * @see #pause() */ public synchronized void resume() { if (!paused) { Util.w(TAG, "require resume this queue(remain " + taskList.size() + "), but it is" + " still running"); return; } paused = false; if (!taskList.isEmpty() && !looping) { looping = true; startNewLooper(); } }
@Test public void pause_isRunning_cancel() { serialQueue.runningTask = task1; serialQueue.pause(); verify(task1).cancel(); assertThat(taskList.get(0)).isEqualTo(task1); }