From 58ed48b0978ed82aa6d14ddcc995d963304d0d0a Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Mon, 13 Mar 2023 11:17:56 +0100
Subject: [PATCH 01/10] UI: * remove restart notice for volume type * only show
 restart label, when switching between macFUSE and FUSET

---
 .../preferences/VolumePreferencesController.java  | 15 +++++++++++++++
 src/main/resources/css/dark_theme.css             |  4 ++++
 src/main/resources/css/light_theme.css            |  4 ++++
 src/main/resources/fxml/preferences_volume.fxml   |  2 ++
 src/main/resources/i18n/strings.properties        |  2 +-
 5 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
index 61a54ba22..ab3c319ba 100644
--- a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
+++ b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
@@ -33,6 +33,7 @@ public class VolumePreferencesController implements FxController {
 	private final ObservableValue<Boolean> mountToDriveLetterSupported;
 	private final ObservableValue<Boolean> mountFlagsSupported;
 	private final ObservableValue<Boolean> readonlySupported;
+	private final ObservableValue<Boolean> macFuseAndFUSETRestartRequired;
 	private final Lazy<Application> application;
 	private final List<MountService> mountProviders;
 	public ChoiceBox<MountService> volumeTypeChoiceBox;
@@ -53,6 +54,12 @@ public class VolumePreferencesController implements FxController {
 		this.mountToDriveLetterSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_AS_DRIVE_LETTER));
 		this.mountFlagsSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_FLAGS));
 		this.readonlySupported = selectedMountService.map(s -> s.hasCapability(MountCapability.READ_ONLY));
+		var mountServiceAtStart = selectedMountService.getValue();
+		this.macFuseAndFUSETRestartRequired = selectedMountService.map(s -> isFUSETOrMacFUSE(mountServiceAtStart) && isFUSETOrMacFUSE(s) && !mountServiceAtStart.equals(s));
+	}
+
+	private boolean isFUSETOrMacFUSE(MountService service) {
+		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
 	}
 
 	public void initialize() {
@@ -129,6 +136,14 @@ public class VolumePreferencesController implements FxController {
 		return mountFlagsSupported.getValue();
 	}
 
+	public ObservableValue<Boolean> macFuseAndFUSETRestartRequiredProperty() {
+		return macFuseAndFUSETRestartRequired;
+	}
+
+	public boolean isMacFuseAndFUSETRestartRequired() {
+		return macFuseAndFUSETRestartRequired.getValue();
+	}
+
 	/* Helpers */
 
 	private class MountServiceConverter extends StringConverter<MountService> {
diff --git a/src/main/resources/css/dark_theme.css b/src/main/resources/css/dark_theme.css
index 5f0877842..45cadba93 100644
--- a/src/main/resources/css/dark_theme.css
+++ b/src/main/resources/css/dark_theme.css
@@ -116,6 +116,10 @@
 	-fx-font-size: 0.64em;
 }
 
+.label-red {
+	-fx-text-fill: RED_5;
+}
+
 .text-flow > * {
 	-fx-fill: TEXT_FILL;
 }
diff --git a/src/main/resources/css/light_theme.css b/src/main/resources/css/light_theme.css
index decf64b64..c3c0faaa9 100644
--- a/src/main/resources/css/light_theme.css
+++ b/src/main/resources/css/light_theme.css
@@ -116,6 +116,10 @@
 	-fx-font-size: 0.64em;
 }
 
+.label-red {
+	-fx-text-fill: RED_5;
+}
+
 .text-flow > * {
 	-fx-fill: TEXT_FILL;
 }
diff --git a/src/main/resources/fxml/preferences_volume.fxml b/src/main/resources/fxml/preferences_volume.fxml
index 16ccc2b52..680579fbe 100644
--- a/src/main/resources/fxml/preferences_volume.fxml
+++ b/src/main/resources/fxml/preferences_volume.fxml
@@ -32,6 +32,8 @@
 			</Hyperlink>
 		</HBox>
 
+		<Label styleClass="label-red" text="To apply the changes, Cryptomator needs to be restarted." visible="${controller.macFuseAndFUSETRestartRequired}" managed="${controller.macFuseAndFUSETRestartRequired}"/>
+
 		<HBox spacing="12" alignment="CENTER_LEFT" visible="${controller.loopbackPortSupported}" managed="${controller.loopbackPortSupported}">
 			<Label text="%preferences.volume.tcp.port"/>
 			<NumericTextField fx:id="loopbackPortField"/>
diff --git a/src/main/resources/i18n/strings.properties b/src/main/resources/i18n/strings.properties
index ebaf73143..a14957cc9 100644
--- a/src/main/resources/i18n/strings.properties
+++ b/src/main/resources/i18n/strings.properties
@@ -275,7 +275,7 @@ preferences.interface.showMinimizeButton=Show minimize button
 preferences.interface.showTrayIcon=Show tray icon (requires restart)
 ## Volume
 preferences.volume=Virtual Drive
