refactorings

Author: andob

EventBus/src/org/greenrobot/eventbus/EventBus.java

@@ -141,7 +141,7 @@ public EventBus() {
      */
     public void register(Object subscriber) {
 
-        if (AndroidDependenciesDetector.isAndroidSDKAvailable() && !AndroidDependenciesDetector.isAndroidSDKProxyImplAvailable()) {
+        if (AndroidDependenciesDetector.isAndroidSDKAvailable() && !AndroidDependenciesDetector.areAndroidComponentsAvailable()) {
             //should crash user's app if the user (developer) has not imported the android compatibility library
             throw new RuntimeException("Looks like you are using the latest version of EventBus on Android " +
                 "without importing the EventBus for Android compatibility library. Please import it on app/build.gradle!");

EventBus/src/org/greenrobot/eventbus/EventBusBuilder.java

@@ -15,7 +15,7 @@
  */
 package org.greenrobot.eventbus;
 
-import org.greenrobot.eventbus.android.AndroidSDKProxy;
+import org.greenrobot.eventbus.android.AndroidComponents;
 import org.greenrobot.eventbus.meta.SubscriberInfoIndex;
 import java.util.ArrayList;
 import java.util.List;
@@ -162,8 +162,8 @@ Logger getLogger() {
     MainThreadSupport getMainThreadSupport() {
         if (mainThreadSupport != null) {
             return mainThreadSupport;
-        } else if (AndroidSDKProxy.isAvailable()) {
-            return AndroidSDKProxy.get().defaultMainThreadSupport;
+        } else if (AndroidComponents.areAvailable()) {
+            return AndroidComponents.get().defaultMainThreadSupport;
         } else {
             return null;
         }

EventBus/src/org/greenrobot/eventbus/Logger.java

@@ -15,8 +15,7 @@
  */
 package org.greenrobot.eventbus;
 
-import org.greenrobot.eventbus.android.AndroidLogger;
-import org.greenrobot.eventbus.android.AndroidSDKProxy;
+import org.greenrobot.eventbus.android.AndroidComponents;
 import java.util.logging.Level;
 
 public interface Logger {
@@ -63,8 +62,8 @@ public void log(Level level, String msg, Throwable th) {
 
     class Default {
         public static Logger get() {
-            if (AndroidSDKProxy.isAvailable()) {
-                return new AndroidLogger(AndroidSDKProxy.get(), "EventBus");
+            if (AndroidComponents.areAvailable()) {
+                return AndroidComponents.get().logger;
             }
 
             return new SystemOutLogger();

EventBus/src/org/greenrobot/eventbus/android/AndroidComponents.java

@@ -0,0 +1,31 @@
+package org.greenrobot.eventbus.android;
+
+import org.greenrobot.eventbus.Logger;
+import org.greenrobot.eventbus.MainThreadSupport;
+
+public abstract class AndroidComponents {
+
+    private static final AndroidComponents implementation;
+
+    static {
+        implementation = AndroidDependenciesDetector.isAndroidSDKAvailable()
+            ? AndroidDependenciesDetector.instantiateAndroidComponents()
+            : null;
+    }
+
+    public static boolean areAvailable() {
+        return implementation != null;
+    }
+
+    public static AndroidComponents get() {
+        return implementation;
+    }
+
+    public final Logger logger;
+    public final MainThreadSupport defaultMainThreadSupport;
+
+    public AndroidComponents(Logger logger, MainThreadSupport defaultMainThreadSupport) {
+        this.logger = logger;
+        this.defaultMainThreadSupport = defaultMainThreadSupport;
+    }
+}

EventBus/src/org/greenrobot/eventbus/android/AndroidDependenciesDetector.java

@@ -22,22 +22,24 @@ public static boolean isAndroidSDKAvailable() {
         return false;
     }
 
-    public static boolean isAndroidSDKProxyImplAvailable() {
+    private static final String ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME = "org.greenrobot.eventbus.android.AndroidComponentsImpl";
+
+    public static boolean areAndroidComponentsAvailable() {
 
         try {
-            Class.forName("org.greenrobot.eventbus.android.AndroidSDKProxyImpl");
+            Class.forName(ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME);
             return true;
         }
         catch (ClassNotFoundException ex) {
             return false;
         }
     }
 
-    public static AndroidSDKProxy instantiateAndroidSDKProxy() {
+    public static AndroidComponents instantiateAndroidComponents() {
 
         try {
-            Class<?> impl = Class.forName("org.greenrobot.eventbus.android.AndroidSDKProxyImpl");
-            return (AndroidSDKProxy) impl.getConstructor().newInstance();
+            Class<?> impl = Class.forName(ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME);
+            return (AndroidComponents) impl.getConstructor().newInstance();
         }
         catch (Throwable ex) {
             return null;

EventBus/src/org/greenrobot/eventbus/android/AndroidSDKProxy.java

@@ -0,0 +1,16 @@
+package org.greenrobot.eventbus;
+
+import org.greenrobot.eventbus.android.AndroidComponents;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class AndroidComponentsAvailabilityTest {
+
+    @Test
+    public void shouldBeAvailable() {
+        assertTrue(AndroidComponents.areAvailable());
+        assertNotNull(AndroidComponents.get());
+    }
+}

EventBusTest/src/org/greenrobot/eventbus/AndroidComponentsAvailabilityTest.java

@@ -0,0 +1,17 @@
+package org.greenrobot.eventbus;
+
+import org.greenrobot.eventbus.android.AndroidComponents;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+
+public class AndroidComponentsAvailabilityOnJavaTest
+{
+
+    @Test
+    public void shouldNotBeAvailable() {
+        assertFalse(AndroidComponents.areAvailable());
+        assertNull(AndroidComponents.get());
+    }
+}

EventBusTest/src/org/greenrobot/eventbus/AndroidSDKProxyTest.java

@@ -0,0 +1,8 @@
+package org.greenrobot.eventbus.android;
+
+public class AndroidComponentsImpl extends AndroidComponents {
+
+    public AndroidComponentsImpl() {
+        super(new AndroidLogger("EventBus"), new DefaultAndroidMainThreadSupport());
+    }
+}

EventBusTestJava/src/main/java/org/greenrobot/eventbus/AndroidComponentsAvailabilityOnJavaTest.java

@@ -15,47 +15,46 @@
  */
 package org.greenrobot.eventbus.android;
 
+import android.util.Log;
 import org.greenrobot.eventbus.Logger;
 import org.greenrobot.eventbus.util.ExceptionStackTraceUtils;
 import java.util.logging.Level;
 
 public class AndroidLogger implements Logger {
 
-    private final AndroidSDKProxy androidSDK;
     private final String tag;
 
-    public AndroidLogger(AndroidSDKProxy androidSDK, String tag) {
-        this.androidSDK = androidSDK;
+    public AndroidLogger(String tag) {
         this.tag = tag;
     }
 
     public void log(Level level, String msg) {
         if (level != Level.OFF) {
-            androidSDK.log.println(mapLevel(level), tag, msg);
+            Log.println(mapLevel(level), tag, msg);
         }
     }
 
     public void log(Level level, String msg, Throwable th) {
         if (level != Level.OFF) {
             // That's how Log does it internally
-            androidSDK.log.println(mapLevel(level), tag, msg + "\n" + ExceptionStackTraceUtils.getStackTraceAsString(th));
+            Log.println(mapLevel(level), tag, msg + "\n" + ExceptionStackTraceUtils.getStackTraceAsString(th));
         }
     }
 
     private int mapLevel(Level level) {
         int value = level.intValue();
         if (value < 800) { // below INFO
             if (value < 500) { // below FINE
-                return androidSDK.log.getVerboseLevelId();
+                return Log.VERBOSE;
             } else {
-                return androidSDK.log.getDebugLevelId();
+                return Log.DEBUG;
             }
         } else if (value < 900) { // below WARNING
-            return androidSDK.log.getInfoLevelId();
+            return Log.INFO;
         } else if (value < 1000) { // below ERROR
-            return androidSDK.log.getWarnLevelId();
+            return Log.WARN;
         } else {
-            return androidSDK.log.getErrorLevelId();
+            return Log.ERROR;
         }
     }
 }