Java 类javafx.concurrent.Task 实例源码

public ViewerAboutDialog(Stage stage) {
    ImageView image = ImageUtils.createImageView("/icons/spy128.png");
    this.setCenter(image);
    this.setOnMouseClicked(e -> stage.close());

    image.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
        Task<Void> task = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                Desktop.getDesktop().browse(URI.create(homeUrl));
                return null;
            }
        };
        task.setOnFailed(e -> {
            Throwable exception = e.getSource().getException();
            if (exception != null) {
                Log.error(exception);
                ViewerAlert.exceptionAlert(exception);
            }
        });

        new Thread(task).start();
    });

}

@Test
public void shouldShowProgressBarWhileGivenTaskRun() throws Exception {
    Task<Void> task = new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            Thread.sleep(1000);
            return null;
        }
    };

    statusBar.bindProgressTo(task);
    view.checkProgressBarIsNotVisible();

    new Thread(task).start();

    view.waitUntilProgressBarIsVisible();
    view.waitUntilProgressBarIsNotVisible();
}

public void partialSync(){
    Task<Void> syncNewMails = new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            while (true) {
                try {
                    Thread.sleep(5000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                GmailOperations.getNewInboxMails();
                GmailOperations.getNewSentMails();
                GmailOperations.getNewDraftMails();
                GmailOperations.getNewTrashMails();

            }
        }
    };

    Thread backgroundThread = new Thread(syncNewMails);
    backgroundThread.setDaemon(true);
    backgroundThread.start();

}

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();
    }
}

/**
 * Monitors a given task, and updates the current status and progress accordingly.
 *
 * @param task the {@link Consumer<ProgressUpdater>} to monitor
 */
public void monitorTask(final Consumer<ProgressUpdater> task) {
    final Task<Void> progressTask = new Task<Void>() {
        @Override
        public Void call() throws InterruptedException {
            task.accept((progress, message) -> Platform.runLater(() -> {
                this.updateProgress(progress, PROGRESS_MAX);
                statusProperty.set(message);
            }));
            return null;
        }
    };

    progressProperty.unbind();
    progressProperty.bind(progressTask.progressProperty());

    new Thread(progressTask).start();
}

public static <T> CompletableFuture<T> runAsyncTask(Callable<T> task) {
    Task<T> jfxTask = new Task<T>() {
        @Override
        protected T call() throws Exception {
            return task.call();
        }
    };

    CompletableFuture<T> ret = new CompletableFuture<T>();

    jfxTask.setOnSucceeded(event -> ret.complete(jfxTask.getValue()));
    jfxTask.setOnFailed(event -> ret.completeExceptionally(jfxTask.getException()));
    jfxTask.setOnCancelled(event -> ret.cancel(false));

    threadPool.execute(jfxTask);

    return ret;
}

public void loadThreadMes(Label lbl) {
    Task tMes = new Task<Void>() {
        DecimalFormat df = new DecimalFormat("#.00€");

        @Override
        protected Void call() throws Exception {
            Platform.runLater(new Runnable() {
                @Override
                public void run() {
                    lbl.setText(df.format(mesatarja()) + "");
                }
            });
            return null;
        }
    };
    Thread mesT = new Thread(tMes);
    mesT.setDaemon(true);
    mesT.start();
}

public static void keyPress(String key)
{
    if(playerEntity != null)
    {
        playerEntity.keyPress(key);
    }
    else
    {
        if(key.compareTo("R")==0)
        {
            Task<Void> mainLoop = new MainLoop();
            Thread mainLoopThread = new Thread(mainLoop);
            mainLoopThread.start();
        }
    }
}

