public void setOnSuccededAfterService(TestdataPresenter testdataPresenter, String onSucceededMessage) { super.setOnSucceeded((WorkerStateEvent t) -> { LoggerFacade.getDefault().debug(this.getClass(), onSucceededMessage); presenter.setProgressBarInformation(onSucceededMessage); if (!presenter.getProgressBarPercentInformation().getText().equals("100%")) { // NOI18N presenter.getProgressBarPercentInformation().textProperty().unbind(); presenter.getProgressBarPercentInformation().setText("100%"); // NOI18N } if (testdataPresenter != null) { testdataPresenter.cleanUpAfterServices(); } }); }
private void performAction(WorkerStateEvent event) { if (!buttonClicked) { return; } buttonClicked = false; ServerInfo serverInfo = (ServerInfo) event.getSource().getValue(); switch (serverInfo.getServerStatus()) { case LOCALLY_ONLINE: serverService.requestShutdown(); break; case OFFLINE: startServer(); break; case REMOTE_ONLINE: case REMOTE_UPLOADING: case LOCALLY_UPLOADING: case LOCALLY_DOWNLOADING: // do nothing } }
private void updateButtonState(WorkerStateEvent event) { ServerInfo serverInfo = (ServerInfo) event.getSource().getValue(); switch (serverInfo.getServerStatus()) { case REMOTE_ONLINE: serverButton.setDisable(true); break; case OFFLINE: serverButton.setText("Start server"); serverButton.setDisable(false); break; case REMOTE_UPLOADING: serverButton.setDisable(true); break; case LOCALLY_ONLINE: serverButton.setText("Stop server"); serverButton.setDisable(false); break; case LOCALLY_UPLOADING: serverButton.setDisable(true); break; case LOCALLY_DOWNLOADING: serverButton.setDisable(true); break; } }
@Override public void handle(WorkerStateEvent event) { LOGGER.debug("successed!"); Object obj = event.getSource().getValue(); TreeItem<V> root = new TreeItem<>(vRoot); tvFiles.setRoot(root); int totalSize = 0; if (obj != null) { Map<String, ObservableList<File>> value = (Map<String, ObservableList<File>>) obj; for (String key : value.keySet()) { V v = new V(); v.setFileExtension(key); ObservableList<File> list = value.get(key); v.setItems(list); totalSize += list.size(); root.getChildren().add(new TreeItem<>(v)); } } vRoot.setSize(totalSize); service.reset(); }
private void getUserIdAndSetOrders(){ Task<Void> getUserIdTask = new Task<Void>() { @Override protected Void call() throws Exception { while(userId == null){ } return null; } }; new Thread(getUserIdTask).start(); progressIndicator.progressProperty().bind(getUserIdTask.progressProperty()); progressIndicator.setVisible(true); getUserIdTask.setOnSucceeded(new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent workerStateEvent) { progressIndicator.setVisible(false); setOrders(); } }); }
public static void callAfter(int mseconds, CallbackVisitor callback) { Task<Void> sleeper = new Task<Void>() { @Override protected Void call() throws Exception { try { Thread.sleep(mseconds); } catch (InterruptedException e) { ExceptionAlerter.showException(e); } return null; } }; sleeper.setOnSucceeded(new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent event) { callback.call(); } }); new Thread(sleeper).start(); }
/** * Return async stats list * * @param type * @param addData */ private void getAsyncStatList(final AsyncStatsType type, final int addData) { refreshStatsService = new RefreshingService(); refreshStatsService.setPeriod(Duration.seconds(Constants.REFRESH_ONE_INTERVAL_SECONDS)); refreshStatsService.setOnSucceeded((WorkerStateEvent event) -> { switch (type) { case GLOBAL: buildGlobalStat(); break; case PORT: buildPortStatTable(addData); break; case TUI: buildPortStatTable(-1); break; default: break; } }); refreshStatsService.start(); }
/** * Initialize reading stats thread */ private void initializeReadingStats() { readingStatService = new RefreshingService(); readingStatService.setPeriod(Duration.seconds(Constants.REFRESH_ONE_INTERVAL_SECONDS)); readingStatService.setOnSucceeded((WorkerStateEvent event) -> { currentStatsList = StatsLoader.getInstance().getLoadedStatsList(); String data = currentStatsList.get("m_cpu_util"); if (Util.isNullOrEmpty(data)) { data = "0"; } updateGaugeSegmentsAndColoring(Double.parseDouble(data)); ((StatsInfoView) totalTx.getChildren().get(0)).setValue(Util.getFormatted(currentStatsList.get("m_tx_bps"), true, "b/sec")); ((StatsInfoView) totalRx.getChildren().get(0)).setValue(Util.getFormatted(currentStatsList.get("m_rx_bps"), true, "b/sec")); ((StatsInfoView) totalPPS.getChildren().get(0)).setValue(Util.getFormatted(currentStatsList.get("m_tx_pps"), true, "pkt/sec")); ((StatsInfoView) totalStream.getChildren().get(0)).setValue("0"); ((StatsInfoView) activePort.getChildren().get(0)).setValue(portManager.getActivePort()); ((StatsInfoView) dropRate.getChildren().get(0)).setValue(Util.getFormatted(currentStatsList.get("m_rx_drop_bps"), true, "b/sec")); ((StatsInfoView) queueFull.getChildren().get(0)).setValue(Util.getFormatted(getDiffQueueFull(), true, "pkts")); buildPortStatTable(); }); readingStatService.start(); latencyChartController.runChart(); }
public DrBookingService() { super(progressLabel); addEventHandler(WorkerStateEvent.WORKER_STATE_FAILED, event -> { setWorking(false, false); }); addEventHandler(WorkerStateEvent.WORKER_STATE_SCHEDULED, event -> { setWorking(true); }); addEventHandler(WorkerStateEvent.WORKER_STATE_SUCCEEDED, event -> { setWorking(false); }); }
private void handleFailureEvent(WorkerStateEvent event, String messageId) { String errorMessage = DEFAULT_ERROR_MESSAGE; Throwable exception = event.getSource().getException(); if (exception != null) { if (exception instanceof AuthenticationException) { navigator.navigateToLogin(exception.getLocalizedMessage()); view.enableSearchButton(); return; } else if (exception instanceof ReportNotFoundException) { errorMessage = "Delivery report for " + messageId + " was not found.\n" + "Perhaps it did not arrive yet or has already been collected.\n" + "Remember: a delivery report can be received only once per SMS."; } else { errorMessage += " because " + exception.getLocalizedMessage(); } } view.showErrorMessage(errorMessage); view.enableSearchButton(); }
private void onVersionCheckFinished(WorkerStateEvent event) { Optional<GitHubVersion> gitHubVersionOptional = ((VersionCheckerTask) event.getSource()).getValue(); gitHubVersionOptional.ifPresent(gitHubVersion -> { Version currentVersion = new Version(resources.getString("release.version")); Version mostRecentVersion = new Version(gitHubVersion.getVersion()); LOGGER.debug("Most recent github version is {}, this version is {}", mostRecentVersion, currentVersion); if (mostRecentVersion.isNewerThan(currentVersion)) { Hyperlink link = HyperlinkUtil.createLink( FormattingUtil.getFormatted("worker.updatecheck.available", mostRecentVersion.toString()), gitHubVersion.getUrl() ); mainToolbar.getItems().add(link); } }); }
public SrmDetectionTask(String title, @Nullable String message, @Nonnull RawDataFile rawDataFile, @Nonnull DataPointStore dataStore, @Nullable String nameSuffix) { this.rawDataFile = rawDataFile; this.dataStore = dataStore; this.nameSuffix = nameSuffix; this.title = title; this.message = message; // SRM detection method srmDetectionMethod = new SrmDetectionMethod(rawDataFile, dataStore); refreshStatus(); EventHandler<WorkerStateEvent> cancelEvent = new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent workerEvent) { srmDetectionMethod.cancel(); } }; setOnCancelled(cancelEvent); }
public ChromatogramBuilderTask(String title, @Nullable String message, @Nonnull RawDataFile rawDataFile, @Nonnull DataPointStore dataStore, @Nonnull MaximumMzTolerance mzTolerance, @Nonnull Double noiseLevel, @Nonnull Double minDuration, @Nonnull Double minHeight, @Nullable String nameSuffix) { this.rawDataFile = rawDataFile; this.dataStore = dataStore; this.nameSuffix = nameSuffix; this.title = title; this.message = message; // Chromatogram builder method chromatogramBuilderMethod = new ChromatogramBuilderMethod(dataStore, rawDataFile, noiseLevel, minDuration, minHeight, mzTolerance); refreshStatus(); EventHandler<WorkerStateEvent> cancelEvent = new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent workerEvent) { chromatogramBuilderMethod.cancel(); } }; setOnCancelled(cancelEvent); }
private void createServiceChain(final Service<String> service, final ServiceChain demoControl) { service.addEventHandler(WorkerStateEvent.WORKER_STATE_SUCCEEDED, (val) -> { final Service<String> service2 = createServiceTwo(); service2.addEventHandler(WorkerStateEvent.WORKER_STATE_SUCCEEDED, (val2) -> { demoControl.stepTwoRectangle.setStroke(Color.GRAY); service2.reset(); }); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } demoControl.progressService.progressProperty().unbind(); demoControl.progressService.progressProperty().bind(service2.progressProperty()); demoControl.stepOneRectangle.setStroke(Color.GRAY); demoControl.stepTwoRectangle.setStroke(Color.GREEN); demoControl.stepTwoRectangle.setVisible(true); service2.start(); }); }
private void bindServiceToControl(ServiceAndTask demoControl,Service<String> service) { demoControl.startService.setOnMouseClicked((val) -> { if (!service.isRunning()) { service.reset(); service.start(); demoControl.labelService.textProperty().bind(service.messageProperty()); } }); demoControl.labelService.textProperty().bind(service.messageProperty()); service.addEventHandler(WorkerStateEvent.WORKER_STATE_SUCCEEDED, (val) -> { demoControl.labelService.textProperty().unbind(); demoControl.labelService.setText(service.getValue()); }); demoControl.progressService.progressProperty().bind(service.progressProperty()); }
public EventHandler<WorkerStateEvent> getOnSucceeded() { return event -> { final String applicationVersion = AppConfiguration.getApplicationProperty("project.version"); final int currentVersionMayor = getVersionMayor(applicationVersion); final int currentVersionMinor = getVersionMinor(applicationVersion); final Release latestRelease = (Release) event.getSource().getValue(); if (ReleaseVersionUtils.updateAvailable(latestRelease, currentVersionMayor, currentVersionMinor)) { LOGGER.info("Update to version {} available.", latestRelease.getVersionName()); openUpdateDialog(latestRelease); } else { LOGGER.info("Updated to latest version."); } }; }
/** * Instantiates a new {@link ImageLoaderService}. * * @param imageLoaderQueue The ImageLoaderQueue */ public ImageLoaderService(final ImageLoaderQueue imageLoaderQueue) { this.image = new SimpleObjectProperty<ImageWithFile>(); this.imageLoaderQueue = imageLoaderQueue; this.queueable = null; setOnSucceeded(new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent wse) { queueable.onLoaded(image.get()); endTime = System.currentTimeMillis(); loadTime = (endTime - startTime); LJGM.instance().getLogger().debug("Loaded file \"" + image.get().getFile().getName() + "\" in " + loadTime + "ms. Average " + imageLoaderQueue.getAverageLoadTime() + "ms."); reset(); ImageLoaderService.this.imageLoaderQueue.finished(ImageLoaderService.this); } }); }
void addDrive(final Drive driveToBeAdded) { Platform.runLater(new Runnable() { @Override public void run() { try { driveToBeAdded.initProgressPane(); } catch (IOException ex) { Logger.getLogger(MagicCopierPreferencesModel.class.getName()).log(Level.SEVERE, null, ex); } drivesList.add(driveToBeAdded); driveToBeAdded.startCopy(destinationDirectory.get().toPath(), new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent t) { System.out.println("copied drive: " + driveToBeAdded.volumeName.get()); } }); } }); }
@FXML void initialize(){ backgroundTasks = new Task<Boolean>() { @Override protected Boolean call() throws Exception { try{ Login.startAuthentication(); new SynchronizeMessages().fullSync(); }catch (IOException e){ e.printStackTrace(); System.out.println("Internet Error at splashWait Task"); AmailMain.isInternetUp = false; Platform.runLater(new Runnable() { @Override public void run() { NotifyUser.getNotification("Internet Connection has lost", "Please check your internet connection").showInformation(); } }); return false; } return true; } }; backgroundTasks.setOnSucceeded(new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent event) { if(backgroundTasks.getValue()) { //controllers.AmailMain.getStage().setResizable(true); myController.setScreen(AmailMain.mainUIId); new SynchronizeMessages().partialSync(); } } }); }
private void done(WorkerStateEvent event) throws IllegalStateException { T result = task.getValue(); validators.values().forEach(v -> { if (!v.test(result)) { throw new IllegalStateException(message); } }); processors.values().forEach(p -> p.accept(result)); }
@Override public void handle(WorkerStateEvent event) { try { handler.handleThrowing(event); } catch (Exception e) { last = e; } }
default void handle(WorkerStateEvent event) { try { handleThrowing(event); } catch (Exception e) { throw new RuntimeException(MARKER, e); } }
@FXML void refreshAllAppList(ActionEvent event) { try { Task<Void> syncApp = allAppList.init(); refreshListButton.setContentDisplay(ContentDisplay.GRAPHIC_ONLY); refreshListButton.setGraphic(new JFXSpinner()); syncApp.setOnSucceeded((WorkerStateEvent t) -> { allAppList.saveToXml(); setAppNameList(); listResult.setItems(FXCollections.observableArrayList(currentAppList)); listResult.refresh(); refreshListButton.setGraphic(null); refreshListButton.setContentDisplay(ContentDisplay.TEXT_ONLY); }); syncApp.setOnFailed(t -> { JFXSnackbar error = new JFXSnackbar(root); error.show(I18n.getMessage("errorrefreshapplist"),3000); }); new Thread(syncApp).start(); } catch (Exception e) { e.printStackTrace(); } }
private void updatePendingTasks(GoogleTask<?> task) { Util.runInFXThread(() -> { pendingTasks.set(pendingTasks.get() + 1); EventHandler<WorkerStateEvent> handler = evt -> pendingTasks.set(pendingTasks.get() - 1); task.setOnFailed(handler); task.setOnSucceeded(handler); log.add(0, task.getLogItem()); }); }
public void loadTask(@NotNull Task<?> task, @Nullable EventHandler<WorkerStateEvent> succeedEvent) { getProgressBar().setProgress(-1); getLblStatus().setText(""); task.exceptionProperty().addListener(taskExceptionPropertyListener); task.messageProperty().addListener(taskMessagePropertyListener); task.setOnSucceeded(succeedEvent); getProgressBar().progressProperty().bind(task.progressProperty()); new Thread(task).start(); }
private void getUserIdAndOrder(){ statusLabel.setText("Loading..."); statusLabel.setVisible(true); Task<Void> getUserDetailsTask = new Task<Void>() { @Override protected Void call() throws Exception { while(userId == null){ } while(parkingOrder == null){ } return null; } }; new Thread(getUserDetailsTask).start(); progressIndicator.progressProperty().bind(getUserDetailsTask.progressProperty()); progressIndicator.setVisible(true); getUserDetailsTask.setOnSucceeded(new EventHandler<WorkerStateEvent>() { @Override public void handle(WorkerStateEvent workerStateEvent) { headerLabel.setText("Please rate the quality of your last parking experience at " + parkingOrder.getParkingSlotId() + "."); submitButton.setDisable(false); progressIndicator.setVisible(false); statusLabel.setVisible(false); } }); }
/** * Start scheduler to update port state every 15sec */ public void startPortStatusScheduler() { updatePortStatusService = new UpdatePortStatusService(portList); updatePortStatusService.setPeriod(Duration.seconds(Constants.REFRESH_FIFTEEN_INTERVAL_SECONDS)); updatePortStatusService.setRestartOnFailure(false); updatePortStatusService.setOnSucceeded((WorkerStateEvent event) -> { portList = (List<Port>) event.getSource().getValue(); boolean successfulyUpdate = portList != null && !portList.isEmpty(); portManagerHandler.onPortListUpdated(successfulyUpdate); }); updatePortStatusService.start(); }
/** * Start drawing chart and update his points */ public void runChart() { updateChartService = new RefreshingService(); updateChartService.setPeriod(Duration.millis(500)); updateChartService.setOnSucceeded((WorkerStateEvent event) -> { updateChartSeries(); addDataToSeries(); }); updateChartService.start(); }
public AbstractDrBookingsService(final Labeled labeled) { this.labeled = labeled; addEventHandler(WorkerStateEvent.WORKER_STATE_FAILED, event -> { final Throwable e = getException(); if (logger.isErrorEnabled()) { logger.error(e.toString()); } labeled.setText("Error: " + e.getLocalizedMessage()); }); addEventHandler(WorkerStateEvent.WORKER_STATE_SCHEDULED, event -> { labeled.setText(null); }); addEventHandler(WorkerStateEvent.WORKER_STATE_RUNNING, event -> { labeled.setText("Working.."); }); addEventHandler(WorkerStateEvent.WORKER_STATE_SUCCEEDED, event -> { labeled.textProperty().unbind(); labeled.setText(null); }); setExecutor(MainController.EXECUTOR); }
private void handleSuccessEvent(WorkerStateEvent event) { Object eventValue = event.getSource().getValue(); if (eventValue instanceof Sms) { Sms sentSms = (Sms) eventValue; view.showSuccessMessage(sentSms.getId()); } else { view.showErrorMessage(DEFAULT_ERROR_MESSAGE); } view.enableSendButton(); }
private void handleFailureEvent(WorkerStateEvent event) { String errorMessage = DEFAULT_ERROR_MESSAGE; Throwable exception = event.getSource().getException(); if (exception != null) { if (exception instanceof AuthenticationException) { navigator.navigateToLogin(exception.getLocalizedMessage()); view.enableSendButton(); return; } errorMessage += " because " + exception.getLocalizedMessage(); } view.showErrorMessage(errorMessage); view.enableSendButton(); }
private void handleSuccessEvent(WorkerStateEvent event) { Object eventValue = event.getSource().getValue(); if (eventValue instanceof Log) { view.showLog((Log) eventValue); } else { view.showErrorMessage(DEFAULT_ERROR_MESSAGE); } view.enableSearchButton(); }
private void handleFailureEvent(WorkerStateEvent event) { String errorMessage = DEFAULT_ERROR_MESSAGE; Throwable exception = event.getSource().getException(); if (exception != null) { if (exception instanceof AuthenticationException) { navigator.navigateToLogin(exception.getLocalizedMessage()); view.enableSearchButton(); return; } errorMessage += " because " + exception.getLocalizedMessage(); } view.showErrorMessage(errorMessage); view.enableSearchButton(); }
private void handleSuccessEvent(WorkerStateEvent event) { Object eventValue = event.getSource().getValue(); if (eventValue instanceof DeliveryReport) { view.showLog((DeliveryReport) eventValue); } else { view.showErrorMessage(DEFAULT_ERROR_MESSAGE); } view.enableSearchButton(); }
/** * Submit an action as a {@link Callable} instance to be run asynchronously, as well as callback to handle success and failure of the main action. * * @param action an action as a {@link Callable} instance to be run asynchronously * @param onSucceeded a callback to handle success * @param onFailed a callback to handle failure * @param <V> the parameter type for the task * @return the result of the task */ public <V> Future<?> submit(Callable<V> action, EventHandler<WorkerStateEvent> onSucceeded, EventHandler<WorkerStateEvent> onFailed) { Task<V> t = new Task<V>() { @Override protected V call() throws Exception { return action.call(); } }; t.setOnSucceeded(onSucceeded); t.setOnFailed(onFailed); logger.trace(() -> "Task " + t.getTitle() + " submitted"); return threadPool.submit(t); }