-preferences.volume.type=Volume Type (requires restart)
+preferences.volume.type=Volume Type
 preferences.volume.type.automatic=Automatic
 preferences.volume.docsTooltip=Open the documentation to learn more about the different volume types.
 preferences.volume.tcp.port=TCP Port

From fdc0d2d6b525171e89bd5108386cb8e207989c51 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Mon, 13 Mar 2023 12:44:56 +0100
Subject: [PATCH 02/10] only require restart in case if macFUSE or FUSE-T

Closes #2786
---
 .../cryptomator/common/ObservableUtil.java    | 12 +++++
 .../cryptomator/common/mount/MountModule.java | 50 +++++++++++--------
 2 files changed, 42 insertions(+), 20 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/ObservableUtil.java b/src/main/java/org/cryptomator/common/ObservableUtil.java
index 289f6e929..7927b6e54 100644
--- a/src/main/java/org/cryptomator/common/ObservableUtil.java
+++ b/src/main/java/org/cryptomator/common/ObservableUtil.java
@@ -2,7 +2,9 @@ package org.cryptomator.common;
 
 import javafx.beans.binding.Bindings;
 import javafx.beans.value.ObservableValue;
+import java.util.Objects;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 public class ObservableUtil {
 
@@ -15,4 +17,14 @@ public class ObservableUtil {
 			}
 		}, observable);
 	}
+
+	public static <T, U> ObservableValue<U> mapWithDefault(ObservableValue<T> observable, Function<? super T, ? extends U> mapper, Supplier<U> defaultValue) {
+		return Bindings.createObjectBinding(() -> {
+			if (observable.getValue() == null) {
+				return defaultValue.get();
+			} else {
+				return mapper.apply(observable.getValue());
+			}
+		}, observable);
+	}
 }
diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index d78cc3216..2511a9d2e 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -2,50 +2,60 @@ package org.cryptomator.common.mount;
 
 import dagger.Module;
 import dagger.Provides;
+import org.cryptomator.common.ObservableUtil;
 import org.cryptomator.common.settings.Settings;
 import org.cryptomator.integrations.mount.MountService;
 
 import javax.inject.Singleton;
-import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.value.ObservableValue;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
 @Module
 public class MountModule {
 
+	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
+
 	@Provides
 	@Singleton
 	static List<MountService> provideSupportedMountServices() {
 		return MountService.get().toList();
 	}
 
-	//currently not used, because macFUSE and FUSE-T cannot be used in the same JVM
-	/*
 	@Provides
 	@Singleton
 	static ObservableValue<ActualMountService> provideMountService(Settings settings, List<MountService> serviceImpls) {
 		var fallbackProvider = serviceImpls.stream().findFirst().orElse(null);
-		return ObservableUtil.mapWithDefault(settings.mountService(), //
+
+		var observableMountService = ObservableUtil.mapWithDefault(settings.mountService(), //
 				desiredServiceImpl -> { //
-					var desiredService = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(desiredServiceImpl)).findAny(); //
-					return new ActualMountService(desiredService.orElse(fallbackProvider), desiredService.isPresent()); //
+					var serviceFromSettings = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(desiredServiceImpl)).findAny(); //
+					var targetedService = serviceFromSettings.orElse(fallbackProvider);
+					return applyWorkaroundForFuseTMacFuse(targetedService, serviceFromSettings.isPresent());
 				}, //
-				new ActualMountService(fallbackProvider, true));
-	}
-	 */
-
-	@Provides
-	@Singleton
-	static ActualMountService provideActualMountService(Settings settings, List<MountService> serviceImpls) {
-		var fallbackProvider = serviceImpls.stream().findFirst().orElse(null);
-		var desiredService = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(settings.mountService().getValue())).findFirst(); //
-		return new ActualMountService(desiredService.orElse(fallbackProvider), desiredService.isPresent()); //
+				() -> { //
+					return applyWorkaroundForFuseTMacFuse(fallbackProvider, true);
+				});
+		return observableMountService;
 	}
 
-	@Provides
-	@Singleton
-	static ObservableValue<ActualMountService> provideMountService(ActualMountService service) {
-		return new SimpleObjectProperty<>(service);
+
+	//see https://github.com/cryptomator/cryptomator/issues/2786
+	private static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
+		if (isFUSETOrMacFUSE(targetedService) && isFUSETOrMacFUSE(formerSelectedMountService.get()) && !targetedService.equals(formerSelectedMountService.get())) {
+			return new ActualMountService(formerSelectedMountService.get(), false); //
+		} else {
+			formerSelectedMountService.set(targetedService);
+			return new ActualMountService(targetedService, isDesired); //
+		}
+	}
+
+	private static boolean isFUSETOrMacFUSE(MountService service) {
+		if (service == null) {
+			return false;
+		} else {
+			return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
+		}
 	}
 
 }

From 2223bc5e781d3113bd80dc9c9532ba19aa3e36c7 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Mon, 13 Mar 2023 12:58:34 +0100
Subject: [PATCH 03/10] use correct selection logic