public void start(final Stage initStage) {        
    initStage.getIcons().add(new Image(APPLICATION_ICON));
    initStage.setResizable(false);
    initStage.setAlwaysOnTop(true);
    final Task<ObservableList<String>> friendTask = new Task<ObservableList<String>>() {
        @Override
        protected ObservableList<String> call() throws InterruptedException {
            ObservableList<String> titles = FXCollections.<String>observableArrayList();
            ObservableList<String> loadings = FXCollections.observableArrayList(
                    "Validate Version", "Running", "Initialize application", "Preparing ...", "Please Wait", "Done"
            );

            updateMessage("Checking Version");
            for (int i = 0; i < loadings.size(); i++) {
                Thread.sleep(400);
                updateProgress(i + 1, loadings.size());
                String nextFriend = loadings.get(i);
                titles.add(nextFriend);
                updateMessage("Chess Bot 1.0.0 ...  " + nextFriend);
            }

            Thread.sleep(400);

            return titles;
        }
    };

    showSplash(initStage, friendTask, () -> showMainStage());
    new Thread(friendTask).start();
}

@FXML
private void removeStore() {
    final int selectedIndex = indexView.getSelectionModel().getSelectedIndex();

    if (selectedIndex == -1) {
        return;
    }

    createTask(new Task<Boolean>() {

        @Override
        protected Boolean call() throws Exception {
            cache.removeStore(indexView.getSelectionModel().getSelectedItem().getId());
            cache.reset();
            Platform.runLater(() ->indexes.remove(selectedIndex));
            return true;
        }
    }, true);
}

/**
 * stop the monitoring
 */
public void stopMonitoring() {
  if (monitortask == null)
    return;
  // TODO use better symbol e.g. icon
  setWatchDogState("X", I18n.get(I18n.HALTED));
  setMenuItemDisable(I18n.OBD_START_MENU_ITEM, false);
  setMenuItemDisable(I18n.OBD_START_WITH_LOG_MENU_ITEM,
      simulatorPane != null);
  setMenuItemDisable(I18n.OBD_TEST_MENU_ITEM, false);
  setMenuItemDisable(I18n.OBD_HALT_MENU_ITEM, true);
  Task<Void> task = new Task<Void>() {
    @Override
    public Void call() {
      try {
        obdApp.stop();
      } catch (Exception e) {
        handleException(e);
      }
      return null;
    }
  };
  new Thread(task).start();
}

@FXML
private void defragment() {
    if (!cache.isLoaded()) {
        Dialogue.showWarning("Load your cache first.").showAndWait();
        return;
    }

    createTask(new Task<Boolean>() {

        @Override
        protected Boolean call() throws Exception {
            if (!cache.defragment()) {
                Platform.runLater(() -> Dialogue.showWarning("Failed to defragment cache.").showAndWait());
            }
            return true;
        }
    }, true);
}

@Override
protected Task<Void> createTask() {
    return new Task<Void>() {
        @Override
        protected Void call() throws SQLException, InterruptedException {
            try (Connection connection = DataSourceFactory.getConfiguredDataSource(properties, textPassword.getText()).getConnection()) {
                if (isCancelled()) return null;

                LOGGER.info("Successfully connected to the database.");
                linkifier = new Linkifier(connection, properties.getProperty("schema"));
                if (isCancelled()) return null;

                linkifier.estimatePk();
                if (isCancelled()) return null;

                linkifier.estimateFk();
                LOGGER.info("Estimated foreign key constraint count: " + linkifier.getFkCount());
            }

            return null;
        }
    };
}

/**
 * 
 * Perform an async call
 * 
 * @param action
 * @param success
 * @param error
 */
public static <T extends Object> void doAsyncWork(Supplier<T> action, Consumer<T> success,
        Consumer<Throwable> error) {
    Task<T> tarefaCargaPg = new Task<T>() {
        @Override
        protected T call() throws Exception {
            return action.get();
        }

        @Override
        protected void succeeded() {
            success.accept(getValue());
        }

        @Override
        protected void failed() {
            error.accept(getException());
        }
    };
    Thread t = new Thread(tarefaCargaPg);
    t.setDaemon(true);
    t.start();
}

