@Override public void connectEnd(@NonNull DownloadTask task, int blockIndex, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { for (DownloadListener listener : listenerList) { listener.connectEnd(task, blockIndex, responseCode, responseHeaderFields); } }
@Override public void connectStart(@NonNull DownloadTask task, int blockIndex, @NonNull Map<String, List<String>> requestHeaderFields) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.connectStart(task, blockIndex, requestHeaderFields); } }
@Override public void connectTrialEnd(@NonNull DownloadTask task, int responseCode, @NonNull Map<String, List<String>> responseHeaderFields) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.connectTrialEnd(task, responseCode, responseHeaderFields); } }
listener.taskStart(task); listener.taskStart(noAttachTask); verify(listener1).taskStart(eq(task)); verify(listener2).taskStart(eq(task)); listener.connectTrialStart(task, headerFields); listener.connectTrialStart(noAttachTask, headerFields); verify(listener1).connectTrialStart(eq(task), eq(headerFields)); verify(listener2).connectTrialStart(eq(task), eq(headerFields)); listener.connectTrialEnd(task, 200, headerFields); listener.connectTrialEnd(noAttachTask, 200, headerFields); verify(listener1).connectTrialEnd(eq(task), eq(200), eq(headerFields)); verify(listener2).connectTrialEnd(eq(task), eq(200), eq(headerFields)); listener.downloadFromBeginning(task, info, resumeFailedCause); listener.downloadFromBeginning(noAttachTask, info, resumeFailedCause); verify(listener1).downloadFromBeginning(eq(task), eq(info), eq(resumeFailedCause)); verify(listener2).downloadFromBeginning(eq(task), eq(info), eq(resumeFailedCause)); listener.downloadFromBreakpoint(task, info); listener.downloadFromBreakpoint(noAttachTask, info); verify(listener1).downloadFromBreakpoint(eq(task), eq(info)); verify(listener2).downloadFromBreakpoint(eq(task), eq(info)); listener.connectStart(task, 1, headerFields); listener.connectStart(noAttachTask, 1, headerFields); verify(listener1).connectStart(eq(task), eq(1), eq(headerFields)); verify(listener2).connectStart(eq(task), eq(1), eq(headerFields));
@Override public void taskEnd(@NonNull DownloadTask task, @NonNull EndCause cause, @Nullable Exception realCause) { for (DownloadListener listener : listenerList) { listener.taskEnd(task, cause, realCause); } }
@Test public void trialHeadMethodForInstanceLength() throws IOException { final DownloadConnection.Factory factory = OkDownload.with().connectionFactory(); final DownloadConnection connection = mock(DownloadConnection.class); when(factory.create(anyString())).thenReturn(connection); final DownloadConnection.Connected connected = mock(DownloadConnection.Connected.class); when(connection.execute()).thenReturn(connected); when(connected.getResponseHeaderField(CONTENT_LENGTH)).thenReturn("10"); final CallbackDispatcher callbackDispatcher = OkDownload.with().callbackDispatcher(); final DownloadListener listener = mock(DownloadListener.class); when(callbackDispatcher.dispatch()).thenReturn(listener); connectTrial.trialHeadMethodForInstanceLength(); verify(connection).setRequestMethod(eq(METHOD_HEAD)); verify(listener).connectTrialStart(eq(task), nullable(Map.class)); verify(listener).connectTrialEnd(eq(task), anyInt(), nullable(Map.class)); assertThat(connectTrial.getInstanceLength()).isEqualTo(10L); }
@Override public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.downloadFromBeginning(task, info, cause); } }
@Override public void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes) { for (DownloadListener listener : listenerList) { listener.fetchProgress(task, blockIndex, increaseBytes); } }
void start() throws IOException { final CallbackDispatcher dispatcher = OkDownload.with().callbackDispatcher(); // connect chain final RetryInterceptor retryInterceptor = new RetryInterceptor(); final BreakpointInterceptor breakpointInterceptor = new BreakpointInterceptor(); connectInterceptorList.add(retryInterceptor); connectInterceptorList.add(breakpointInterceptor); connectInterceptorList.add(new HeaderInterceptor()); connectInterceptorList.add(new CallServerInterceptor()); connectIndex = 0; final DownloadConnection.Connected connected = processConnect(); if (cache.isInterrupt()) { throw InterruptException.SIGNAL; } dispatcher.dispatch().fetchStart(task, blockIndex, getResponseContentLength()); // fetch chain final FetchDataInterceptor fetchDataInterceptor = new FetchDataInterceptor(blockIndex, connected.getInputStream(), getOutputStream(), task); fetchInterceptorList.add(retryInterceptor); fetchInterceptorList.add(breakpointInterceptor); fetchInterceptorList.add(fetchDataInterceptor); fetchIndex = 0; final long totalFetchedBytes = processFetch(); dispatcher.dispatch().fetchEnd(task, blockIndex, totalFetchedBytes); }
@Override public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { for (DownloadListener listener : listenerList) { listener.downloadFromBreakpoint(task, info); } }
.connectStart(task, blockIndex, connection.getRequestProperties()); if (responseHeaderFields == null) responseHeaderFields = new HashMap<>(); OkDownload.with().callbackDispatcher().dispatch().connectEnd(task, blockIndex, connected.getResponseCode(), responseHeaderFields);
@Override public void fetchStart(@NonNull DownloadTask task, int blockIndex, long contentLength) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.fetchStart(task, blockIndex, contentLength); } }
@Override public void fetchEnd(@NonNull DownloadTask task, int blockIndex, long contentLength) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.fetchEnd(task, blockIndex, contentLength); } }
@Override public void connectTrialStart(@NonNull DownloadTask task, @NonNull Map<String, List<String>> requestHeaderFields) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.connectTrialStart(task, requestHeaderFields); } }
dispatcher.dispatch().taskStart(task); verify(listener).taskStart(eq(task)); dispatcher.dispatch().connectTrialStart(task, headerFields); verify(listener).connectTrialStart(eq(task), eq(headerFields)); dispatcher.dispatch().connectTrialEnd(task, 200, headerFields); verify(listener).connectTrialEnd(eq(task), eq(200), eq(headerFields)); dispatcher.dispatch().downloadFromBeginning(task, info, resumeFailedCause); verify(listener).downloadFromBeginning(eq(task), eq(info), eq(resumeFailedCause)); dispatcher.dispatch().downloadFromBreakpoint(task, info); verify(listener).downloadFromBreakpoint(eq(task), eq(info)); dispatcher.dispatch().connectStart(task, 1, headerFields); verify(listener).connectStart(eq(task), eq(1), eq(headerFields)); dispatcher.dispatch().connectEnd(task, 2, 200, headerFields); verify(listener).connectEnd(eq(task), eq(2), eq(200), eq(headerFields)); dispatcher.dispatch().fetchStart(task, 1, 2L); verify(listener).fetchStart(eq(task), eq(1), eq(2L)); dispatcher.dispatch().fetchProgress(task, 1, 2L); verify(listener).fetchProgress(eq(task), eq(1), eq(2L)); dispatcher.dispatch().fetchEnd(task, 1, 2L); verify(listener).fetchEnd(eq(task), eq(1), eq(2L));
@Override public void run() { for (DownloadTask task : completedTaskCollection) { task.getListener().taskEnd(task, EndCause.COMPLETED, null); } for (DownloadTask task : sameTaskConflictCollection) { task.getListener().taskEnd(task, EndCause.SAME_TASK_BUSY, null); } for (DownloadTask task : fileBusyCollection) { task.getListener().taskEnd(task, EndCause.FILE_BUSY, null); } } });
void trialHeadMethodForInstanceLength() throws IOException { final DownloadConnection connection = OkDownload.with().connectionFactory() .create(task.getUrl()); final DownloadListener listener = OkDownload.with().callbackDispatcher().dispatch(); try { connection.setRequestMethod(METHOD_HEAD); final Map<String, List<String>> userHeader = task.getHeaderMapFields(); if (userHeader != null) Util.addUserRequestHeaderField(userHeader, connection); listener.connectTrialStart(task, connection.getRequestProperties()); final DownloadConnection.Connected connectedForContentLength = connection.execute(); listener.connectTrialEnd(task, connectedForContentLength.getResponseCode(), connectedForContentLength.getResponseHeaderFields()); this.instanceLength = Util.parseContentLength( connectedForContentLength.getResponseHeaderField(CONTENT_LENGTH)); } finally { connection.release(); } }
@Override public void downloadFromBeginning(@NonNull DownloadTask task, @NonNull BreakpointInfo info, @NonNull ResumeFailedCause cause) { for (DownloadListener listener : listenerList) { listener.downloadFromBeginning(task, info, cause); } }
@Override public void fetchProgress(@NonNull DownloadTask task, int blockIndex, long increaseBytes) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.fetchProgress(task, blockIndex, increaseBytes); } }
@Override public void downloadFromBreakpoint(@NonNull DownloadTask task, @NonNull BreakpointInfo info) { final DownloadListener[] listeners = getThreadSafeArray(task, realListenerMap); if (listeners == null) return; for (final DownloadListener realOne : listeners) { if (realOne == null) continue; realOne.downloadFromBreakpoint(task, info); } }