Java 类javafx.concurrent.Service 实例源码

private void backgroundSearch(String query){
    if(query != null) {
        if (!GmailMessages.activeSearches.isEmpty()) {
            for (Service<Void> service : GmailMessages.activeSearches) {
                service.cancel();
            }
        }
        Service<Void> search = new Service<Void>() {
            @Override
            protected Task<Void> createTask() {
                try {
                    GmailOperations.listSearchMessages(query);
                    GmailOperations.getSearchMessages(query);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        };
        GmailMessages.activeSearches.add(search);
        search.start();
    }
}

private void transitToConnectedMode() {
    if(mode == Mode.REMOTE){
        CDH.setPort(Mode.getPort(mode));
    }

    System.out.println("ConnectionManager.State -> "+c.getState().toString());
    if(c.getState() == Service.State.CANCELLED || c.getState() == Service.State.SUCCEEDED){
        Platform.runLater(() ->{
           reinitSession();
        });
    }

    if(c.getState() == Service.State.READY){
        Log.log("FXMLController","attempting to init ConnectionManager");
        initSession();
    }
    TIME_STARTED_LABEL.setText("Time started: "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
    TIME_STOPPED_LABEL.setText("Time stopped: ");
    CONNECT.setDisable(true);
    DISCONNECT.setDisable(false);
}

/**
 * @작성자 : KYJ
 * @작성일 : 2016. 12. 2.
 */
private void loadFontWeights() {

    Service<List<String>> createFxService = new Service<List<String>>() {
        @Override
        protected Task<List<String>> createTask() {
            return new Task<List<String>>() {
                @Override
                protected List<String> call() throws Exception {
                    return FxUtil.FONTUtil.getFontWeights();
                }
            };
        }
    };

    createFxService.setOnSucceeded(w -> {
        List<String> value = createFxService.getValue();
        cbFontWeight.getItems().addAll(value);
    });

    createFxService.start();

}

private void loadFontStyles() {
    Service<List<String>> createFxService = new Service<List<String>>() {
        @Override
        protected Task<List<String>> createTask() {
            return new Task<List<String>>() {
                @Override
                protected List<String> call() throws Exception {
                    return FxUtil.FONTUtil.getFontStyles();
                }
            };
        }
    };

    createFxService.setOnSucceeded(w -> {
        List<String> value = createFxService.getValue();
        cbFontStyles.getItems().addAll(value);
    });



    createFxService.start();

}

@FXML public Service<Void> handleLoginButtonAction(ActionEvent event){
    // Button for google
    Button googleAuth = new Button(Configuration.getBundle().getString("ui.dialog.auth.google.title"), IconFactory.createGoogleIcon());
    LoginDialog dialog = new LoginDialog(googleAuth);
    googleAuth.setOnAction(t -> {
        GoogleLoginDialog googleDialog = new GoogleLoginDialog(dialog);
        googleDialog.show();
    });
    Optional<Pair<String, String>> result = dialog.showAndWait();

    hBottomBox.add(labelField, 0, 0);
    LoginService loginTask = new LoginService();
    result.ifPresent(usernamePassword -> {
        loginTask.setUsername(usernamePassword.getKey());
        loginTask.setPassword(usernamePassword.getValue());
    });
    labelField.textProperty().bind(loginTask.messageProperty());
    return loginTask;
}

@FXML private void handleDownloadButtonAction(ActionEvent event){
    if(! MainApp.getZdsutils().isAuthenticated()){
        Service<Void> loginTask = handleLoginButtonAction(event);
        loginTask.setOnSucceeded(t -> downloadContents(null));
        loginTask.setOnCancelled(t -> {
            hBottomBox.getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.auth.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.auth.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.auth.failed.text"));

            alert.showAndWait();
        });

        loginTask.start();
    }else{
        downloadContents(null);
    }
}

@FXML private void handleDownloadArticleButtonAction(ActionEvent event){
    if(! MainApp.getZdsutils().isAuthenticated()){
        Service<Void> loginTask = handleLoginButtonAction(event);
        loginTask.setOnSucceeded(t -> downloadContents("ARTICLE"));
        loginTask.setOnCancelled(t -> {
            hBottomBox.getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.auth.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.auth.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.auth.failed.text"));

            alert.showAndWait();
        });

        loginTask.start();
    }else{
        downloadContents("ARTICLE");
    }
}

@FXML private void handleDownloadTutorialButtonAction(ActionEvent event){
    if(! MainApp.getZdsutils().isAuthenticated()){
        Service<Void> loginTask = handleLoginButtonAction(event);
        loginTask.setOnSucceeded(t -> downloadContents("TUTORIAL"));
        loginTask.setOnCancelled(t -> {
            hBottomBox.getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.auth.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.auth.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.auth.failed.text"));

            alert.showAndWait();
        });

        loginTask.start();
    }else{
        downloadContents("TUTORIAL");
    }
}

@FXML private void handleDownloadOpinionButtonAction(ActionEvent event){
    if(! MainApp.getZdsutils().isAuthenticated()){
        Service<Void> loginTask = handleLoginButtonAction(event);
        loginTask.setOnSucceeded(t -> downloadContents("OPINION"));
        loginTask.setOnCancelled(t -> {
            hBottomBox.getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.auth.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.auth.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.auth.failed.text"));

            alert.showAndWait();
        });

        loginTask.start();
    }else{
        downloadContents("OPINION");
    }
}

@FXML private void handleUploadButtonAction(ActionEvent event){
    if(! MainApp.getZdsutils().isAuthenticated()){
        Service<Void> loginTask = handleLoginButtonAction(event);
        loginTask.setOnCancelled(t -> {
            hBottomBox.getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.upload.content.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.upload.content.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.upload.content.failed.text"));

            alert.showAndWait();
        });
        loginTask.setOnSucceeded(t -> uploadContents());
        loginTask.start();
    }else{
        uploadContents();
    }
}

@FXML private void handleSelectFileAction(){
    if(! zdsUtils.isAuthenticated()){
        Service<Void> loginTask = menuManager.handleLoginButtonAction(null);
        loginTask.setOnSucceeded(t -> selectAndUploadImage());
        loginTask.setOnCancelled(t -> {
            menuManager.getHBottomBox().getChildren().clear();
            Alert alert = new CustomAlert(AlertType.ERROR);
            alert.setTitle(Configuration.getBundle().getString("ui.dialog.auth.failed.title"));
            alert.setHeaderText(Configuration.getBundle().getString("ui.dialog.auth.failed.header"));
            alert.setContentText(Configuration.getBundle().getString("ui.dialog.auth.failed.text"));

            alert.showAndWait();
        });
        loginTask.start();
    }else{
        selectAndUploadImage();
    }
}

private void startServer(int port) throws Exception {
    new Service<Void>() {

        @Override
        protected Task<Void> createTask() {
            return new Task<Void>() {

                @Override
                protected Void call() throws Exception {
                    new Server().connect(resetButton, connectionStatusLabel,
                            messageLabel, port);
                    return null;
                }

            };
        }

    }.start();
}

public void connect(InetAddress inetAddress, int port) {
    new Service<Void>() {

        @Override
        protected Task<Void> createTask() {
            return new Task<Void>() {

                @Override
                protected Void call() throws Exception {
                    Thread.sleep(3000);
                    connectToAndroid(inetAddress, port);
                    return null;
                }

            };
        }

    }.start();
}

private void initRunningService(final BooleanSupplier autoAdjustResolution, final Runnable updateUI) {
    runningService = new Service<Void>() {

        @Override
        protected Task<Void> createTask() {
            return new Task<Void>() {

                @Override
                protected Void call() throws Exception {
                    looper.start(autoAdjustResolution, updateUI);
                    return null;
                }
            };
        }
    };
    runningService.setOnCancelled(event -> {
        runningService.reset();
        logger.warning("Running is cancelled");
    });
    runningService.setOnFailed(event -> {
        runningService.reset();
        logger.warning("Running is failed");
    });
}

/**
 * @since 2.9.0
 */
@Override
public void start() {
    reset();

    service = new Service<E>() {

        @Override
        protected Task<E> createTask() {
            return new Task<E>() {

                @Override
                protected E call() throws Exception {
                    return execute();
                }
            };
        }
    };

    service.setOnCancelled(getFailureEvent());
    service.setOnFailed(getFailureEvent());
    service.setOnSucceeded(getSuccessEvent());
    service.start();
}

@Override
public void start(Stage stage) {
    FlatterFX.style();
    ServiceChain demoControl = new ServiceChain();
    Scene scene = new Scene(demoControl, 800, 400);
    stage.setScene(scene);
    stage.setTitle("ServiceChain Demo");

    final Service<String> service = createServiceOne();
    createServiceChain(service,demoControl);
    demoControl.startService.setOnMouseClicked((val) -> {
        if (!service.isRunning()) {
            service.reset();
            demoControl.stepOneRectangle.setStroke(Color.GREEN);
            demoControl.stepOneRectangle.setVisible(true);
            service.start();
        }
    });
    demoControl.progressService.progressProperty().bind(service.progressProperty());

    stage.show();
}

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 LocalRepoListMainTreeItem() {
    super("Local repositories");
    setGraphic(new ImageView(icon));

    new Service<List<LocalRepo>>() {
        @Override
        protected Task<List<LocalRepo>> createTask() {
            return new SsTask<List<LocalRepo>>() {
                @Override
                protected List<LocalRepo> call() throws Exception {
                    final LocalRepoRegistry localRepoRegistry = getLocalRepoRegistry();
                    return localRepoRegistry.getLocalRepos();
                }

                @Override
                protected void succeeded() {
                    final List<LocalRepo> localRepos;
                    try { localRepos = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addTableItemsViewCallback(localRepos);
                    super.succeeded();
                }
            };
        }
    }.start();
}

public ServerListMainTreeItem() {
    super("Servers");
    setGraphic(new ImageView(icon));

    new Service<List<Server>>() {
        @Override
        protected Task<List<Server>> createTask() {
            return new SsTask<List<Server>>() {
                @Override
                protected List<Server> call() throws Exception {
                    return getServerRegistry().getServers();
                }

                @Override
                protected void succeeded() {
                    final List<Server> servers;
                    try { servers = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addTreeItemsViewCallback(servers);
                    super.succeeded();
                }
            };
        }
    }.start();
}

private void updateCollisionIcon() {
    new Service<Image>() {
        @Override
        protected Task<Image> createTask() {
            return new SsTask<Image>() {
                @Override
                protected Image call() throws Exception {
                    return _getCollisionIcon();
                }

                @Override
                protected void succeeded() {
                    final Image result;
                    try { result = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    collisionIcon.set(result);
                }
            };
        }
    }.start();
}

private void populateTableViewAsync() {
    new Service<Collection<Server>>() {
        @Override
        protected Task<Collection<Server>> createTask() {
            return new SsTask<Collection<Server>>() {
                @Override
                protected Collection<Server> call() throws Exception {
                    getPgpSyncDaemon(); // hook listener
                    getLockerSyncDaemon(); // hook listener
                    return getServerRegistry().getServers();
                }

                @Override
                protected void succeeded() {
                    final Collection<Server> servers;
                    try { servers = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addOrRemoveTableItemsViewCallback(servers);
                }
            };
        }
    }.start();
}

@FXML
private void syncButtonClicked(final ActionEvent event) {
    new Service<Void>() {
        @Override
        protected Task<Void> createTask() {
            return new SsTask<Void>() {
                @Override
                protected Void call() throws Exception {
                    getPgpSyncDaemon().sync();
                    getLockerSyncDaemon().sync();
                    return null;
                }
            };
        }
    }.start();
}

private void populateTableViewAsync() {
    new Service<Collection<User>>() {
        @Override
        protected Task<Collection<User>> createTask() {
            return new SsTask<Collection<User>>() {
                @Override
                protected Collection<User> call() throws Exception {
                    return getUserRegistry().getUsers();
                }

                @Override
                protected void succeeded() {
                    final Collection<User> users;
                    try { users = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addTableItemsViewCallback(users);
                }
            };
        }
    }.start();
}

private void populateTableViewAsync() {
    new Service<Collection<LocalRepo>>() {
        @Override
        protected Task<Collection<LocalRepo>> createTask() {
            return new SsTask<Collection<LocalRepo>>() {
                @Override
                protected Collection<LocalRepo> call() throws Exception {
                    getRepoSyncDaemon(); // hook listener
                    return getLocalRepoRegistry().getLocalRepos();
                }

                @Override
                protected void succeeded() {
                    final Collection<LocalRepo> localRepos;
                    try { localRepos = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addOrRemoveTableItemsViewCallback(localRepos);
                }
            };
        }
    }.start();
}

@FXML
private void syncAllButtonClicked(final ActionEvent event) {
    new Service<Void>() {
        @Override
        protected Task<Void> createTask() {
            return new SsTask<Void>() {
                @Override
                protected Void call() throws Exception {
                    for (LocalRepo localRepo : getLocalRepoRegistry().getLocalRepos())
                        getRepoSyncDaemon().startSync(localRepo.getLocalRoot());

                    return null;
                }
            };
        }
    }.start();
}

@FXML
private void syncButtonClicked(final ActionEvent event) {
    final List<File> selectedLocalRoots = new ArrayList<>();
    for (LocalRepoListItem li : tableView.getSelectionModel().getSelectedItems())
        selectedLocalRoots.add(li.getLocalRoot());

    new Service<Void>() {
        @Override
        protected Task<Void> createTask() {
            return new SsTask<Void>() {
                @Override
                protected Void call() throws Exception {
                    for (File localRoot : selectedLocalRoots)
                        getRepoSyncDaemon().startSync(localRoot);

                    return null;
                }
            };
        }
    }.start();
}

private void populateTableViewAsync() {
    new Service<Collection<ServerRepo>>() {
        @Override
        protected Task<Collection<ServerRepo>> createTask() {
            return new SsTask<Collection<ServerRepo>>() {
                @Override
                protected Collection<ServerRepo> call() throws Exception {
                    return getServerRepoRegistry().getServerReposOfServer(server.getServerId());
                }

                @Override
                protected void succeeded() {
                    final Collection<ServerRepo> serverRepos;
                    try { serverRepos = get(); } catch (InterruptedException | ExecutionException e) { throw new RuntimeException(e); }
                    addTableItemsViewCallback(serverRepos);
                }
            };
        }
    }.start();
}

/**
 * Creates a dialog service for showing and hiding a {@linkplain Stage}
 *
 * @param parent
 *            the parent {@linkplain Stage}
 * @param window
 *            the window {@linkplain Stage} that will be shown/hidden
 * @param messageHeader
 *            the messageHeader {@linkplain Text} used for the service
 *            that will be updated with exception information as the
 *            submitService informs the {@linkplain DialogService} of
 * @param submitService
 *            the {@linkplain Service} that will be listened to for
 *            {@linkplain State#SUCCEEDED} at which point the
 *            {@linkplain DialogService} window {@linkplain Stage} will
 *            be hidden
 */
protected DialogService(final Stage parent, final Stage window,
        final Text messageHeader, final Service<Void> submitService) {
    this.window = window;
    this.parent = parent;
    this.origEffect = hasParentSceneRoot() ? this.parent.getScene(
            ).getRoot().getEffect() : null;
    this.submitService = submitService;
    this.submitService.stateProperty().addListener(new ChangeListener<State>() {
        @Override
        public void changed(final ObservableValue<? extends State> observable,
                final State oldValue, final State newValue) {
            if (submitService.getException() != null) {
                // service indicated that an error occurred
                messageHeader.setText(submitService.getException().getMessage());
            } else if (newValue == State.SUCCEEDED) {
                window.getScene().getRoot().setEffect(
                        ColorAdjustBuilder.create().brightness(-0.5d).build());
                Platform.runLater(createHideTask());
            }
        }
    });
}

/**
 * Creates a dialog service for showing and hiding a {@linkplain Stage}
 *
 * @param parent
 *            the parent {@linkplain Stage}
 * @param window
 *            the window {@linkplain Stage} that will be shown/hidden
 * @param messageHeader
 *            the messageHeader {@linkplain Text} used for the service
 *            that will be updated with exception information as the
 *            submitService informs the {@linkplain DialogService} of
 * @param submitService
 *            the {@linkplain Service} that will be listened to for
 *            {@linkplain State#SUCCEEDED} at which point the
 *            {@linkplain DialogService} window {@linkplain Stage} will
 *            be hidden
 */
protected DialogService(final Stage parent, final Stage window,
        final Text messageHeader, final Service<Void> submitService) {
    this.window = window;
    this.parent = parent;
    this.origEffect = hasParentSceneRoot() ? this.parent.getScene(
            ).getRoot().getEffect() : null;
    this.submitService = submitService;
    this.submitService.stateProperty().addListener(new ChangeListener<State>() {
        @Override
        public void changed(final ObservableValue<? extends State> observable,
                final State oldValue, final State newValue) {
            if (submitService.getException() != null) {
                // service indicated that an error occurred
                messageHeader.setText(submitService.getException().getMessage());
            } else if (newValue == State.SUCCEEDED) {
                window.getScene().getRoot().setEffect(
                        ColorAdjustBuilder.create().brightness(-0.5d).build());
                Platform.runLater(createHideTask());
            }
        }
    });
}

public void removeAllBlocs() {

        final Bloc[][] blocs = currentRoundDetails.blocs;

        int maxX = blocs.length;
        int maxY = blocs[0].length;

        final Service<Void> calculateService = new Service<Void>() {

            @Override
            protected Task<Void> createTask() {
                return new Task<Void>() {

                    @Override
                    protected Void call() throws Exception {
                        for (int i = 0; i < maxX; i++) {
                            for (int j = 0; j < maxY; j++) {

                                removeBloc(blocs[i][j]);

                            }
                        }
                        return null;
                    }
                };
            }
        };
        calculateService.start();
    }

/**
 *
 * 코드 분석 시작 처리.
 * @작성자 : KYJ
 * @작성일 : 2017. 2. 3.
 */
public void start() {

    // 동적처리에 따라 API 함수 수정.
    FileUtil.consumeJavaParser(targetFile, cu -> {

        NameExpr name = cu.getPackage().getName();
        lblPackage.setText(name.toString());
        String importStatement = cu.getImports().stream().map(im -> im.getName().toString()).collect(Collectors.joining(","));
        lblImports.setText(importStatement);

        Service<Void> service = new Service<Void>() {
            @Override
            protected Task<Void> createTask() {

                return new Task<Void>() {

                    @Override
                    protected Void call() throws Exception {
                        new MethodVisitor(v -> {

                            methodData.add(v);

                        }).visit(cu, null);
                        return null;
                    }
                };
            }
        };
        service.start();

    } , err ->{
        LOGGER.error(ValueUtil.toString(err));
    });

}

/**
 * 폰트명 로딩
 * @작성자 : KYJ
 * @작성일 : 2016. 12. 2.
 */
private void loadFontNames() {

    Service<List<String>> createFxService = new Service<List<String>>() {
        @Override
        protected Task<List<String>> createTask() {
            return new Task<List<String>>() {
                @Override
                protected List<String> call() throws Exception {
                    List<String> avaliableFontNames = FxUtil.FONTUtil.getAvaliableFontNames();
                    return avaliableFontNames;
                }
            };
        }
    };

    createFxService.setOnSucceeded(w -> {
        List<String> value = createFxService.getValue();
        cbFontNames.getItems().addAll(value);
        LOGGER.debug("Font Load Completed.");

        cbFontNames.setDisable(false);
    });

    createFxService.setExecutor(newFixedThreadExecutor);
    createFxService.start();

}

public void logout() {
    Service<Void> service = new Service<Void>() {
        @Override
        protected Task<Void> createTask() {
            return new Task<Void>() {
                @Override
                protected Void call() throws Exception {
                    if (logged) {
                        try {
                            HttpUriRequest request = RequestBuilder.get().setUri("/logout").setConfig(requestConfig)
                                    .build();
                            EntityUtils.toString(
                                    closeableHttpClient.execute(target, request, httpClientContext).getEntity());
                            closeableHttpClient.close();
                            cookieStore.clear();
                            logged = false;
                            Context.setMessage("Wylogowano pomyślnie", "green");
                        } catch (Exception ex) {
                            Context.setMessage("Wystąpił problem z połączeniem", "red");
                        }
                    } else {
                        Context.setMessage("Nie jesteś zalogowany", "red");
                    }
                    return null;
                }
            };
        }
    };
    service.start();
}

@FXML
private void handleImport(ActionEvent event) {
    final Service<Attachments> service = importersBox.getValue();
    if (service.isRunning()) {
        service.cancel();
        return;
    }
    service.reset();

    importersBox.disableProperty().bind(service.runningProperty());
    progressBar.visibleProperty().bind(service.runningProperty());
    progressBar.progressProperty().bind(service.progressProperty());
    service.runningProperty().addListener(e -> {
        final String key = service.isRunning() ? "cancel" : "import";
        importButton.setText(resources.getString(key));
    });
    service.setOnFailed(e -> Notification.error(resources.getString("notification.failed")));
    service.setOnSucceeded(e -> {
        Notification.success(resources.getString("notification.completed"));

        final Attachments attachments = service.getValue();
        if (attachments == null) return;

        NoticeController.getNoticeTreeViewController().getCurrentNotice().addAttachments(attachments);
        NoticeController.getNoticeViewController().rebuildAttachsView();
    });
    service.start();
}

/**
 * Sets up the {@link Alert}, using the {@link Service} provided.
 * When the service has succeeded, the alert is closed.
 * @param window The parent Node of this dialog.
 * @param service The service being watched.
 */
public ProgressDialog(Window window, Service<?> service) {
    super(AlertType.NONE);
    this.window = window;
    this.setOnCloseRequest(e -> service.cancel());
    setupProgressBar();
    setupAlert();
}

/**
 * Registers a listener on the service to update the completableFuture.
 * @param service The service.
 * @param completableFuture The future.
 * @param <T> The expected type.
 */
public static <T> void registerListeners(Service<T> service,
        CompletableFuture<T> completableFuture) {
    service.setOnSucceeded(e -> completableFuture.complete(service.getValue()));
    service.setOnFailed(e ->
        completableFuture.completeExceptionally(service.getException()));
    service.setOnCancelled(e -> completableFuture.cancel(true));
}

/**
 * Starts a new game.
 */
private void startNewGame() {
    game = new Game();
    game.start();
    gameService = new Service<Boolean>() {

        @Override
        protected Task<Boolean> createTask() {
            return new Task<Boolean>() {

                @Override
                protected Boolean call() throws Exception {
                    return game.nextLoop();
                }
            };
        }
    };
    gameService.setOnSucceeded((WorkerStateEvent event1) -> {
        updateContent();
        Boolean flag = (Boolean) event1.getSource().getValue();
        if (flag) {
            gameService.restart();
        } else {
            AddPersonDialogController.setScore(game.getPlayerA().getScore());
            AddPersonDialog.getAddpersonstage().show();
        }
    });
    updateContent();
    gameService.start();
}

private void handleAction(ActionEvent ae) {

        // retrieving bean properties may take some time
        // so we have to put it on separate thread to keep UI responsive
        Service<?> service = new Service<ObservableList<Item>>() {

            @Override
            protected Task<ObservableList<Item>> createTask() {
                return new Task<ObservableList<Item>>() {
                    @Override
                    protected ObservableList<Item> call() throws Exception {
                        return bean == null ? null : getProperties(bean);
                    }
                };
            }

        };
        service.setOnSucceeded(new EventHandler<WorkerStateEvent>() {

            @SuppressWarnings("unchecked")
            @Override
            public void handle(WorkerStateEvent e) {
                ObservableList<Item> items = (ObservableList<Item>) e.getSource().getValue();
                if (items != null) {
                    try {
                        propertySheet.getItems().setAll(items.filtered((v) -> v != null));
                    } catch (Exception exc) {
                        //exc.printStackTrace();
                        propertySheet.getItems().clear();
                    }
                } else {
                    propertySheet.getItems().clear();
                }
            }
        });
        service.start();

    }

private void initScriptService(final Runnable updateUI) {
    scriptService = new Service<Void>() {

        @Override
        protected Task<Void> createTask() {
            return new Task<Void>() {

                @Override
                protected Void call() throws Exception {
                    updateUI.run();
                    try {
                        Platform.instance().init();
                    } catch (final BotConfigurationException e) {
                        logger.log(Level.WARNING, e.getMessage(), e);
                    }
                    ScriptManager.instance().run(runningScript);
                    return null;
                }
            };
        }
    };
    scriptService.setOnCancelled(event -> {
        scriptService.reset();
        runningScript = null;
        updateUI.run();
        logger.warning("Script is cancelled");
    });
    scriptService.setOnFailed(event -> {
        scriptService.reset();
        runningScript = null;
        updateUI.run();
        logger.warning("Script is failed");
    });
    scriptService.setOnSucceeded(event -> {
        scriptService.reset();
        runningScript = null;
        updateUI.run();
        logger.log(Level.INFO, "Script is succeeded");
    });
}