Merge branch 'develop' into release/1.1.0

pom.xml

@@ -44,6 +44,18 @@
 			<version>23.0.0</version>
 			<scope>provided</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter</artifactId>
+			<version>5.8.2</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-core</artifactId>
+			<version>4.3.1</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 
     <build>

src/main/java/org/cryptomator/integrations/common/CheckAvailability.java

@@ -0,0 +1,48 @@
+package org.cryptomator.integrations.common;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Identifies 0..n public methods to check preconditions for the integration to work. These are the rules:
+ *
+ * <ul>
+ *     <li>Both the type and the method(s) must be annotated with {@code @CheckAvailability}</li>
+ *     <li>Only public no-arg boolean methods are considered</li>
+ *     <li>Methods <em>may</em> be {@code static}, in which case they get invoked before instantiating the service</li>
+ *     <li>Should the method throw an exception, it has the same effect as returning {@code false}</li>
+ *     <li>No specific execution order is guaranteed in case of multiple annotated methods</li>
+ *     <li>Annotations must be present on classes or ancestor classes, not on interfaces</li>
+ * </ul>
+ *
+ * Example:
+ * <pre>
+ * {@code
+ * @CheckAvailability
+ * public class Foo {
+ *	@CheckAvailability
+ *	public static boolean isSupported() {
+ *		return "enabled".equals(System.getProperty("plugin.status"));
+ *	}
+ * }
+ * }
+ * </pre>
+ * <p>
+ * Annotations are discovered at runtime using reflection, so make sure to make relevant classes accessible to this
+ * module ({@code opens X to org.cryptomator.integrations.api}).
+ *
+ * @since 1.1.0
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Inherited
+@ApiStatus.Experimental
+public @interface CheckAvailability {
+}

src/main/java/org/cryptomator/integrations/common/ClassLoaderFactory.java

@@ -0,0 +1,66 @@
+package org.cryptomator.integrations.common;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.VisibleForTesting;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class ClassLoaderFactory {
+
+	private static final String USER_HOME = System.getProperty("user.home");
+	private static final String PLUGIN_DIR_KEY = "cryptomator.pluginDir";
+	private static final String JAR_SUFFIX = ".jar";
+
+	/**
+	 * Attempts to find {@code .jar} files in the path specified in {@value #PLUGIN_DIR_KEY} system property.
+	 * A new class loader instance is returned that loads classes from the given classes.
+	 *
+	 * @return A new URLClassLoader that is aware of all {@code .jar} files in the plugin dir
+	 */
+	@Contract(value = "-> new", pure = true)
+	public static URLClassLoader forPluginDir() {
+		String val = System.getProperty(PLUGIN_DIR_KEY, "");
+		final Path p;
+		if (val.startsWith("~/")) {
+			p = Path.of(USER_HOME).resolve(val.substring(2));
+		} else {
+			p = Path.of(val);
+		}
+		return forPluginDirWithPath(p);
+	}
+
+	@VisibleForTesting
+	@Contract(value = "_ -> new", pure = true)
+	static URLClassLoader forPluginDirWithPath(Path path) throws UncheckedIOException {
+		return URLClassLoader.newInstance(findJars(path));
+	}
+
+	@VisibleForTesting
+	static URL[] findJars(Path path) {
+		try (var stream = Files.walk(path)) {
+			return stream.filter(ClassLoaderFactory::isJarFile).map(ClassLoaderFactory::toUrl).toArray(URL[]::new);
+		} catch (IOException | UncheckedIOException e) {
+			// unable to locate any jars // TODO: log a warning?
+			return new URL[0];
+		}
+	}
+
+	private static URL toUrl(Path path) throws UncheckedIOException {
+		try {
+			return path.toUri().toURL();
+		} catch (MalformedURLException e) {
+			throw new UncheckedIOException(e);
+		}
+	}
+
+	private static boolean isJarFile(Path path) {
+		return Files.isRegularFile(path) && path.getFileName().toString().toLowerCase().endsWith(JAR_SUFFIX);
+	}
+
+}

src/main/java/org/cryptomator/integrations/common/IntegrationsLoader.java