public static <T extends Object> void doBlockingAsyncWork(Scene scene, Supplier<T> action, Consumer<T> success,
        Consumer<Throwable> error) {
    Parent originalRoot = scene.getRoot();
    Runnable blockScreen = () -> originalRoot.setDisable(true);
    Runnable unblockScreen = () -> originalRoot.setDisable(false);

    Task<T> task = new Task<T>() {
        @Override
        protected T call() throws Exception {
            blockScreen.run();
            return action.get();
        }

        @Override
        protected void succeeded() {
            unblockScreen.run();
            success.accept(getValue());
        }

        @Override
        protected void failed() {
            unblockScreen.run();
            error.accept(getException());
        }
    };
    Thread t = new Thread(task);
    t.setDaemon(true);
    t.start();
}

public void runTask(final FXMLC home)
{
    Commands.Connect();
    System.out.println("connected");
    while (true)
    {
        try
        {
            Platform.runLater(new Runnable()
            {
                @Override
                public void run()
                {
                    Task(home);
                }
            });

            Thread.sleep(10);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

@Test
public void shouldShowProgressIndicatorAndMessageWhileGivenTaskRun() throws Exception {
    Task<Void> task = new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            Thread.sleep(1000);
            return null;
        }
    };

    String message = "Status message...";

    statusBar.bindProgressTo(task, message);
    view.checkProgressIndicatorIsNotVisible();

    new Thread(task).start();

    view.waitUntilProgressIndicatorIsVisible();
    view.waitUntilStatusMessageIsVisible(message);

    view.waitUntilProgressIndicatorIsNotVisible();
    view.waitUntilStatusMessageIsNotVisible(message);
}

@Override
protected Task<Void> createTask() {
    return new PageTask<ModpackTile>(entries.get(), tiles, placeholder, count) {
        @Override
        public void addElement(List<ModpackTile> elements, Map.Entry<String, CurseProject> entry) {
            Instance instance = new CurseImporter(entry.getKey()).create();
            if (instance != null) {
                MiscUtil.runLaterIfNeeded(() -> {
                    elements.add(new ModpackTile(instance));
                    page.setText((count.intValue() - entries.get().size()) + "/" + count.intValue());
                });
            }

        }
    };
}

@Override
protected Task<Boolean> createTask() {
    return new Task<Boolean>() {
        @Override
        protected Boolean call() throws Exception {
            System.out.println("try to write to file");
            boolean write = false;
            try {
                write = ImageIO.write(image, "png", new File(filePath));
            } catch (IOException ex) {
                return write;
            }
            return write;
        }
    };
}

@Override
protected Task<Void> createTask() {
    return new PageTask<ModTile>(entries.get(), tiles, placeholder, count) {
        @Override
        public void addElement(List<ModTile> elements, Map.Entry<String, CurseProject> entry) {
            CurseFullProject project = JsonUtil.read(Curse.getProjectURL(entry.getValue().Id), CurseFullProject.class);
            CurseModInstaller installer = new CurseModInstaller(instance, project);
            installer.setResolveDependencies(true);
            if (instance != null) {
                MiscUtil.runLaterIfNeeded(() -> {
                    elements.add(new ModTile(instance, installer));
                    page.setText((count.intValue() - entries.get().size()) + "/" + count.intValue());
                });
            }
        }
    };
}

public void loadThread(Label lbl) {
    Task task = new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            Platform.runLater(new Runnable() {
                @Override
                public void run() {
                    lbl.setText(totalVitiAktual() + " / " + totalPunet());
                }
            });
            return null;
        }
    };
    Thread newT = new Thread(task);
    newT.setDaemon(true);
    newT.start();
}

private void addImages(ObservableList<Image> images) {
    Task<Void> importTask = new Task<Void>() {
        @Override
        protected Void call() throws InterruptedException, IOException {
            final int size = images.size();
            for (int i = 0; i < size; i++) {
                if (Thread.currentThread().isInterrupted()) break;
                addImageView(images.get(i));
                updateProgress(i, size);
            }
            return null;
        }
    };

    TaskRunner.run(importTask, "Loading Images...", null);
}

@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();
            }
        }
    });


}

