fix: Assign method call listeners directly to the proxy instance (#2102)

src/main/java/io/appium/java_client/proxy/HasMethodCallListeners.java

@@ -0,0 +1,35 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appium.java_client.proxy;
+
+public interface HasMethodCallListeners {
+    /**
+     * The setter is dynamically created by ByteBuddy to store
+     * method call listeners on the instrumented proxy instance.
+     *
+     * @param methodCallListeners Array of method call listeners assigned to the proxy instance.
+     */
+    void setMethodCallListeners(MethodCallListener[] methodCallListeners);
+
+    /**
+     * The getter is dynamically created by ByteBuddy to access
+     * method call listeners on the instrumented proxy instance.
+     *
+     * @return Array of method call listeners assigned the proxy instance.
+     */
+    MethodCallListener[] getMethodCallListeners();
+}

src/main/java/io/appium/java_client/proxy/Helpers.java

@@ -19,7 +19,9 @@
 import com.google.common.base.Preconditions;
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.modifier.Visibility;
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.FieldAccessor;
 import net.bytebuddy.implementation.MethodDelegation;
 import net.bytebuddy.matcher.ElementMatcher;
 import net.bytebuddy.matcher.ElementMatchers;
@@ -118,16 +120,18 @@ public static <T> T createProxy(
                 .subclass(cls)
                 .method(extraMethodMatcher == null ? matcher : matcher.and(extraMethodMatcher))
                 .intercept(MethodDelegation.to(Interceptor.class))
+                // https://github.com/raphw/byte-buddy/blob/2caef35c172897cbdd21d163c55305a64649ce41/byte-buddy-dep/src/test/java/net/bytebuddy/ByteBuddyTutorialExamplesTest.java#L346
+                .defineField("methodCallListeners", MethodCallListener[].class, Visibility.PRIVATE)
+                .implement(HasMethodCallListeners.class).intercept(FieldAccessor.ofBeanProperty())
                 .make()
                 .load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                 .getLoaded()
                 .asSubclass(cls);
 
         try {
-            return ProxyListenersContainer.getInstance().setListeners(
-                    cls.cast(proxy.getConstructor(constructorArgTypes).newInstance(constructorArgs)),
-                    listeners
-            );
+            T result = cls.cast(proxy.getConstructor(constructorArgTypes).newInstance(constructorArgs));
+            ((HasMethodCallListeners) result).setMethodCallListeners(listeners.toArray(MethodCallListener[]::new));
+            return result;
         } catch (SecurityException | ReflectiveOperationException e) {
             throw new IllegalStateException(String.format("Unable to create a proxy of %s", cls.getName()), e);
         }

src/main/java/io/appium/java_client/proxy/Interceptor.java

@@ -25,10 +25,10 @@
 import org.slf4j.LoggerFactory;
 
 import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.UUID;
 import java.util.concurrent.Callable;
 
+import static io.appium.java_client.proxy.MethodCallListener.UNSET;
+
 public class Interceptor {
     private static final Logger LOGGER = LoggerFactory.getLogger(Interceptor.class);
 
@@ -37,7 +37,9 @@ private Interceptor() {
 
     /**
      * A magic method used to wrap public method calls in classes
-     * patched by ByteBuddy and acting as proxies.
+     * patched by ByteBuddy and acting as proxies. The performance
+     * of this method is mission-critical as it gets called upon
+     * every invocation of any method of the proxied class.
      *
      * @param self     The reference to the original instance.
      * @param method   The reference to the original method.
@@ -53,12 +55,12 @@ public static Object intercept(
             @AllArguments Object[] args,
             @SuperCall Callable<?> callable
     ) throws Throwable {
-        Collection<MethodCallListener> listeners = ProxyListenersContainer.getInstance().getListeners(self);
-        if (listeners.isEmpty()) {
+        var listeners = ((HasMethodCallListeners) self).getMethodCallListeners();
+        if (listeners == null || listeners.length == 0) {
             return callable.call();
         }
 
-        listeners.forEach(listener -> {
+        for (var listener : listeners) {
             try {
                 listener.beforeCall(self, method, args);
             } catch (NotImplementedException e) {
@@ -68,32 +70,39 @@ public static Object intercept(
                         self.getClass().getName(), method.getName(), e
                 );
             }
-        });
+        }
 
-        final UUID noResult = UUID.randomUUID();
-        Object result = noResult;
-        for (MethodCallListener listener : listeners) {
+        Object result = UNSET;
+        for (var listener : listeners) {
             try {
                 result = listener.call(self, method, args, callable);
-                break;
+                if (result != UNSET) {
+                    break;
+                }
             } catch (NotImplementedException e) {
                 // ignore
             } catch (Exception e) {
                 try {
-                    return listener.onError(self, method, args, e);
+                    result = listener.onError(self, method, args, e);
+                    if (result != UNSET) {
+                        return result;
+                    }
                 } catch (NotImplementedException ignore) {
                     // ignore
                 }
                 throw e;
             }
         }
-        if (noResult.equals(result)) {
+        if (UNSET == result) {
             try {
                 result = callable.call();
             } catch (Exception e) {
-                for (MethodCallListener listener : listeners) {
+                for (var listener : listeners) {
                     try {
-                        return listener.onError(self, method, args, e);
+                        result = listener.onError(self, method, args, e);
+                        if (result != UNSET) {
+                            return result;
+                        }
                     } catch (NotImplementedException ignore) {
                         // ignore
                     }
@@ -102,8 +111,8 @@ public static Object intercept(
             }
         }
 
-        final Object endResult = result == noResult ? null : result;
-        listeners.forEach(listener -> {
+        final Object endResult = result == UNSET ? null : result;
+        for (var listener : listeners) {
             try {
                 listener.afterCall(self, method, args, endResult);
             } catch (NotImplementedException e) {
@@ -113,7 +122,7 @@ public static Object intercept(
                         self.getClass().getName(), method.getName(), e
                 );
             }
-        });
+        }
         return endResult;
     }
 }

src/main/java/io/appium/java_client/proxy/MethodCallListener.java

@@ -17,9 +17,11 @@
 package io.appium.java_client.proxy;
 
 import java.lang.reflect.Method;
+import java.util.UUID;
 import java.util.concurrent.Callable;
 
 public interface MethodCallListener {
+    UUID UNSET = UUID.randomUUID();
 
     /**
      * The callback to be invoked before any public method of the proxy is called.
@@ -31,7 +33,6 @@ public interface MethodCallListener {
      * @param args   Array of method arguments
      */
     default void beforeCall(Object obj, Method method, Object[] args) {
-        throw new NotImplementedException();
     }
 
     /**
@@ -48,7 +49,7 @@ default void beforeCall(Object obj, Method method, Object[] args) {
      * @return The type of the returned result should be castable to the returned type of the original method.
      */
     default Object call(Object obj, Method method, Object[] args, Callable<?> original) throws Throwable {
-        throw new NotImplementedException();
+        return UNSET;
     }
 
     /**
@@ -61,7 +62,6 @@ default Object call(Object obj, Method method, Object[] args, Callable<?> origin
      * @param args   Array of method arguments
      */
     default void afterCall(Object obj, Method method, Object[] args, Object result) {
-        throw new NotImplementedException();
     }
 
     /**
@@ -77,6 +77,6 @@ default void afterCall(Object obj, Method method, Object[] args, Object result)
      *     type of the returned argument could be cast to the returned type of the original method.
      */
     default Object onError(Object obj, Method method, Object[] args, Throwable e) throws Throwable {
-        throw new NotImplementedException();
+        return UNSET;
     }
 }