JavaFX wait for Webview fully load or cancel everything after 15 seconds

There's at least a couple problems in your code that may be contributing to your overall problem.

1. You don't stop the PauseTransition when the load succeeds (or fails).

   It looks like there's an attempt to implement this, but you do it in the onFinished handler of the animation. That handler is invoked when the animation has finished and is thus already stopped/stopping. To call stop() inside that handler is basically a no-op.

   It would probably be easier to reuse a single PauseTransition instance and simply start and stop it based on the running state of the load worker (e.g. by observing the worker's running property). You can also probably use the running status of the worker instead of your own waitForData flag.

2. You add a new listener to the worker's state property every time you load a new web page, but you don't remove the old listeners.

   This means the work inside the listener is repeated, where the number of times it's repeated increases over time. You should only add the listener once when you are first initializing everything.

In some ways I believe you're thinking too linearly. Typically GUI programming is event-driven which is inherently asynchronous.

Here's a skeleton example of what I was hinting at above and in the question comments. You'll obviously need to rewrite things in order to integrate it into your application, but it should help you understand what's happening and hopefully find a solution.

import javafx.animation.PauseTransition;
import javafx.beans.value.ObservableValue;
import javafx.concurrent.Worker;
import javafx.concurrent.Worker.State;
import javafx.scene.web.WebView;
import javafx.util.Duration;

public class Foo {

  private final String baseUrl;
  private final PauseTransition timeout;
  private final WebView webView;

  public Foo(String baseUrl) {
    this.baseUrl = baseUrl;
    timeout = new PauseTransition(Duration.seconds(15));
    webView = new WebView();

    Worker<?> worker = webView.getEngine().getLoadWorker();
    // observe 'running' property to start/stop timeout
    worker.runningProperty().addListener(this::loaderRunningChanged);
    // observe 'state' property to handle success/failure
    worker.stateProperty().addListener(this::loaderStateChanged);

    timeout.setOnFinished(
        e -> {
          worker.cancel(); // stop trying to load
          handleTimeout();
        });
  }

  public void loadData(String uid) {
    if (!webView.getEngine().getLoadWorker().isRunning()) {
      webView.getEngine().load(baseUrl + uid);
    }
  }

  private void loaderRunningChanged(
      ObservableValue<? extends Boolean> obs, boolean wasRunning, boolean isRunning) {
    if (isRunning) {
      System.out.println("Loading...");
      timeout.playFromStart(); // restart timeout countdown
    } else {
      timeout.stop(); // load completed, stop timeout countdown
    }
  }

  private void loaderStateChanged(
      ObservableValue<? extends State> obs, State oldState, State newState) {
    // switch expressions standardized in Java 14 (preview feature in Java 12 and 13)
    switch (newState) {
      case SUCCEEDED -> handleSuccess();
      case FAILED -> handleFailure();
    }
  }

  private void handleSuccess() {
    System.out.println("Load succeeded.");
    // ...
  }

  private void handleFailure() {
    System.out.println("Load failed.");
    // ...
  }

  private void handleTimeout() {
    System.out.println("Load timeout.");
    // ...
  }
}

Here is an example of what I think you should do.

1. Try to load the engine.
2. Create a global Worker.State variable that will be used to keep up with the state of the stateProperty listener. Use a Timeline to check the value of the Worker.State variable every second for 15 seconds.

/*
Code found here -> http://tutorials.jenkov.com/javafx/webview.html
*/
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.application.Application;
import javafx.concurrent.Worker;
import javafx.event.ActionEvent;
import javafx.scene.Scene;
import javafx.scene.layout.VBox;
import javafx.scene.web.WebView;
import javafx.stage.Stage;
import javafx.util.Duration;

public class App extends Application {

    public static void main(String[] args) {
        launch(args);
    }

    Worker.State workerState;
    Timeline oneSecondWonder;
    
    public void start(Stage primaryStage) {
        primaryStage.setTitle("JavaFX WebView Example");

        WebView webView = new WebView();

        webView.getEngine().getLoadWorker().stateProperty().addListener((obs, oldState, newState) -> {
            workerState = newState;
        });        
        webView.getEngine().load("http://google5.com");//Use to see what happens after 15 seconds.
        //webView.getEngine().load("http://google.com");//Use to see what happens before 15 seconds.
        
        oneSecondWonder = new Timeline(
                 new KeyFrame(Duration.seconds(1), (ActionEvent event) -> {
                     System.out.println("Worker State: " + workerState);
                     switch(workerState)
                     {
                         case FAILED:
                             System.out.println("FAILED");
                             break;
                         case SUCCEEDED:
                             System.out.println("SUCCEEDED");
                             oneSecondWonder.stop();
                             System.out.println("I am stopping the Timeline and moving forward with code here!");
                             oneSecondWonder.stop();
                             //Next set of code here!
                             break;
                         case CANCELLED:
                             //Code here if needed!
                             break;
                         //Other cases if needed here!
                     }
        }));
        oneSecondWonder.setOnFinished((t) -> {
            System.out.println("The Timeline ended. I am alerting the user about his/her next options");
        });        
        oneSecondWonder.setCycleCount(15);
        oneSecondWonder.play();
        
        VBox vBox = new VBox(webView);
        Scene scene = new Scene(vBox, 960, 600);

        primaryStage.setScene(scene);
        primaryStage.show();

    }
}