public void startHost() {

        Task<Void> task = new Task() {
            @Override
            protected Void call() throws Exception {
                host.start();
                return null;
            }

            @Override
            protected void succeeded() {
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        Platform.runLater(() -> {
                            TesterHost thost = (TesterHost) host;
                            thost.execute();
                            try {
                                Parent root = FXMLLoader.load(getClass().getResource("/ussd/fxml/USSD-GUI.fxml"));
                                Stage st = UssdClient.st;
                                st.setScene(new Scene(root));
                                st.centerOnScreen();
                            } catch (IOException ex) {
                                Logger.getLogger(Impl.class.getName()).log(Level.SEVERE, null, ex);
                            }
                        });

                    }
                }, 10000);
            }

        };

        new Thread(task).start();
    }

/**
 * Initialize the given {@link Task}, and set the {@link Scene} of the {@link Stage}.
 *
 * @param progressTask {@link Task} to initialize
 */
private void initialize(final Task<Void> progressTask) {
    try {
        final Parent root = fxmlLoader.load();
        stage.setScene(new Scene(root));

        setController(fxmlLoader.getController());
        progressBarController.activateProgressBar(progressTask);

        new Thread(progressTask).start();
    } catch (final IOException e) {
        LOGGER.error("Unable to load progress bar view.", e);
    }
}

public void runProgressTask(String labelText, Consumer<DoubleConsumer> task, Runnable onSuccess, Consumer<Throwable> onError) {
    Stage stage = new Stage(StageStyle.UTILITY);
    stage.initOwner(this.scene.getWindow());
    VBox pane = new VBox(GuiConstants.padding);

    stage.setScene(new Scene(pane));
    stage.initModality(Modality.APPLICATION_MODAL);
    stage.setOnCloseRequest(event -> event.consume());
    stage.setResizable(false);
    stage.setTitle("Operation progress");

    pane.setPadding(new Insets(GuiConstants.padding));

    pane.getChildren().add(new Label(labelText));

    ProgressBar progress = new ProgressBar(0);
    progress.setPrefWidth(400);
    pane.getChildren().add(progress);

    stage.show();

    Task<Void> jfxTask = new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            task.accept(cProgress -> Platform.runLater(() -> progress.setProgress(cProgress)));

            return null;
        }
    };

    jfxTask.setOnSucceeded(event -> {
        onSuccess.run();
        stage.hide();
    });

    jfxTask.setOnFailed(event -> {
        onError.accept(jfxTask.getException());
        stage.hide();
    });

    threadPool.execute(jfxTask);
}

/**
 * Update the parent tasks in the database. Used after dragging a task, we
 * only have to update the parents, because the subtasks only depend on
 * their parents, and are independent of the day and the order in the day.
 *
 * @param day
 *         The day of which to update the tasks.
 * @param parentTasks
 *         The list with parents to update.
 */
public void updateParentDatabase(LocalDate day,
                                 List<HomeworkTask> parentTasks) {
    progressIndicator.setVisible(true);
    Task<HomeworkTask> task = new Task<HomeworkTask>() {
        @Override
        public HomeworkTask call() throws Exception {
            updateParentsSynced(day, parentTasks);
            return null;
        }
    };
    task.setOnSucceeded(e -> progressIndicator.setVisible(false));
    exec.execute(task);
}

/**
 * Updates database using the given homework tasks for a day.
 *
 * @param day
 *         Date from which the tasks are.
 * @param homeworkTasks
 *         Tasks to be put in the database.
 */
public void updateDatabase(LocalDate day,
                           List<List<HomeworkTask>> homeworkTasks) {
    progressIndicator.setVisible(true);
    Task<List<HomeworkTask>> task = new Task<List<HomeworkTask>>() {
        @Override
        public List<HomeworkTask> call() throws Exception {
            updateDatabaseSynced(day, homeworkTasks);
            return null;
        }
    };
    task.setOnSucceeded(e -> progressIndicator.setVisible(false));
    exec.execute(task);
}

