Calculate route using Executer instead of Thread

OsmAnd/src/net/osmand/plus/routing/RouteRecalculationHelper.java

@@ -10,11 +10,19 @@ import net.osmand.plus.settings.backend.ApplicationMode;
 import net.osmand.plus.settings.backend.OsmandSettings;
 import net.osmand.router.RouteCalculationProgress;
 
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 import static net.osmand.plus.notifications.OsmandNotification.NotificationType.NAVIGATION;
 
-class RouteRecalculationThreadHelper {
+class RouteRecalculationHelper {
 
 	private static final int RECALCULATE_THRESHOLD_COUNT_CAUSING_FULL_RECALCULATE = 3;
 	private static final int RECALCULATE_THRESHOLD_CAUSING_FULL_RECALCULATE_INTERVAL = 2 * 60 * 1000;
@@ -22,17 +30,19 @@ class RouteRecalculationThreadHelper {
 	private final OsmandApplication app;
 	private final RoutingHelper routingHelper;
 
-	private Thread currentRunningJob;
+	private final ExecutorService executor = new RouteRecalculationExecutor();
+	private final Map<Future<?>, RouteRecalculationTask> tasksMap = new LinkedHashMap<>();
+	private RouteRecalculationTask lastTask;
+
 	private long lastTimeEvaluatedRoute = 0;
 	private String lastRouteCalcError;
 	private String lastRouteCalcErrorShort;
 	private long recalculateCountInInterval = 0;
 	private int evalWaitInterval = 0;
-	private boolean waitingNextJob;
 
 	private RouteCalculationProgressCallback progressRoute;
 
-	RouteRecalculationThreadHelper(@NonNull RoutingHelper routingHelper) {
+	RouteRecalculationHelper(@NonNull RoutingHelper routingHelper) {
 		this.routingHelper = routingHelper;
 		this.app = routingHelper.getApplication();
 	}
@@ -50,7 +60,14 @@ class RouteRecalculationThreadHelper {
 	}
 
 	boolean isRouteBeingCalculated() {
-		return currentRunningJob instanceof RouteRecalculationThread || waitingNextJob;
+		synchronized (routingHelper) {
+			for (Future<?> future : tasksMap.keySet()) {
+				if (!future.isDone()) {
+					return true;
+				}
+			}
+		}
+		return false;
 	}
 
 	void resetEvalWaitInterval() {
@@ -58,24 +75,31 @@ class RouteRecalculationThreadHelper {
 	}
 
 	void stopCalculation() {
-		Thread job = currentRunningJob;
+		synchronized (routingHelper) {
-		if (job instanceof RouteRecalculationThread) {
+			for (Entry<Future<?>, RouteRecalculationTask> taskFuture : tasksMap.entrySet()) {
-			((RouteRecalculationThread) job).stopCalculation();
+				taskFuture.getValue().stopCalculation();
+				taskFuture.getKey().cancel(false);
+			}
 		}
 	}
 
-	void stopCalculationIfParamsChanged() {
+	void stopCalculationIfParamsNotChanged() {
-		Thread job = currentRunningJob;
+		synchronized (routingHelper) {
-		if (job instanceof RouteRecalculationThread) {
+			boolean hasPendingTasks = tasksMap.isEmpty();
-			RouteRecalculationThread thread = (RouteRecalculationThread) job;
+			for (Entry<Future<?>, RouteRecalculationTask> taskFuture : tasksMap.entrySet()) {
-			if (!thread.isParamsChanged()) {
+				RouteRecalculationTask task = taskFuture.getValue();
-				thread.stopCalculation();
+				if (!task.isParamsChanged()) {
+					taskFuture.getKey().cancel(false);
+					task.stopCalculation();
 				}
+			}
+			if (hasPendingTasks) {
 				if (isFollowingMode()) {
 					getVoiceRouter().announceBackOnRoute();
 				}
 			}
 		}
+	}
 
 	private OsmandSettings getSettings() {
 		return routingHelper.getSettings();
@@ -130,8 +154,6 @@ class RouteRecalculationThreadHelper {
 
 				}
 			}
-
-
 			// trigger voice prompt only if new route is in forward direction
 			// If route is in wrong direction after one more setLocation it will be recalculated
 			if (!wrongMovementDirection || newRoute) {
@@ -144,18 +166,15 @@ class RouteRecalculationThreadHelper {
 
 	void startRouteCalculationThread(RouteCalculationParams params, boolean paramsChanged, boolean updateProgress) {
 		synchronized (routingHelper) {
-			final Thread prevRunningJob = currentRunningJob;
 			getSettings().LAST_ROUTE_APPLICATION_MODE.set(getAppMode());
-			RouteRecalculationThread newThread = new RouteRecalculationThread("Calculating route", params, paramsChanged);
+			RouteRecalculationTask newTask = new RouteRecalculationTask(this, params, paramsChanged);
-			currentRunningJob = newThread;
+			lastTask = newTask;
 			startProgress(params);
 			if (updateProgress) {
 				updateProgress(params);
 			}
-			if (prevRunningJob != null) {
+			Future<?> future = executor.submit(newTask);
-				newThread.setWaitPrevJob(prevRunningJob);
+			tasksMap.put(future, newTask);
-			}
-			currentRunningJob.start();
 		}
 	}
 
@@ -165,7 +184,7 @@ class RouteRecalculationThreadHelper {
 			return;
 		}
 		// do not evaluate very often
-		if ((currentRunningJob == null && System.currentTimeMillis() - lastTimeEvaluatedRoute > evalWaitInterval)
+		if ((!isRouteBeingCalculated() && System.currentTimeMillis() - lastTimeEvaluatedRoute > evalWaitInterval)
 				|| paramsChanged || !onlyStartPointChanged) {
 			if (System.currentTimeMillis() - lastTimeEvaluatedRoute < RECALCULATE_THRESHOLD_CAUSING_FULL_RECALCULATE_INTERVAL) {
 				recalculateCountInInterval++;
@@ -234,11 +253,7 @@ class RouteRecalculationThreadHelper {
 				public void run() {
 					RouteCalculationProgress calculationProgress = params.calculationProgress;
 					if (isRouteBeingCalculated()) {
-						Thread t = currentRunningJob;
+						if (lastTask != null && lastTask.params == params) {
-						if (t instanceof RouteRecalculationThread && ((RouteRecalculationThread) t).params != params) {
-							// different calculation started
-							return;
-						} else {
 							progressRoute.updateProgress((int) calculationProgress.getLinearProgress());
 							if (calculationProgress.requestPrivateAccessRouting) {
 								progressRoute.requestPrivateAccessRouting();
@@ -268,23 +283,21 @@ class RouteRecalculationThreadHelper {
 		}
 	}
 
-	private void showMessage(final String msg) {
+	private static class RouteRecalculationTask implements Runnable {
-		app.runInUIThread(new Runnable() {
-			@Override
-			public void run() {
-				app.showToastMessage(msg);
-			}
-		});
-	}
-
-	class RouteRecalculationThread extends Thread {
 
+		private final RouteRecalculationHelper routingThreadHelper;
+		private final RoutingHelper routingHelper;
 		private final RouteCalculationParams params;
 		private final boolean paramsChanged;
-		private Thread prevRunningJob;
 
-		public RouteRecalculationThread(String name, RouteCalculationParams params, boolean paramsChanged) {
+		String routeCalcError;
-			super(name);
+		String routeCalcErrorShort;
+		int evalWaitInterval = 0;
+
+		public RouteRecalculationTask(@NonNull RouteRecalculationHelper routingThreadHelper,
+									  @NonNull RouteCalculationParams params, boolean paramsChanged) {
+			this.routingThreadHelper = routingThreadHelper;
+			this.routingHelper = routingThreadHelper.routingHelper;
 			this.params = params;
 			this.paramsChanged = paramsChanged;
 			if (params.calculationProgress == null) {
@@ -300,39 +313,26 @@ class RouteRecalculationThreadHelper {
 			params.calculationProgress.isCancelled = true;
 		}
 
+		private OsmandSettings getSettings() {
+			return routingHelper.getSettings();
+		}
+
+		private void showMessage(final String msg) {
+			final OsmandApplication app = routingHelper.getApplication();
+			app.runInUIThread(new Runnable() {
+				@Override
+				public void run() {
+					app.showToastMessage(msg);
+				}
+			});
+		}
 
 		@Override
 		public void run() {
-			synchronized (routingHelper) {
-				routingHelper.resetRouteWasFinished();
-				currentRunningJob = this;
-				waitingNextJob = prevRunningJob != null;
-			}
-			if (prevRunningJob != null) {
-				while (prevRunningJob.isAlive()) {
-					try {
-						Thread.sleep(50);
-					} catch (InterruptedException e) {
-						// ignore
-					}
-				}
-				synchronized (routingHelper) {
-					if (params.calculationProgress.isCancelled) {
-						return;
-					}
-					currentRunningJob = this;
-					waitingNextJob = false;
-				}
-			}
-			lastRouteCalcError = null;
-			lastRouteCalcErrorShort = null;
 			RouteProvider provider = routingHelper.getProvider();
 			OsmandSettings settings = getSettings();
 			RouteCalculationResult res = provider.calculateRouteImpl(params);
 			if (params.calculationProgress.isCancelled) {
-				synchronized (routingHelper) {
-					currentRunningJob = null;
-				}
 				return;
 			}
 			final boolean onlineSourceWithoutInternet = !res.isCalculated() &&
@@ -353,37 +353,54 @@ class RouteRecalculationThreadHelper {
 						params.resultListener.onRouteCalculated(res);
 					}
 				} else {
-					evalWaitInterval = Math.max(3000, evalWaitInterval * 3 / 2); // for Issue #3899
+					evalWaitInterval = Math.max(3000, routingThreadHelper.evalWaitInterval * 3 / 2); // for Issue #3899
 					evalWaitInterval = Math.min(evalWaitInterval, 120000);
 				}
-				currentRunningJob = null;
 			}
+			OsmandApplication app = routingHelper.getApplication();
 			if (res.isCalculated()) {
 				if (!params.inSnapToRoadMode && !params.inPublicTransportMode) {
-					setNewRoute(prev, res, params.start);
+					routingThreadHelper.setNewRoute(prev, res, params.start);
 				}
 			} else if (onlineSourceWithoutInternet) {
-				lastRouteCalcError = app.getString(R.string.error_calculating_route)
+				routeCalcError = app.getString(R.string.error_calculating_route)
 						+ ":\n" + app.getString(R.string.internet_connection_required_for_online_route);
-				lastRouteCalcErrorShort = app.getString(R.string.error_calculating_route);
+				routeCalcErrorShort = app.getString(R.string.error_calculating_route);
-				showMessage(lastRouteCalcError); //$NON-NLS-1$
+				showMessage(routeCalcError);
 			} else {
 				if (res.getErrorMessage() != null) {
-					lastRouteCalcError = app.getString(R.string.error_calculating_route) + ":\n" + res.getErrorMessage();
+					routeCalcError = app.getString(R.string.error_calculating_route) + ":\n" + res.getErrorMessage();
-					lastRouteCalcErrorShort = app.getString(R.string.error_calculating_route);
+					routeCalcErrorShort = app.getString(R.string.error_calculating_route);
-					showMessage(lastRouteCalcError); //$NON-NLS-1$
 				} else {
-					lastRouteCalcError = app.getString(R.string.empty_route_calculated);
+					routeCalcError = app.getString(R.string.empty_route_calculated);
-					lastRouteCalcErrorShort = app.getString(R.string.empty_route_calculated);
+					routeCalcErrorShort = app.getString(R.string.empty_route_calculated);
-					showMessage(lastRouteCalcError);
 				}
+				showMessage(routeCalcError);
 			}
 			app.getNotificationHelper().refreshNotification(NAVIGATION);
-			lastTimeEvaluatedRoute = System.currentTimeMillis();
+		}
 	}
 
-		public void setWaitPrevJob(Thread prevRunningJob) {
+	private class RouteRecalculationExecutor extends ThreadPoolExecutor {
-			this.prevRunningJob = prevRunningJob;
+
+		public RouteRecalculationExecutor() {
+			super(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
+		}
+
+		protected void afterExecute(Runnable r, Throwable t) {
+			super.afterExecute(r, t);
+			RouteRecalculationTask task = null;
+			synchronized (routingHelper) {
+				if (r instanceof Future<?>) {
+					task = tasksMap.remove(r);
+				}
+			}
+			if (t == null && task != null) {
+				evalWaitInterval = task.evalWaitInterval;
+				lastRouteCalcError = task.routeCalcError;
+				lastRouteCalcErrorShort = task.routeCalcErrorShort;
+			}
+			lastTimeEvaluatedRoute = System.currentTimeMillis();
 		}
 	}
 }

OsmAnd/src/net/osmand/plus/routing/RoutingHelper.java

@@ -54,7 +54,7 @@ public class RoutingHelper {
 	private OsmandSettings settings;
 	private final RouteProvider provider;
 	private final VoiceRouter voiceRouter;
-	private final RouteRecalculationThreadHelper routeRecalculationHelper;
+	private final RouteRecalculationHelper routeRecalculationHelper;
 	private final TransportRoutingHelper transportRoutingHelper;
 
 	private boolean isFollowingMode = false;
@@ -94,7 +94,7 @@ public class RoutingHelper {
 		settings = context.getSettings();
 		voiceRouter = new VoiceRouter(this);
 		provider = new RouteProvider();
-		routeRecalculationHelper = new RouteRecalculationThreadHelper(this);
+		routeRecalculationHelper = new RouteRecalculationHelper(this);
 		transportRoutingHelper = context.getTransportRoutingHelper();
 		transportRoutingHelper.setRoutingHelper(this);
 		setAppMode(settings.APPLICATION_MODE.get());
@@ -505,7 +505,7 @@ public class RoutingHelper {
 			routeRecalculationHelper.recalculateRouteInBackground(currentLocation, finalLocation, intermediatePoints, currentGPXRoute,
 					previousRoute.isCalculated() ? previousRoute : null, false, !targetPointsChanged);
 		} else {
-			routeRecalculationHelper.stopCalculationIfParamsChanged();
+			routeRecalculationHelper.stopCalculationIfParamsNotChanged();
 		}
 
 		double projectDist = mode != null && mode.hasFastSpeed() ? posTolerance : posTolerance / 2;

OsmAnd/src/net/osmand/plus/routing/TransportRoutingHelper.java

@@ -13,37 +13,42 @@ import net.osmand.binary.BinaryMapIndexReader;
 import net.osmand.data.LatLon;
 import net.osmand.data.QuadRect;
 import net.osmand.osm.edit.Node;
-import net.osmand.plus.settings.backend.ApplicationMode;
 import net.osmand.plus.OsmandApplication;
 import net.osmand.plus.OsmandPlugin;
-import net.osmand.plus.settings.backend.CommonPreference;
-import net.osmand.plus.settings.backend.OsmandSettings;
 import net.osmand.plus.R;
 import net.osmand.plus.render.NativeOsmandLibrary;
 import net.osmand.plus.routing.RouteCalculationParams.RouteCalculationResultListener;
 import net.osmand.plus.routing.RouteProvider.RouteService;
+import net.osmand.plus.settings.backend.ApplicationMode;
+import net.osmand.plus.settings.backend.CommonPreference;
+import net.osmand.plus.settings.backend.OsmandSettings;
 import net.osmand.router.GeneralRouter;
-
+import net.osmand.router.NativeTransportRoutingResult;
 import net.osmand.router.RouteCalculationProgress;
 import net.osmand.router.RoutingConfiguration;
 import net.osmand.router.TransportRoutePlanner;
-import net.osmand.router.TransportRouteResult;
 import net.osmand.router.TransportRoutePlanner.TransportRouteResultSegment;
-import net.osmand.router.TransportRoutingContext;
+import net.osmand.router.TransportRouteResult;
 import net.osmand.router.TransportRoutingConfiguration;
-import net.osmand.router.NativeTransportRoutingResult;
+import net.osmand.router.TransportRoutingContext;
 import net.osmand.util.MapUtils;
 
 import java.io.IOException;
 import java.lang.ref.WeakReference;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 import static net.osmand.plus.notifications.OsmandNotification.NotificationType.NAVIGATION;
 
@@ -53,10 +58,14 @@ public class TransportRoutingHelper {
 
 	private List<WeakReference<IRouteInformationListener>> listeners = new LinkedList<>();
 
-	private OsmandApplication app;
+	private final OsmandApplication app;
 	private ApplicationMode applicationMode = ApplicationMode.PUBLIC_TRANSPORT;
 	private RoutingHelper routingHelper;
 
+	private final ExecutorService executor = new RouteRecalculationExecutor();
+	private final Map<Future<?>, RouteRecalculationTask> tasksMap = new LinkedHashMap<>();
+	private RouteRecalculationTask lastTask;
+
 	private List<TransportRouteResult> routes;
 	private Map<Pair<TransportRouteResultSegment, TransportRouteResultSegment>, RouteCalculationResult> walkingRouteSegments;
 	private int currentRoute = -1;
@@ -64,11 +73,9 @@ public class TransportRoutingHelper {
 	private LatLon startLocation;
 	private LatLon endLocation;
 
-	private Thread currentRunningJob;
 	private String lastRouteCalcError;
 	private String lastRouteCalcErrorShort;
 	private long lastTimeEvaluatedRoute = 0;
-	private boolean waitingNextJob;
 
 	private TransportRouteCalculationProgressCallback progressRoute;
 
@@ -212,18 +219,14 @@ public class TransportRoutingHelper {
 
 	private void startRouteCalculationThread(TransportRouteCalculationParams params) {
 		synchronized (this) {
-			final Thread prevRunningJob = currentRunningJob;
 			app.getSettings().LAST_ROUTE_APPLICATION_MODE.set(routingHelper.getAppMode());
-			RouteRecalculationThread newThread =
+			RouteRecalculationTask newTask = new RouteRecalculationTask(this, params,
-					new RouteRecalculationThread("Calculating public transport route", params,
 					app.getSettings().SAFE_MODE.get() ? null : NativeOsmandLibrary.getLoadedLibrary());
-			currentRunningJob = newThread;
+			lastTask = newTask;
 			startProgress(params);
 			updateProgress(params);
-			if (prevRunningJob != null) {
+			Future<?> future = executor.submit(newTask);
-				newThread.setWaitPrevJob(prevRunningJob);
+			tasksMap.put(future, newTask);
-			}
-			currentRunningJob.start();
 		}
 	}
 
@@ -250,10 +253,7 @@ public class TransportRoutingHelper {
 					if (isRouteBeingCalculated()) {
 						float pr = calculationProgress.getLinearProgress();
 						progressRoute.updateProgress((int) pr);
-						Thread t = currentRunningJob;
+						if (lastTask != null && lastTask.params == params) {
-						if (t instanceof RouteRecalculationThread && ((RouteRecalculationThread) t).params != params) {
-							// different calculation started
-						} else {
 							updateProgress(params);
 						}
 					} else {
@@ -268,7 +268,23 @@ public class TransportRoutingHelper {
 	}
 
 	public boolean isRouteBeingCalculated() {
-		return currentRunningJob instanceof RouteRecalculationThread || waitingNextJob;
+		synchronized (this) {
+			for (Future<?> future : tasksMap.keySet()) {
+				if (!future.isDone()) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private void stopCalculation() {
+		synchronized (this) {
+			for (Map.Entry<Future<?>, RouteRecalculationTask> taskFuture : tasksMap.entrySet()) {
+				taskFuture.getValue().stopCalculation();
+				taskFuture.getKey().cancel(false);
+			}
+		}
 	}
 
 	private void setNewRoute(final List<TransportRouteResult> res) {
@@ -322,9 +338,7 @@ public class TransportRoutingHelper {
 			}
 		});
 		this.endLocation = newFinalLocation;
-		if (currentRunningJob instanceof RouteRecalculationThread) {
+		stopCalculation();
-			((RouteRecalculationThread) currentRunningJob).stopCalculation();
-		}
 	}
 
 	private void setCurrentLocation(LatLon currentLocation) {
@@ -335,15 +349,6 @@ public class TransportRoutingHelper {
 		recalculateRouteInBackground(currentLocation, endLocation);
 	}
 
-	private void showMessage(final String msg) {
-		app.runInUIThread(new Runnable() {
-			@Override
-			public void run() {
-				app.showToastMessage(msg);
-			}
-		});
-	}
-
 	@Nullable
 	public QuadRect getTransportRouteRect(@NonNull TransportRouteResult result) {
 		TransportRoutingHelper transportRoutingHelper = app.getTransportRoutingHelper();
@@ -403,7 +408,7 @@ public class TransportRoutingHelper {
 		}
 	}
 
-	private class WalkingRouteSegment {
+	private static class WalkingRouteSegment {
 		TransportRouteResultSegment s1;
 		TransportRouteResultSegment s2;
 		LatLon start;
@@ -436,18 +441,24 @@ public class TransportRoutingHelper {
 		}
 	}
 
-	private class RouteRecalculationThread extends Thread {
+	private static class RouteRecalculationTask implements Runnable {
 
+		private final TransportRoutingHelper transportRoutingHelper;
+		private final RoutingHelper routingHelper;
 		private final TransportRouteCalculationParams params;
-		private Thread prevRunningJob;
 
 		private final Queue<WalkingRouteSegment> walkingSegmentsToCalculate = new ConcurrentLinkedQueue<>();
 		private Map<Pair<TransportRouteResultSegment, TransportRouteResultSegment>, RouteCalculationResult> walkingRouteSegments = new HashMap<>();
 		private boolean walkingSegmentsCalculated;
-		private NativeLibrary lib;
+		private final NativeLibrary lib;
 
-		public RouteRecalculationThread(String name, TransportRouteCalculationParams params, NativeLibrary library) {
+		String routeCalcError;
-			super(name);
+		String routeCalcErrorShort;
+
+		public RouteRecalculationTask(@NonNull TransportRoutingHelper transportRoutingHelper,
+									  @NonNull TransportRouteCalculationParams params, @Nullable NativeLibrary library) {
+			this.transportRoutingHelper = transportRoutingHelper;
+			this.routingHelper = transportRoutingHelper.routingHelper;
 			this.params = params;
 			this.lib = library;
 			if (params.calculationProgress == null) {
@@ -459,9 +470,9 @@ public class TransportRoutingHelper {
 			params.calculationProgress.isCancelled = true;
 		}
 
-
 		/**
 		 * TODO Check if native lib available and calculate route there.
+		 *
 		 * @param params
 		 * @return
 		 * @throws IOException
@@ -509,7 +520,6 @@ public class TransportRoutingHelper {
 
 		@Nullable
 		private RouteCalculationParams getWalkingRouteParams() {
-
 			ApplicationMode walkingMode = ApplicationMode.PEDESTRIAN;
 
 			final WalkingRouteSegment walkingRouteSegment = walkingSegmentsToCalculate.poll();
@@ -517,13 +527,14 @@ public class TransportRoutingHelper {
 				return null;
 			}
 
+			OsmandApplication app = routingHelper.getApplication();
 			Location start = new Location("");
 			start.setLatitude(walkingRouteSegment.start.getLatitude());
 			start.setLongitude(walkingRouteSegment.start.getLongitude());
 			LatLon end = new LatLon(walkingRouteSegment.end.getLatitude(), walkingRouteSegment.end.getLongitude());
 
 			final float currentDistanceFromBegin =
-					RouteRecalculationThread.this.params.calculationProgress.distanceFromBegin +
+					RouteRecalculationTask.this.params.calculationProgress.distanceFromBegin +
 							(walkingRouteSegment.s1 != null ? (float) walkingRouteSegment.s1.getTravelDist() : 0);
 
 			final RouteCalculationParams params = new RouteCalculationParams();
@@ -547,8 +558,8 @@ public class TransportRoutingHelper {
 					float p = Math.max(params.calculationProgress.distanceFromBegin,
 							params.calculationProgress.distanceFromEnd);
 
-					RouteRecalculationThread.this.params.calculationProgress.distanceFromBegin =
+					RouteRecalculationTask.this.params.calculationProgress.distanceFromBegin =
-							Math.max(RouteRecalculationThread.this.params.calculationProgress.distanceFromBegin, currentDistanceFromBegin + p);
+							Math.max(RouteRecalculationTask.this.params.calculationProgress.distanceFromBegin, currentDistanceFromBegin + p);
 				}
 
 				@Override
@@ -571,7 +582,7 @@ public class TransportRoutingHelper {
 			params.resultListener = new RouteCalculationResultListener() {
 				@Override
 				public void onRouteCalculated(RouteCalculationResult route) {
-					RouteRecalculationThread.this.walkingRouteSegments.put(new Pair<>(walkingRouteSegment.s1, walkingRouteSegment.s2), route);
+					RouteRecalculationTask.this.walkingRouteSegments.put(new Pair<>(walkingRouteSegment.s1, walkingRouteSegment.s2), route);
 				}
 			};
 
@@ -619,26 +630,18 @@ public class TransportRoutingHelper {
 			}
 		}
 
+		private void showMessage(final String msg) {
+			final OsmandApplication app = routingHelper.getApplication();
+			app.runInUIThread(new Runnable() {
 				@Override
 				public void run() {
-			synchronized (TransportRoutingHelper.this) {
+					app.showToastMessage(msg);
-				currentRunningJob = this;
-				waitingNextJob = prevRunningJob != null;
-			}
-			if (prevRunningJob != null) {
-				while (prevRunningJob.isAlive()) {
-					try {
-						Thread.sleep(50);
-					} catch (InterruptedException e) {
-						// ignore
-					}
-				}
-				synchronized (TransportRoutingHelper.this) {
-					currentRunningJob = this;
-					waitingNextJob = false;
 				}
+			});
 		}
 
+		@Override
+		public void run() {
 			List<TransportRouteResult> res = null;
 			String error = null;
 			try {
@@ -651,38 +654,52 @@ public class TransportRoutingHelper {
 				log.error(e);
 			}
 			if (params.calculationProgress.isCancelled) {
-				synchronized (TransportRoutingHelper.this) {
-					currentRunningJob = null;
-				}
 				return;
 			}
-			synchronized (TransportRoutingHelper.this) {
+			synchronized (transportRoutingHelper) {
-				routes = res;
+				transportRoutingHelper.routes = res;
-				TransportRoutingHelper.this.walkingRouteSegments = walkingRouteSegments;
+				transportRoutingHelper.walkingRouteSegments = walkingRouteSegments;
 				if (res != null) {
 					if (params.resultListener != null) {
 						params.resultListener.onRouteCalculated(res);
 					}
 				}
-				currentRunningJob = null;
 			}
+			OsmandApplication app = routingHelper.getApplication();
 			if (res != null) {
-				setNewRoute(res);
+				transportRoutingHelper.setNewRoute(res);
 			} else if (error != null) {
-				lastRouteCalcError = app.getString(R.string.error_calculating_route) + ":\n" + error;
+				routeCalcError = app.getString(R.string.error_calculating_route) + ":\n" + error;
-				lastRouteCalcErrorShort = app.getString(R.string.error_calculating_route);
+				routeCalcErrorShort = app.getString(R.string.error_calculating_route);
-				showMessage(lastRouteCalcError);
+				showMessage(routeCalcError);
 			} else {
-				lastRouteCalcError = app.getString(R.string.empty_route_calculated);
+				routeCalcError = app.getString(R.string.empty_route_calculated);
-				lastRouteCalcErrorShort = app.getString(R.string.empty_route_calculated);
+				routeCalcErrorShort = app.getString(R.string.empty_route_calculated);
-				showMessage(lastRouteCalcError);
+				showMessage(routeCalcError);
 			}
 			app.getNotificationHelper().refreshNotification(NAVIGATION);
-			lastTimeEvaluatedRoute = System.currentTimeMillis();
+		}
 	}
 
-		public void setWaitPrevJob(Thread prevRunningJob) {
+	private class RouteRecalculationExecutor extends ThreadPoolExecutor {
-			this.prevRunningJob = prevRunningJob;
+
+		public RouteRecalculationExecutor() {
+			super(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
+		}
+
+		protected void afterExecute(Runnable r, Throwable t) {
+			super.afterExecute(r, t);
+			RouteRecalculationTask task = null;
+			synchronized (TransportRoutingHelper.this) {
+				if (r instanceof Future<?>) {
+					task = tasksMap.remove(r);
+				}
+			}
+			if (t == null && task != null) {
+				lastRouteCalcError = task.routeCalcError;
+				lastRouteCalcErrorShort = task.routeCalcErrorShort;
+			}
+			lastTimeEvaluatedRoute = System.currentTimeMillis();
 		}
 	}
 }