---
 .../cryptomator/common/mount/MountModule.java | 27 ++++++++++++++-----
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index 2511a9d2e..c0d3f9777 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -9,12 +9,15 @@ import org.cryptomator.integrations.mount.MountService;
 import javax.inject.Singleton;
 import javafx.beans.value.ObservableValue;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 @Module
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
+	private static final AtomicBoolean<MountService> MAC_FUSE_SELECTED_ONCE = new AtomicBoolean(false);
+	private static final AtomicBoolean<MountService> FUSET_SELECTED_ONCE = new AtomicBoolean(false);
 
 	@Provides
 	@Singleton
@@ -42,7 +45,17 @@ public class MountModule {
 
 	//see https://github.com/cryptomator/cryptomator/issues/2786
 	private static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
-		if (isFUSETOrMacFUSE(targetedService) && isFUSETOrMacFUSE(formerSelectedMountService.get()) && !targetedService.equals(formerSelectedMountService.get())) {
+		//check if any of both were already used. If not, check if targetedService is macFuse or FUSE-T
+		if (!MAC_FUSE_SELECTED_ONCE.get() && !FUSET_SELECTED_ONCE.get()) {
+			if (isMacFuseService(targetedService)) {
+				MAC_FUSE_SELECTED_ONCE.set(true);
+			} else if (isFuseTService(targetedService)) {
+				FUSET_SELECTED_ONCE.set(true);
+			}
+		}
+
+		if ((MAC_FUSE_SELECTED_ONCE.get() && isFuseTService(targetedService)) //
+				|| (FUSET_SELECTED_ONCE.get() && isMacFuseService(targetedService))) {
 			return new ActualMountService(formerSelectedMountService.get(), false); //
 		} else {
 			formerSelectedMountService.set(targetedService);
@@ -50,12 +63,12 @@ public class MountModule {
 		}
 	}
 
-	private static boolean isFUSETOrMacFUSE(MountService service) {
-		if (service == null) {
-			return false;
-		} else {
-			return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
-		}
+	private static boolean isFuseTService(MountService service) {
+		return "org.cryptomator.frontend.fuse.mount.FuseTMountProvider".equals(service.getClass().getName());
+	}
+
+	private static boolean isMacFuseService(MountService service) {
+		return "org.cryptomator.frontend.fuse.mount.MacFuseMountProvider".equals(service.getClass().getName());
 	}
 
 }

From 03a362e9b43cda56c096a0a818acf288f4395a60 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Mon, 13 Mar 2023 13:01:13 +0100
Subject: [PATCH 04/10] fix compilation

---
 src/main/java/org/cryptomator/common/mount/MountModule.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index c0d3f9777..a876225c3 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -16,8 +16,8 @@ import java.util.concurrent.atomic.AtomicReference;
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
-	private static final AtomicBoolean<MountService> MAC_FUSE_SELECTED_ONCE = new AtomicBoolean(false);
-	private static final AtomicBoolean<MountService> FUSET_SELECTED_ONCE = new AtomicBoolean(false);
+	private static final AtomicBoolean MAC_FUSE_SELECTED_ONCE = new AtomicBoolean(false);
+	private static final AtomicBoolean FUSET_SELECTED_ONCE = new AtomicBoolean(false);
 
 	@Provides
 	@Singleton

From c988fb50a77794bca321055f81afddda665e2982 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Wed, 29 Mar 2023 11:39:18 +0200
Subject: [PATCH 05/10] increase readability

---
 .../cryptomator/common/mount/MountModule.java | 35 ++++++++++++-------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index a876225c3..2f84e9908 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -9,15 +9,17 @@ import org.cryptomator.integrations.mount.MountService;
 import javax.inject.Singleton;
 import javafx.beans.value.ObservableValue;
 import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
+import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.FUSET;
+import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.MACFUSE;
+import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.UNDEFINED;
+
 @Module
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
-	private static final AtomicBoolean MAC_FUSE_SELECTED_ONCE = new AtomicBoolean(false);
-	private static final AtomicBoolean FUSET_SELECTED_ONCE = new AtomicBoolean(false);
+	private static final AtomicReference<FirstUsedFuseOnMacOS> FIRST_USED = new AtomicReference<>(UNDEFINED);
 
 	@Provides
 	@Singleton
@@ -44,18 +46,22 @@ public class MountModule {
 
 
 	//see https://github.com/cryptomator/cryptomator/issues/2786
-	private static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
-		//check if any of both were already used. If not, check if targetedService is macFuse or FUSE-T
-		if (!MAC_FUSE_SELECTED_ONCE.get() && !FUSET_SELECTED_ONCE.get()) {
-			if (isMacFuseService(targetedService)) {
-				MAC_FUSE_SELECTED_ONCE.set(true);
-			} else if (isFuseTService(targetedService)) {
-				FUSET_SELECTED_ONCE.set(true);
+	private synchronized static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
+		var targetIsFuseT= isFuseTService(targetedService);
+		var targetIsMacFuse= isMacFuseService(targetedService);
+
+		//if none of macFUSE and FUSE-T were selected before, check if targetedService is macFUSE or FUSE-T
+		if (FIRST_USED.get() == UNDEFINED) {
+			if (targetIsMacFuse) {
+				FIRST_USED.set(MAC_FUSE);
+			} else if (targetIsFuseT) {
+				FIRST_USED.set(FUSE_T);
 			}
 		}
 
-		if ((MAC_FUSE_SELECTED_ONCE.get() && isFuseTService(targetedService)) //
-				|| (FUSET_SELECTED_ONCE.get() && isMacFuseService(targetedService))) {
+		//if one of both were selected before and now the other should be used
+		if ((FIRST_USED.get() == MAC_FUSE && targetIsFuseT) || (FIRST_USED.get() == FUSE_T && targetIsMacFuse )) {
+			//return the former mount service
 			return new ActualMountService(formerSelectedMountService.get(), false); //
 		} else {
 			formerSelectedMountService.set(targetedService);
@@ -71,4 +77,9 @@ public class MountModule {
 		return "org.cryptomator.frontend.fuse.mount.MacFuseMountProvider".equals(service.getClass().getName());
 	}
 
+	private enum FirstUsedFuseOnMacOS {
+		UNDEFINED,
+		MAC_FUSE,
+		FUSE_T;
+	}
 }

From 943a3e9cfd36a9f9af65ca28f36a7be7526708f5 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Wed, 29 Mar 2023 11:42:14 +0200
Subject: [PATCH 06/10] adjust visibility

---
 .../org/cryptomator/common/mount/MountModule.java    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index 2f84e9908..4e278c793 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -11,8 +11,8 @@ import javafx.beans.value.ObservableValue;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.FUSET;
-import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.MACFUSE;
+import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.FUSE_T;
+import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.MAC_FUSE;
 import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.UNDEFINED;
 
 @Module
@@ -47,8 +47,8 @@ public class MountModule {
 
 	//see https://github.com/cryptomator/cryptomator/issues/2786
 	private synchronized static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
-		var targetIsFuseT= isFuseTService(targetedService);
-		var targetIsMacFuse= isMacFuseService(targetedService);
+		var targetIsFuseT = isFuseTService(targetedService);
+		var targetIsMacFuse = isMacFuseService(targetedService);
 
 		//if none of macFUSE and FUSE-T were selected before, check if targetedService is macFUSE or FUSE-T
 		if (FIRST_USED.get() == UNDEFINED) {
@@ -60,7 +60,7 @@ public class MountModule {
 		}
 
 		//if one of both were selected before and now the other should be used
-		if ((FIRST_USED.get() == MAC_FUSE && targetIsFuseT) || (FIRST_USED.get() == FUSE_T && targetIsMacFuse )) {
+		if ((FIRST_USED.get() == MAC_FUSE && targetIsFuseT) || (FIRST_USED.get() == FUSE_T && targetIsMacFuse)) {
 			//return the former mount service
 			return new ActualMountService(formerSelectedMountService.get(), false); //
 		} else {
@@ -77,7 +77,7 @@ public class MountModule {
 		return "org.cryptomator.frontend.fuse.mount.MacFuseMountProvider".equals(service.getClass().getName());
 	}
 
-	private enum FirstUsedFuseOnMacOS {
+	enum FirstUsedFuseOnMacOS {
 		UNDEFINED,
 		MAC_FUSE,
 		FUSE_T;

From 771468c8c655b6aed820ca0554a09be755c422c5 Mon Sep 17 00:00:00 2001
From: Tobias Hagemann <tobias.hagemann@skymatic.de>
Date: Wed, 29 Mar 2023 16:16:04 +0200
Subject: [PATCH 07/10] refactored macfuse/fuse-t specific workaround to a
 generic fuse workaround

---
 .../cryptomator/common/mount/MountModule.java | 50 ++++++-------------
 .../VolumePreferencesController.java          | 16 +++---
 .../resources/fxml/preferences_volume.fxml    |  4 +-
 src/main/resources/i18n/strings.properties    |  1 +
 4 files changed, 25 insertions(+), 46 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index 4e278c793..e9d8098a5 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -11,15 +11,11 @@ import javafx.beans.value.ObservableValue;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.FUSE_T;
-import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.MAC_FUSE;
-import static org.cryptomator.common.mount.MountModule.FirstUsedFuseOnMacOS.UNDEFINED;
-
 @Module
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
-	private static final AtomicReference<FirstUsedFuseOnMacOS> FIRST_USED = new AtomicReference<>(UNDEFINED);
+	private static final AtomicReference<MountService> firstUsedFuseMountService = new AtomicReference<>(null);
 
 	@Provides
 	@Singleton
@@ -36,50 +32,32 @@ public class MountModule {
 				desiredServiceImpl -> { //
 					var serviceFromSettings = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(desiredServiceImpl)).findAny(); //
 					var targetedService = serviceFromSettings.orElse(fallbackProvider);
-					return applyWorkaroundForFuseTMacFuse(targetedService, serviceFromSettings.isPresent());
+					return applyWorkaroundForFuse(targetedService, serviceFromSettings.isPresent());
 				}, //
 				() -> { //
-					return applyWorkaroundForFuseTMacFuse(fallbackProvider, true);
+					return applyWorkaroundForFuse(fallbackProvider, true);
 				});
 		return observableMountService;
 	}
 
-
 	//see https://github.com/cryptomator/cryptomator/issues/2786
-	private synchronized static ActualMountService applyWorkaroundForFuseTMacFuse(MountService targetedService, boolean isDesired) {
-		var targetIsFuseT = isFuseTService(targetedService);
-		var targetIsMacFuse = isMacFuseService(targetedService);
-
-		//if none of macFUSE and FUSE-T were selected before, check if targetedService is macFUSE or FUSE-T
-		if (FIRST_USED.get() == UNDEFINED) {
-			if (targetIsMacFuse) {
-				FIRST_USED.set(MAC_FUSE);
-			} else if (targetIsFuseT) {
-				FIRST_USED.set(FUSE_T);
-			}
+	private synchronized static ActualMountService applyWorkaroundForFuse(MountService targetedService, boolean isDesired) {
+		//set the first used fuse service if applicable
+		var targetIsFuse = isFuseService(targetedService);
+		if (targetIsFuse && firstUsedFuseMountService.get() == null) {
+			firstUsedFuseMountService.set(targetedService);
 		}
 
-		//if one of both were selected before and now the other should be used
-		if ((FIRST_USED.get() == MAC_FUSE && targetIsFuseT) || (FIRST_USED.get() == FUSE_T && targetIsMacFuse)) {
-			//return the former mount service
-			return new ActualMountService(formerSelectedMountService.get(), false); //
+		//make sure that the first used fuse service is always used
+		if (targetIsFuse && !firstUsedFuseMountService.get().equals(targetedService)) {
+			return new ActualMountService(formerSelectedMountService.get(), false);
 		} else {
 			formerSelectedMountService.set(targetedService);
-			return new ActualMountService(targetedService, isDesired); //
+			return new ActualMountService(targetedService, isDesired);
 		}
 	}
 
-	private static boolean isFuseTService(MountService service) {
-		return "org.cryptomator.frontend.fuse.mount.FuseTMountProvider".equals(service.getClass().getName());
-	}
-
-	private static boolean isMacFuseService(MountService service) {
-		return "org.cryptomator.frontend.fuse.mount.MacFuseMountProvider".equals(service.getClass().getName());
-	}
-
-	enum FirstUsedFuseOnMacOS {
-		UNDEFINED,
-		MAC_FUSE,
-		FUSE_T;
+	private static boolean isFuseService(MountService service) {
+		return service.getClass().getName().startsWith("org.cryptomator.frontend.fuse.mount.");
 	}
 }
diff --git a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
index ab3c319ba..5d0e66da5 100644
--- a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
+++ b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
@@ -33,7 +33,7 @@ public class VolumePreferencesController implements FxController {
 	private final ObservableValue<Boolean> mountToDriveLetterSupported;
 	private final ObservableValue<Boolean> mountFlagsSupported;
 	private final ObservableValue<Boolean> readonlySupported;
-	private final ObservableValue<Boolean> macFuseAndFUSETRestartRequired;
+	private final ObservableValue<Boolean> fuseRestartRequired;
 	private final Lazy<Application> application;
 	private final List<MountService> mountProviders;
 	public ChoiceBox<MountService> volumeTypeChoiceBox;
@@ -55,11 +55,11 @@ public class VolumePreferencesController implements FxController {
 		this.mountFlagsSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_FLAGS));
 		this.readonlySupported = selectedMountService.map(s -> s.hasCapability(MountCapability.READ_ONLY));
 		var mountServiceAtStart = selectedMountService.getValue();
-		this.macFuseAndFUSETRestartRequired = selectedMountService.map(s -> isFUSETOrMacFUSE(mountServiceAtStart) && isFUSETOrMacFUSE(s) && !mountServiceAtStart.equals(s));
+		this.fuseRestartRequired = selectedMountService.map(s -> isFuse(mountServiceAtStart) && isFuse(s) && !mountServiceAtStart.equals(s));
 	}
 
-	private boolean isFUSETOrMacFUSE(MountService service) {
-		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
+	private boolean isFuse(MountService service) {
+		return service.getClass().getName().startsWith("org.cryptomator.frontend.fuse.mount.");
 	}
 
 	public void initialize() {
@@ -136,12 +136,12 @@ public class VolumePreferencesController implements FxController {
 		return mountFlagsSupported.getValue();
 	}
 
-	public ObservableValue<Boolean> macFuseAndFUSETRestartRequiredProperty() {
-		return macFuseAndFUSETRestartRequired;
+	public ObservableValue<Boolean> fuseRestartRequiredProperty() {
+		return fuseRestartRequired;
 	}
 
-	public boolean isMacFuseAndFUSETRestartRequired() {
-		return macFuseAndFUSETRestartRequired.getValue();
+	public boolean getFuseRestartRequired() {
+		return fuseRestartRequired.getValue();
 	}
 
 	/* Helpers */
diff --git a/src/main/resources/fxml/preferences_volume.fxml b/src/main/resources/fxml/preferences_volume.fxml
index 680579fbe..f48b1c1c8 100644
--- a/src/main/resources/fxml/preferences_volume.fxml
+++ b/src/main/resources/fxml/preferences_volume.fxml
@@ -8,9 +8,9 @@
 <?import javafx.scene.control.Hyperlink?>
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.control.Separator?>
+<?import javafx.scene.control.Tooltip?>
 <?import javafx.scene.layout.HBox?>
 <?import javafx.scene.layout.VBox?>
-<?import javafx.scene.control.Tooltip?>
 <VBox xmlns:fx="http://javafx.com/fxml"
 	  xmlns="http://javafx.com/javafx"
 	  fx:controller="org.cryptomator.ui.preferences.VolumePreferencesController"
@@ -32,7 +32,7 @@
 			</Hyperlink>
 		</HBox>
 
-		<Label styleClass="label-red" text="To apply the changes, Cryptomator needs to be restarted." visible="${controller.macFuseAndFUSETRestartRequired}" managed="${controller.macFuseAndFUSETRestartRequired}"/>
+		<Label styleClass="label-red" text="%preferences.volume.fuseRestartRequired" visible="${controller.fuseRestartRequired}" managed="${controller.fuseRestartRequired}"/>
 
 		<HBox spacing="12" alignment="CENTER_LEFT" visible="${controller.loopbackPortSupported}" managed="${controller.loopbackPortSupported}">
 			<Label text="%preferences.volume.tcp.port"/>
diff --git a/src/main/resources/i18n/strings.properties b/src/main/resources/i18n/strings.properties
index a14957cc9..6c580ba84 100644
--- a/src/main/resources/i18n/strings.properties
+++ b/src/main/resources/i18n/strings.properties
@@ -278,6 +278,7 @@ preferences.volume=Virtual Drive
 preferences.volume.type=Volume Type
 preferences.volume.type.automatic=Automatic
 preferences.volume.docsTooltip=Open the documentation to learn more about the different volume types.
+preferences.volume.fuseRestartRequired=To apply the changes, Cryptomator needs to be restarted.
 preferences.volume.tcp.port=TCP Port
 preferences.volume.supportedFeatures=The chosen volume type supports the following features:
 preferences.volume.feature.mountAuto=Automatic mount point selection

From b5bbd21f2528a93bf01d237894b1ae0712ca6a8f Mon Sep 17 00:00:00 2001
From: Tobias Hagemann <tobias.hagemann@skymatic.de>
Date: Wed, 29 Mar 2023 16:50:02 +0200
Subject: [PATCH 08/10] refactored the refactoring to a macfuse/fuse-t
 workaround again

---
 .../cryptomator/common/mount/MountModule.java | 24 +++++++++----------
 .../VolumePreferencesController.java          |  6 ++---
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index e9d8098a5..a6e7fb490 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -15,7 +15,7 @@ import java.util.concurrent.atomic.AtomicReference;
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
-	private static final AtomicReference<MountService> firstUsedFuseMountService = new AtomicReference<>(null);
+	private static final AtomicReference<MountService> firstUsedProblematicFuseMountService = new AtomicReference<>(null);
 
 	@Provides
 	@Singleton
@@ -32,24 +32,24 @@ public class MountModule {
 				desiredServiceImpl -> { //
 					var serviceFromSettings = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(desiredServiceImpl)).findAny(); //
 					var targetedService = serviceFromSettings.orElse(fallbackProvider);
-					return applyWorkaroundForFuse(targetedService, serviceFromSettings.isPresent());
+					return applyWorkaroundForProblematicFuse(targetedService, serviceFromSettings.isPresent());
 				}, //
 				() -> { //
-					return applyWorkaroundForFuse(fallbackProvider, true);
+					return applyWorkaroundForProblematicFuse(fallbackProvider, true);
 				});
 		return observableMountService;
 	}
 
 	//see https://github.com/cryptomator/cryptomator/issues/2786
-	private synchronized static ActualMountService applyWorkaroundForFuse(MountService targetedService, boolean isDesired) {
-		//set the first used fuse service if applicable
-		var targetIsFuse = isFuseService(targetedService);
-		if (targetIsFuse && firstUsedFuseMountService.get() == null) {
-			firstUsedFuseMountService.set(targetedService);
+	private synchronized static ActualMountService applyWorkaroundForProblematicFuse(MountService targetedService, boolean isDesired) {
+		//set the first used problematic fuse service if applicable
+		var targetIsProblematicFuse = isProblematicFuseService(targetedService);
+		if (targetIsProblematicFuse && firstUsedProblematicFuseMountService.get() == null) {
+			firstUsedProblematicFuseMountService.set(targetedService);
 		}
 
-		//make sure that the first used fuse service is always used
-		if (targetIsFuse && !firstUsedFuseMountService.get().equals(targetedService)) {
+		//make sure that the first used problematic fuse service is always used
+		if (targetIsProblematicFuse && !firstUsedProblematicFuseMountService.get().equals(targetedService)) {
 			return new ActualMountService(formerSelectedMountService.get(), false);
 		} else {
 			formerSelectedMountService.set(targetedService);
@@ -57,7 +57,7 @@ public class MountModule {
 		}
 	}
 
-	private static boolean isFuseService(MountService service) {
-		return service.getClass().getName().startsWith("org.cryptomator.frontend.fuse.mount.");
+	private static boolean isProblematicFuseService(MountService service) {
+		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
 	}
 }
diff --git a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
index 5d0e66da5..b665a682f 100644
--- a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
+++ b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
@@ -55,11 +55,11 @@ public class VolumePreferencesController implements FxController {
 		this.mountFlagsSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_FLAGS));
 		this.readonlySupported = selectedMountService.map(s -> s.hasCapability(MountCapability.READ_ONLY));
 		var mountServiceAtStart = selectedMountService.getValue();
-		this.fuseRestartRequired = selectedMountService.map(s -> isFuse(mountServiceAtStart) && isFuse(s) && !mountServiceAtStart.equals(s));
+		this.fuseRestartRequired = selectedMountService.map(s -> isProblematicFuse(mountServiceAtStart) && isProblematicFuse(s) && !mountServiceAtStart.equals(s));
 	}
 
-	private boolean isFuse(MountService service) {
-		return service.getClass().getName().startsWith("org.cryptomator.frontend.fuse.mount.");
+	private boolean isProblematicFuse(MountService service) {
+		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
 	}
 
 	public void initialize() {

From c8a6d0339e503e9dfdbca1db6a20806b3bb8697f Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Wed, 29 Mar 2023 17:42:18 +0200
Subject: [PATCH 09/10] Use in volume preferences controller same objet as in
 MountModule to store first used fuse mount service

---
 .../cryptomator/common/mount/MountModule.java | 23 +++++++++++++------
 .../VolumePreferencesController.java          | 15 +++++++-----
 2 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index a6e7fb490..1241b783e 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -4,8 +4,10 @@ import dagger.Module;
 import dagger.Provides;
 import org.cryptomator.common.ObservableUtil;
 import org.cryptomator.common.settings.Settings;
+import org.cryptomator.integrations.mount.Mount;
 import org.cryptomator.integrations.mount.MountService;
 
+import javax.inject.Named;
 import javax.inject.Singleton;
 import javafx.beans.value.ObservableValue;
 import java.util.List;
@@ -15,7 +17,7 @@ import java.util.concurrent.atomic.AtomicReference;
 public class MountModule {
 
 	private static final AtomicReference<MountService> formerSelectedMountService = new AtomicReference<>(null);
-	private static final AtomicReference<MountService> firstUsedProblematicFuseMountService = new AtomicReference<>(null);
+	private static final List<String> problematicFuseMountServices = List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider");
 
 	@Provides
 	@Singleton
@@ -25,23 +27,30 @@ public class MountModule {
 
 	@Provides
 	@Singleton
-	static ObservableValue<ActualMountService> provideMountService(Settings settings, List<MountService> serviceImpls) {
+	@Named("FUPFMS")
+	static AtomicReference<MountService> provideFirstUsedProblematicFuseMountService() {
+		return new AtomicReference<>(null);
+	}
+
+	@Provides
+	@Singleton
+	static ObservableValue<ActualMountService> provideMountService(Settings settings, List<MountService> serviceImpls, @Named("FUPFMS") AtomicReference<MountService> fupfms) {
 		var fallbackProvider = serviceImpls.stream().findFirst().orElse(null);
 
 		var observableMountService = ObservableUtil.mapWithDefault(settings.mountService(), //
 				desiredServiceImpl -> { //
 					var serviceFromSettings = serviceImpls.stream().filter(serviceImpl -> serviceImpl.getClass().getName().equals(desiredServiceImpl)).findAny(); //
 					var targetedService = serviceFromSettings.orElse(fallbackProvider);
-					return applyWorkaroundForProblematicFuse(targetedService, serviceFromSettings.isPresent());
+					return applyWorkaroundForProblematicFuse(targetedService, serviceFromSettings.isPresent(), fupfms);
 				}, //
 				() -> { //
-					return applyWorkaroundForProblematicFuse(fallbackProvider, true);
+					return applyWorkaroundForProblematicFuse(fallbackProvider, true, fupfms);
 				});
 		return observableMountService;
 	}
 
 	//see https://github.com/cryptomator/cryptomator/issues/2786
-	private synchronized static ActualMountService applyWorkaroundForProblematicFuse(MountService targetedService, boolean isDesired) {
+	private synchronized static ActualMountService applyWorkaroundForProblematicFuse(MountService targetedService, boolean isDesired, AtomicReference<MountService> firstUsedProblematicFuseMountService) {
 		//set the first used problematic fuse service if applicable
 		var targetIsProblematicFuse = isProblematicFuseService(targetedService);
 		if (targetIsProblematicFuse && firstUsedProblematicFuseMountService.get() == null) {
@@ -57,7 +66,7 @@ public class MountModule {
 		}
 	}
 
-	private static boolean isProblematicFuseService(MountService service) {
-		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
+	public static boolean isProblematicFuseService(MountService service) {
+		return problematicFuseMountServices.contains(service.getClass().getName());
 	}
 }
diff --git a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
index b665a682f..6c60e74b7 100644
--- a/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
+++ b/src/main/java/org/cryptomator/ui/preferences/VolumePreferencesController.java
@@ -2,12 +2,14 @@ package org.cryptomator.ui.preferences;
 
 import dagger.Lazy;
 import org.cryptomator.common.ObservableUtil;
+import org.cryptomator.common.mount.MountModule;
 import org.cryptomator.common.settings.Settings;
 import org.cryptomator.integrations.mount.MountCapability;
 import org.cryptomator.integrations.mount.MountService;
 import org.cryptomator.ui.common.FxController;
 
 import javax.inject.Inject;
+import javax.inject.Named;
 import javafx.application.Application;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanExpression;
@@ -19,6 +21,7 @@ import javafx.util.StringConverter;
 import java.util.List;
 import java.util.Optional;
 import java.util.ResourceBundle;
+import java.util.concurrent.atomic.AtomicReference;
 
 @PreferencesScoped
 public class VolumePreferencesController implements FxController {
@@ -41,7 +44,7 @@ public class VolumePreferencesController implements FxController {
 	public Button loopbackPortApplyButton;
 
 	@Inject
-	VolumePreferencesController(Settings settings, Lazy<Application> application, List<MountService> mountProviders, ResourceBundle resourceBundle) {
+	VolumePreferencesController(Settings settings, Lazy<Application> application, List<MountService> mountProviders, @Named("FUPFMS") AtomicReference<MountService> firstUsedProblematicFuseMountService, ResourceBundle resourceBundle) {
 		this.settings = settings;
 		this.application = application;
 		this.mountProviders = mountProviders;
@@ -54,12 +57,12 @@ public class VolumePreferencesController implements FxController {
 		this.mountToDriveLetterSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_AS_DRIVE_LETTER));
 		this.mountFlagsSupported = selectedMountService.map(s -> s.hasCapability(MountCapability.MOUNT_FLAGS));
 		this.readonlySupported = selectedMountService.map(s -> s.hasCapability(MountCapability.READ_ONLY));
-		var mountServiceAtStart = selectedMountService.getValue();
-		this.fuseRestartRequired = selectedMountService.map(s -> isProblematicFuse(mountServiceAtStart) && isProblematicFuse(s) && !mountServiceAtStart.equals(s));
-	}
+		this.fuseRestartRequired = selectedMountService.map(s -> {//
+			return firstUsedProblematicFuseMountService.get() != null //
+					&& MountModule.isProblematicFuseService(s) //
+					&& !firstUsedProblematicFuseMountService.get().equals(s);
+		});
 
-	private boolean isProblematicFuse(MountService service) {
-		return List.of("org.cryptomator.frontend.fuse.mount.MacFuseMountProvider", "org.cryptomator.frontend.fuse.mount.FuseTMountProvider").contains(service.getClass().getName());
 	}
 
 	public void initialize() {

From 827f9ad141c12d70cb02d186a73144df8d6f0c35 Mon Sep 17 00:00:00 2001
From: Armin Schrenk <armin.schrenk@skymatic.de>
Date: Thu, 30 Mar 2023 11:18:28 +0200
Subject: [PATCH 10/10] adjust comment

---
 src/main/java/org/cryptomator/common/mount/MountModule.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/cryptomator/common/mount/MountModule.java b/src/main/java/org/cryptomator/common/mount/MountModule.java
index 1241b783e..0978c44db 100644
--- a/src/main/java/org/cryptomator/common/mount/MountModule.java
+++ b/src/main/java/org/cryptomator/common/mount/MountModule.java
@@ -57,7 +57,7 @@ public class MountModule {
 			firstUsedProblematicFuseMountService.set(targetedService);
 		}
 
-		//make sure that the first used problematic fuse service is always used
+		//do not use the targeted mount service and fallback to former one, if the service is problematic _and_ not the first problematic one used.
 		if (targetIsProblematicFuse && !firstUsedProblematicFuseMountService.get().equals(targetedService)) {
 			return new ActualMountService(formerSelectedMountService.get(), false);
 		} else {