@Override
protected Task<Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]>> createTask() {
    return new Task<Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]>>() {

        @Override
        protected Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]> call() throws Exception {
            ProductTypeTransitCumulativeSeriesSales[] productResults = null;
            TransitCumulativeSales[] regionOrStateResults = null;
            if (regionSelection.get().equals("All Regions")) {
                productResults = clsClient.findTypeRange_JSON(ProductTypeTransitCumulativeSeriesSales[].class, from.get(), to.get());
                if (isCancelled()) {
                    return null;
                }
                regionOrStateResults = clsClient.findRegionRange_JSON(RegionTransitCumulativeSales[].class, from.get(), to.get());
                if (isCancelled()) {
                    return null;
                }
            } else {
                int productId = ((Region) regionSelection.get()).getRegionId();
                productResults = clsClient.findTypeRegionRange_JSON(ProductTypeTransitCumulativeSeriesSales[].class, from.get(), to.get(), productId);
                if (isCancelled()) {
                    return null;
                }
                regionOrStateResults = clsClient.findRegionStateRange_JSON(StateTransitCumulativeSales[].class, from.get(), to.get(), productId);
                if (isCancelled()) {
                    return null;
                }
            }
            return new Pair(productResults, regionOrStateResults);
        }
    };
}

public TaskSample() {
    TableView<DailySales> tableView = new TableView<DailySales>();
    Region veil = new Region();
    veil.setStyle("-fx-background-color: rgba(0, 0, 0, 0.4)");
    ProgressIndicator p = new ProgressIndicator();
    p.setMaxSize(150, 150);
    //Define table columns
    TableColumn idCol = new TableColumn();
    idCol.setText("ID");
    idCol.setCellValueFactory(new PropertyValueFactory("dailySalesId"));
    tableView.getColumns().add(idCol);
    TableColumn qtyCol = new TableColumn();
    qtyCol.setText("Qty");
    qtyCol.setCellValueFactory(new PropertyValueFactory("quantity"));
    tableView.getColumns().add(qtyCol);
    TableColumn dateCol = new TableColumn();
    dateCol.setText("Date");
    dateCol.setCellValueFactory(new PropertyValueFactory("date"));
    dateCol.setMinWidth(240);
    tableView.getColumns().add(dateCol);
    StackPane stack = new StackPane();
    stack.getChildren().addAll(tableView, veil, p);

    // Use binding to be notified whenever the data source chagnes
    Task<ObservableList<DailySales>> task = new GetDailySalesTask();
    p.progressProperty().bind(task.progressProperty());
    veil.visibleProperty().bind(task.runningProperty());
    p.visibleProperty().bind(task.runningProperty());
    tableView.itemsProperty().bind(task.valueProperty());

    getChildren().add(stack);
    new Thread(task).start();
}

@Override
protected Task<Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]>> createTask() {
    return new Task<Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]>>() {

        @Override
        protected Pair<ProductTypeTransitCumulativeSeriesSales[], TransitCumulativeSales[]> call() throws Exception {
            ProductTypeTransitCumulativeSeriesSales[] productResults = null;
            TransitCumulativeSales[] regionOrStateResults = null;
            if (regionSelection.get().equals("All Regions")) {
                productResults = clsClient.findTypeRange_JSON(ProductTypeTransitCumulativeSeriesSales[].class, from.get(), to.get());
                if (isCancelled()) {
                    return null;
                }
                regionOrStateResults = clsClient.findRegionRange_JSON(RegionTransitCumulativeSales[].class, from.get(), to.get());
                if (isCancelled()) {
                    return null;
                }
            } else {
                int productId = ((Region) regionSelection.get()).getRegionId();
                productResults = clsClient.findTypeRegionRange_JSON(ProductTypeTransitCumulativeSeriesSales[].class, from.get(), to.get(), productId);
                if (isCancelled()) {
                    return null;
                }
                regionOrStateResults = clsClient.findRegionStateRange_JSON(StateTransitCumulativeSales[].class, from.get(), to.get(), productId);
                if (isCancelled()) {
                    return null;
                }
            }
            return new Pair(productResults, regionOrStateResults);
        }
    };
}

