add UserServiceFactorySelector & fix visibility

Author: kanat

src/main/java/io/getstream/chat/java/services/framework/DefaultClient.java

@@ -76,7 +76,7 @@ public DefaultClient(Properties properties) {
     this.apiSecret = apiSecret.toString();
     this.apiKey = apiKey.toString();
     this.retrofit = buildRetrofitClient();
-    this.serviceFactory = new UserServiceFactoryProxy(retrofit);
+    this.serviceFactory = new UserServiceFactorySelector(retrofit);
   }
 
   private Retrofit buildRetrofitClient() {

src/main/java/io/getstream/chat/java/services/framework/UserCall.java

@@ -5,7 +5,7 @@
 
 import java.io.IOException;
 
-public class UserCall<T> implements retrofit2.Call<T> {
+class UserCall<T> implements retrofit2.Call<T> {
   private final retrofit2.Call<T> delegate;
   private final UserToken token;
 

src/main/java/io/getstream/chat/java/services/framework/UserServiceFactory.java

@@ -1,6 +1,6 @@
 package io.getstream.chat.java.services.framework;
 
-public interface UserServiceFactory {
+interface UserServiceFactory {
 
   <TService> TService create(Class<TService> svcClass, UserToken userToken);
 

src/main/java/io/getstream/chat/java/services/framework/UserServiceFactorySelector.java

@@ -0,0 +1,91 @@
+package io.getstream.chat.java.services.framework;
+
+import retrofit2.Retrofit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Smart user-aware service factory with automatic fallback mechanism.
+ * <p>
+ * This implementation attempts to use {@link UserServiceFactoryProxy} (more efficient)
+ * and automatically falls back to {@link UserServiceFactoryTagging} if reflection fails
+ * or the Retrofit API has changed.
+ * <p>
+ * <b>Fallback Strategy:</b>
+ * <ol>
+ *   <li>First attempt: Use proxy-based approach (reuses Retrofit instance)</li>
+ *   <li>On failure: Switch to tagging-based approach (more compatible)</li>
+ *   <li>Once switched: All subsequent calls use the fallback implementation</li>
+ * </ol>
+ * <p>
+ * <b>Thread-safety:</b> Thread-safe. Uses atomic reference for fallback state tracking.
+ * Multiple threads may attempt fallback simultaneously, but only one will win.
+ */
+final class UserServiceFactorySelector implements UserServiceFactory {
+
+  private final UserServiceFactory proxyFactory;
+  private final UserServiceFactory taggingFactory;
+  private final AtomicReference<UserServiceFactory> activeFactory;
+
+  /**
+   * Constructs a new smart factory with fallback capability.
+   *
+   * @param retrofit the Retrofit instance to create services from
+   */
+  public UserServiceFactorySelector(Retrofit retrofit) {
+    this.proxyFactory = new UserServiceFactoryProxy(retrofit);
+    this.taggingFactory = new UserServiceFactoryTagging(retrofit);
+    
+    // Verify proxy approach is viable before setting default
+    UserServiceFactory defaultFactory = proxyFactory;
+    try {
+      // Check if we can access the rawCall field that UserTokenCallRewriter needs
+      Class<?> retrofitCallClass = Class.forName("retrofit2.OkHttpCall");
+      retrofitCallClass.getDeclaredField("rawCall");
+      // If we get here, proxy should work
+    } catch (Throwable e) {
+      // Proxy approach won't work, use tagging as default
+      defaultFactory = taggingFactory;
+    }
+    
+    this.activeFactory = new AtomicReference<>(defaultFactory);
+  }
+
+  /**
+   * Creates a user-aware service instance with automatic fallback.
+   * <p>
+   * Attempts to use the proxy implementation first. If it fails (due to reflection issues,
+   * API changes, or other errors), automatically switches to the tagging implementation
+   * and retries.
+   *
+   * @param svcClass  the Retrofit service interface class
+   * @param userToken the user token to inject into all requests from this service
+   * @param <TService> the service type
+   * @return a service instance that injects the user token
+   * @throws RuntimeException if both implementations fail
+   */
+  @Override
+  public <TService> TService create(Class<TService> svcClass, UserToken userToken) {
+    UserServiceFactory factory = activeFactory.get();
+    
+    try {
+      return factory.create(svcClass, userToken);
+    } catch (Throwable e) {
+      // If we're already using the fallback, propagate the error
+      if (factory == taggingFactory) {
+        throw new RuntimeException("Failed to create service using fallback implementation", e);
+      }
+
+      // Switch to fallback and retry
+      activeFactory.compareAndSet(proxyFactory, taggingFactory);
+
+      // Retry with fallback
+      try {
+        return taggingFactory.create(svcClass, userToken);
+      } catch (Throwable fallbackException) {
+        throw new RuntimeException("Failed to create service with both implementations", fallbackException);
+      }
+    }
+  }
+
+}
+

src/main/java/io/getstream/chat/java/services/framework/UserServiceFactoryTagging.java

@@ -29,7 +29,7 @@ final class UserServiceFactoryTagging implements UserServiceFactory {
    *
    * @param retrofit the base Retrofit instance to derive user-specific instances from
    */
-  public UserServiceFactoryTagging(Retrofit retrofit) {
+  UserServiceFactoryTagging(Retrofit retrofit) {
     this.retrofit = retrofit;
   }
 

src/main/java/io/getstream/chat/java/services/framework/UserToken.java

@@ -1,17 +1,13 @@
 package io.getstream.chat.java.services.framework;
 
-public final class UserToken {
+final class UserToken {
   private final String value;
 
-  public UserToken(String value) {
+  UserToken(String value) {
     this.value = value;
   }
 
-  public String value() {
+  String value() {
     return value;
   }
-
-  public boolean isBlank() {
-    return value == null || value.isBlank();
-  }
 }

src/main/java/io/getstream/chat/java/services/framework/internal/TokenInjectionException.java

@@ -6,7 +6,7 @@
  * - A service method doesn't return retrofit2.Call<?>
  * - Retrofit's internal structure changes and reflection fails
  */
-public class TokenInjectionException extends Exception {
+public class TokenInjectionException extends ReflectiveOperationException {
   public TokenInjectionException(String message) {
     super(message);
   }