@@ -1,5 +1,10 @@
 package org.cryptomator.integrations.common;
 
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Optional;
@@ -8,6 +13,9 @@
 
 public class IntegrationsLoader {
 
+	private IntegrationsLoader() {
+	}
+
 	/**
 	 * Loads the best suited service, i.e. the one with the highest priority that is supported.
 	 * <p>
@@ -29,11 +37,13 @@ public static <T> Optional<T> load(Class<T> clazz) {
 	 * @return An ordered stream of all suited service candidates
 	 */
 	public static <T> Stream<T> loadAll(Class<T> clazz) {
-		return ServiceLoader.load(clazz)
+		return ServiceLoader.load(clazz, ClassLoaderFactory.forPluginDir())
 				.stream()
 				.filter(IntegrationsLoader::isSupportedOperatingSystem)
+				.filter(IntegrationsLoader::passesStaticAvailabilityCheck)
 				.sorted(Comparator.comparingInt(IntegrationsLoader::getPriority).reversed())
-				.map(ServiceLoader.Provider::get);
+				.map(ServiceLoader.Provider::get)
+				.filter(IntegrationsLoader::passesInstanceAvailabilityCheck);
 	}
 
 	private static int getPriority(ServiceLoader.Provider<?> provider) {
@@ -46,4 +56,43 @@ private static boolean isSupportedOperatingSystem(ServiceLoader.Provider<?> prov
 		return annotations.length == 0 || Arrays.stream(annotations).anyMatch(OperatingSystem.Value::isCurrent);
 	}
 
+	private static boolean passesStaticAvailabilityCheck(ServiceLoader.Provider<?> provider) {
+		return passesStaticAvailabilityCheck(provider.type());
+	}
+
+	@VisibleForTesting
+	static boolean passesStaticAvailabilityCheck(Class<?> type) {
+		return passesAvailabilityCheck(type, null);
+	}
+
+	@VisibleForTesting
+	static boolean passesInstanceAvailabilityCheck(Object instance) {
+		return passesAvailabilityCheck(instance.getClass(), instance);
+	}
+
+	private static <T> boolean passesAvailabilityCheck(Class<? extends T> type, @Nullable T instance) {
+		if (!type.isAnnotationPresent(CheckAvailability.class)) {
+			return true; // if type is not annotated, skip tests
+		}
+		return Arrays.stream(type.getMethods())
+				.filter(m -> isAvailabilityCheck(m, instance == null))
+				.allMatch(m -> passesAvailabilityCheck(m, instance));
+	}
+
+	private static boolean passesAvailabilityCheck(Method m, @Nullable Object instance) {
+		assert Boolean.TYPE.equals(m.getReturnType());
+		try {
+			return (boolean) m.invoke(instance);
+		} catch (ReflectiveOperationException e) {
+			return false;
+		}
+	}
+
+	private static boolean isAvailabilityCheck(Method m, boolean isStatic) {
+		return m.isAnnotationPresent(CheckAvailability.class)
+				&& Boolean.TYPE.equals(m.getReturnType())
+				&& m.getParameterCount() == 0
+				&& Modifier.isStatic(m.getModifiers()) == isStatic;
+	}
+
 }

src/main/java/org/cryptomator/integrations/tray/ActionItem.java

@@ -1,4 +1,8 @@
 package org.cryptomator.integrations.tray;
 
-public record ActionItem(String title, Runnable action) implements TrayMenuItem {
+public record ActionItem(String title, Runnable action, boolean enabled) implements TrayMenuItem {
+
+	public ActionItem(String title, Runnable action) {
+		this(title, action, true);
+	}
 }

src/main/java/org/cryptomator/integrations/tray/TrayMenuController.java

@@ -23,20 +23,21 @@ static Optional<TrayMenuController> get() {
 	/**
 	 * Displays an icon on the system tray.
 	 *
-	 * @param rawImageData  What image to show
+	 * @param imageData     What image to show
 	 * @param defaultAction Action to perform when interacting with the icon directly instead of its menu
 	 * @param tooltip       Text shown when hovering
-	 * @throws IOException thrown when interacting with the given <code>rawImageData</code>
+	 * @throws TrayMenuException thrown when adding the tray icon failed
 	 */
-	void showTrayIcon(InputStream rawImageData, Runnable defaultAction, String tooltip) throws IOException;
+	void showTrayIcon(byte[] imageData, Runnable defaultAction, String tooltip) throws TrayMenuException;
 
 	/**
 	 * Show the given options in the tray menu.
 	 * <p>
 	 * This method may be called multiple times, e.g. when the vault list changes.
 	 *
 	 * @param items Menu items
+	 * @throws TrayMenuException thrown when updating the tray menu failed
 	 */
-	void updateTrayMenu(List<TrayMenuItem> items);
+	void updateTrayMenu(List<TrayMenuItem> items) throws TrayMenuException;
 
 }

src/main/java/org/cryptomator/integrations/tray/TrayMenuException.java

@@ -0,0 +1,13 @@
+package org.cryptomator.integrations.tray;
+
+public class TrayMenuException extends Exception {
+
+	public TrayMenuException(String message) {
+		super(message);
+	}
+
+	public TrayMenuException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+}