public TaskSample() {
    TableView<DailySales> tableView = new TableView<DailySales>();
    Region veil = new Region();
    veil.setStyle("-fx-background-color: rgba(0, 0, 0, 0.4)");
    ProgressIndicator p = new ProgressIndicator();
    p.setMaxSize(150, 150);
    //Define table columns
    TableColumn idCol = new TableColumn();
    idCol.setText("ID");
    idCol.setCellValueFactory(new PropertyValueFactory("dailySalesId"));
    tableView.getColumns().add(idCol);
    TableColumn qtyCol = new TableColumn();
    qtyCol.setText("Qty");
    qtyCol.setCellValueFactory(new PropertyValueFactory("quantity"));
    tableView.getColumns().add(qtyCol);
    TableColumn dateCol = new TableColumn();
    dateCol.setText("Date");
    dateCol.setCellValueFactory(new PropertyValueFactory("date"));
    dateCol.setMinWidth(240);
    tableView.getColumns().add(dateCol);
    StackPane stack = new StackPane();
    stack.getChildren().addAll(tableView, veil, p);

    // Use binding to be notified whenever the data source chagnes
    Task<ObservableList<DailySales>> task = new GetDailySalesTask();
    p.progressProperty().bind(task.progressProperty());
    veil.visibleProperty().bind(task.runningProperty());
    p.visibleProperty().bind(task.runningProperty());
    tableView.itemsProperty().bind(task.valueProperty());

    getChildren().add(stack);
    new Thread(task).start();
}

@Override
public void onStart() {
    root.prefWidthProperty().bind(Main.mainController.contentBox.widthProperty());
    root.prefHeightProperty().bind(Main.mainController.contentBox.heightProperty());
    Bindings.bindContent(downloads.getTasks(), FXCollections.observableArrayList(DownloadManager.DOWNLOADS.values()));
    placeholder = new Label("No Downloads");
    downloads.getTasks().sort(Comparator.comparing(Task::isRunning));
    downloads.setSkin(new TaskSkin<>(downloads));
}

@Override
  protected Task<Void> createTask() {
      return new Task<Void>() {
          {
              updateProgress(0, saveMaxEntities);
          }

          @Override
          protected Void call() throws Exception {
              LoggerFacade.getDefault().deactivate(Boolean.TRUE);

              final StopWatch stopWatch = new StopWatch();
              stopWatch.start();

              final CrudService crudService = DatabaseFacade.getDefault().getCrudService(entityName);
              long id = -1_000_000_000L + DatabaseFacade.getDefault().getCrudService().count(entityName);
              for (int index = 0; index < saveMaxEntities; index++) {
                  final Topic topic = ModelProvider.getDefault().getTopic(id++, TestdataGenerator.getDefault().getUniqueTitles(index));
                  topic.setDescription(TestdataGenerator.getDefault().getDescription());
                  topic.setGenerationTime(TopicService.this.createGenerationTime());

                  crudService.create(topic);
                  updateProgress(index, saveMaxEntities);
              }

              LoggerFacade.getDefault().deactivate(Boolean.FALSE);
              stopWatch.split();
              LoggerFacade.getDefault().debug(this.getClass(), "  + " + stopWatch.toSplitString() + " for " + saveMaxEntities + " Topics."); // NOI18N
stopWatch.stop();

              return null;
          }
      };
  }

@FXML
private void importFS() {

    clearProgram();

    final File selectedDirectory = Dialogue.directoryChooser().showDialog(stage);

    if (selectedDirectory == null) {
        return;
    }

    try {
        cache = IndexedFileSystem.init(selectedDirectory.toPath());
        cache.load();
    } catch (Exception ex) {
        ex.printStackTrace();
        Dialogue.showWarning(String.format("Could not find cache at path=%s", selectedDirectory.toPath().toString())).showAndWait();
        return;
    }

    createTask(new Task<Boolean>() {

        @Override
        protected Boolean call() throws Exception {
            Platform.runLater(() -> populateIndex());

            double progress = 100.00;

            updateMessage(String.format("%.2f%s", progress, "%"));
            updateProgress(1, 1);

            return true;
        }

    }, true);

}

/**
 * Helps the player to play his turn by playing the best turn possible for him
 */
