private static Future<?> publishByteCountEvent( final ProgressListener listener, final ProgressEventType type, final long bytes) { if (listener == ProgressListener.NOOP || listener == null || bytes <= 0) return null; return deliverEvent(listener, new ProgressEvent(type, bytes)); }
/** * @param listener * must not be null or else the publication will be skipped * @param bytesReset * the publication will be skipped unless the number of bytes * reset is positive */ private static Future<?> publishResetEvent( final ProgressListener listener, final ProgressEventType resetEventType, final long bytesReset) { if (bytesReset <= 0) return null; if (listener == ProgressListener.NOOP || listener == null) return null; return deliverEvent(listener, new ProgressEvent(resetEventType, bytesReset)); }
/** * Used to deliver a progress event to the given listener. * * @return the future of a submitted task; or null if the delivery is * synchronous with no future task involved. Note a listener should never * block, and therefore returning null is the typical case. */ public static Future<?> publishProgress( final ProgressListener listener, final ProgressEventType type) { if (listener == ProgressListener.NOOP || listener == null || type == null) { return null; } return deliverEvent(listener, new ProgressEvent(type)); }
protected void fireProgressEvent(final int eventType) { ProgressListenerCallbackExecutor.progressChanged( this.progressListenerChain, new ProgressEvent(eventType, 0)); }
private void notify(int bytesRead) { unnotifiedByteCount += bytesRead; if (unnotifiedByteCount >= this.notificationThreshold) { listenerCallbackExecutor.progressChanged(new ProgressEvent(unnotifiedByteCount)); unnotifiedByteCount = 0; } } }
private static Future<?> publishByteCountEvent( final ProgressListener listener, final ProgressEventType type, final long bytes) { if (listener == ProgressListener.NOOP || listener == null || bytes <= 0) return null; return deliverEvent(listener, new ProgressEvent(type, bytes)); }
/** * Used to deliver a progress event to the given listener. * * @return the future of a submitted task; or null if the delivery is * synchronous with no future task involved. Note a listener should never * block, and therefore returning null is the typical case. */ public static Future<?> publishProgress( final ProgressListener listener, final ProgressEventType type) { if (listener == ProgressListener.NOOP || listener == null || type == null) { return null; } return deliverEvent(listener, new ProgressEvent(type)); }
/** * @param listener * must not be null or else the publication will be skipped * @param bytesReset * the publication will be skipped unless the number of bytes * reset is positive */ private static Future<?> publishResetEvent( final ProgressListener listener, final ProgressEventType resetEventType, final long bytesReset) { if (bytesReset <= 0) return null; if (listener == ProgressListener.NOOP || listener == null) return null; return deliverEvent(listener, new ProgressEvent(resetEventType, bytesReset)); }
@Override public void close() throws IOException { if (unnotifiedByteCount > 0) { listenerCallbackExecutor.progressChanged(new ProgressEvent(unnotifiedByteCount)); unnotifiedByteCount = 0; } super.close(); }
private void notifyCompleted() { if (!fireCompletedEvent) return; ProgressEvent event = new ProgressEvent(unnotifiedByteCount); event.setEventCode(ProgressEvent.COMPLETED_EVENT_CODE); unnotifiedByteCount = 0; listenerCallbackExecutor.progressChanged(event); }
private void fireProgressEvent(final int eventType) { if (progressListenerChainCallbackExecutor == null) return; ProgressEvent event = new ProgressEvent(0); event.setEventCode(eventType); progressListenerChainCallbackExecutor.progressChanged(event); }
private void fireProgressEvent(final int eventType) { if (progressListenerChainCallbackExecutor == null) return; ProgressEvent event = new ProgressEvent(0); event.setEventCode(eventType); progressListenerChainCallbackExecutor.progressChanged(event); }
private void fireProgressEvent(final int eventType) { if (progressListenerChainCallbackExecutor == null) return; ProgressEvent event = new ProgressEvent(0); event.setEventCode(eventType); progressListenerChainCallbackExecutor.progressChanged(event); }
private void fireProgressEvent(final int eventType) { ProgressEvent event = new ProgressEvent(0); event.setEventCode(eventType); ProgressListenerCallbackExecutor.progressChanged(listener, event); } }
/** * Fires a progress event with the specified event type to the specified * listener. * * @param progressListenerCallbackExecutor The listener callback executor. * @param eventType The type of event to fire. */ private void fireProgressEvent( final ProgressListenerCallbackExecutor progressListenerCallbackExecutor, final int eventType) { if (progressListenerCallbackExecutor == null) { return; } final ProgressEvent event = new ProgressEvent(0); event.setEventCode(eventType); progressListenerCallbackExecutor.progressChanged(event); }
@Override public void reset() throws IOException { super.reset(); ProgressEvent event = new ProgressEvent(unnotifiedByteCount); event.setEventCode(ProgressEvent.RESET_EVENT_CODE); listenerCallbackExecutor.progressChanged(event); unnotifiedByteCount = 0; }
@Test public void testStaticProgressChangedWrapper() throws InterruptedException { final List<ProgressEvent> capturedEvents = new ArrayList<ProgressEvent>(); ProgressListener pl = new ProgressListener() { @Override public void progressChanged(ProgressEvent progressEvent) { capturedEvents.add(progressEvent); } }; ProgressEvent toSend = new ProgressEvent(0); ProgressListenerCallbackExecutor.progressChanged(pl, toSend); ExecutorService service = ProgressListenerCallbackExecutor.getExecutorService(); service.shutdown(); service.awaitTermination(10, TimeUnit.SECONDS); ProgressListenerCallbackExecutor.executor = ProgressListenerCallbackExecutor .createNewExecutorService(); assertEquals(capturedEvents.size(), 1); assertSame(capturedEvents.get(0), toSend); }
@Test public void testWrapListener() throws InterruptedException { final List<ProgressEvent> capturedEvents = new ArrayList<ProgressEvent>(); final List<Long> threadIds = new ArrayList<Long>(); threadIds.add(Thread.currentThread().getId()); ProgressListener pl = new ProgressListener() { @Override public void progressChanged(ProgressEvent progressEvent) { threadIds.add(Thread.currentThread().getId()); capturedEvents.add(progressEvent); } }; ProgressEvent toSend = new ProgressEvent(0); ProgressListenerCallbackExecutor.wrapListener(pl); pl.progressChanged(toSend); ExecutorService service = ProgressListenerCallbackExecutor.getExecutorService(); service.shutdown(); service.awaitTermination(10, TimeUnit.SECONDS); ProgressListenerCallbackExecutor.executor = ProgressListenerCallbackExecutor .createNewExecutorService(); assertEquals(threadIds.size(), 2); assertEquals(capturedEvents.size(), 1); assertSame(capturedEvents.get(0), toSend); }
@Test public void testTwoArgConstructor() { ProgressEvent pe = new ProgressEvent(ProgressEvent.COMPLETED_EVENT_CODE, 100); assertEquals(pe.getBytesTransferred(), 100); assertEquals(pe.getEventCode(), ProgressEvent.COMPLETED_EVENT_CODE); }
@Test public void testPlainConstructor() { ProgressListenerCallbackExecutor exec = new ProgressListenerCallbackExecutor(); assertNull(exec.getListener()); assertNotNull(ProgressListenerCallbackExecutor.getExecutorService()); // Makesure it doesn't blow up exec.progressChanged(new ProgressEvent(0)); }