@FXML
protected void handleAskHelp() {
    this.controlButtons.setDisable(true);
    this.playerLettersContainer.setDisable(true);

    HumanPlayerInterface currentPlayer = (HumanPlayerInterface) this.scrabble.getCurrentPlayer();

    Task<SortedMap<BoardPosition, LetterInterface>> bestTurnTaskFinder = ArtificialIntelligenceHelper.getBestTurnPossible(this.scrabble.getLanguage(), this.scrabble.getBoard(), currentPlayer);

    bestTurnTaskFinder.setOnSucceeded(event -> {
        if (null != bestTurnTaskFinder.getValue()) {
            try {
                this.scrabble.playLetters(bestTurnTaskFinder.getValue());
                currentPlayer.decreaseAvailableHelps();

                return;
            } catch (InvalidPlayedTurnException ignored) {
            }
        }

        this.askHelpButton.setDisable(true);
        this.controlButtons.setDisable(false);
        this.playerLettersContainer.setDisable(false);

        this.showAlertOfNoBestTurnPossible();
    });

    new Thread(bestTurnTaskFinder).start();
}

private void createTask(Task<?> task, boolean showDialogue) {
    new Thread(task).start();

    if (showDialogue) {
        task.setOnSucceeded(e -> Dialogue.showInfo("Info", "Success!"));
        task.setOnFailed(e -> Dialogue.showWarning("Failed!").showAndWait());
    }

}

public void createBooklets(){
    List<File> items = list_files.getItems();

    Alert alert = new Alert(AlertType.INFORMATION);
    alert.initStyle(StageStyle.UNDECORATED);
    alert.setHeaderText("Please wait...");
    alert.setContentText("Creating booklets..." );
    alert.getButtonTypes().clear();

    BookletSettings settings = new BookletSettings()
            .quality((int) slide_quality.getValue())
            .rotateEvens(check_rotate.isSelected())
            .size(combo_sizes.getValue())
            .dirSetting(getDirSetting())
            .path(getTargetDirectory());

    Task<Void> task = new Task<Void>() {
        @Override public Void call() {
            for(File f : items) PrintDF.createBooklet(f, settings);
            return null;
        }
    };

    task.setOnRunning((e) -> alert.show());
    task.setOnSucceeded((e) -> {
        alert.getButtonTypes().add(ButtonType.CANCEL);
        alert.hide();
        alert.getButtonTypes().remove(ButtonType.CANCEL);   
    });
    task.setOnFailed((e) -> {});
    new Thread(task).start();
}

private Task<Void> createSynthesizedTask() {
    return new Task<Void>() {
        @Override
        protected Void call() throws Exception {
            if (occuredException != null) {
                throw occuredException;
            }
            return null;
        }
    };
}

@Override
  protected Task<Void> createTask() {
      return new Task<Void>() {
          {
              updateProgress(0, saveMaxEntities);
          }

          @Override
          protected Void call() throws Exception {
              LoggerFacade.getDefault().deactivate(Boolean.TRUE);

              final StopWatch stopWatch = new StopWatch();
              stopWatch.start();

              final CrudService crudService = DatabaseFacade.getDefault().getCrudService(entityName);
              long id = -1_000_000_000L + DatabaseFacade.getDefault().getCrudService().count(entityName);
              for (int index = 0; index < saveMaxEntities; index++) {
                  final Link link = ModelProvider.getDefault().getLink();
                  link.setAlias("Google " + id); // NOI18N
                  link.setDescription(TestdataGenerator.getDefault().getDescription());
                  link.setFavorite(TestdataGenerator.RANDOM.nextDouble() < 0.01d);
                  link.setGenerationTime(LinkService.this.createGenerationTime());
                  link.setId(id++);
                  link.setImage("image-name");  // NOI18N // TODO add real image name
                  link.setMarkAsChanged(false);
                  link.setUrl("https:////www.google.com"); // NOI18N

                  crudService.create(link);
                  updateProgress(index, saveMaxEntities);
              }

              LoggerFacade.getDefault().deactivate(Boolean.FALSE);
              stopWatch.split();
              LoggerFacade.getDefault().debug(this.getClass(), "  + " + stopWatch.toSplitString() + " for " + saveMaxEntities + " Links."); // NOI18N
stopWatch.stop();

              return null;
          }
      };
  }