Separate EventBus Android artifact

.github/workflows/gradle.yml

@@ -0,0 +1,42 @@
+# This workflow will build a Java project with Gradle
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Java CI with Gradle
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'adopt'
+      - name: Cache Gradle packages
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Gradle Info
+        run: ./gradlew -version
+      - name: Build with Gradle
+        run: ./gradlew build
+      - name: Cleanup Gradle Cache
+        # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
+        # Restoring these files from a GitHub Actions cache might cause problems for future builds.
+        run: |
+          rm -f ~/.gradle/caches/modules-2/modules-2.lock
+          rm -f ~/.gradle/caches/modules-2/gc.properties

EventBus/build.gradle

@@ -1,16 +1,9 @@
 apply plugin: 'java'
 
-archivesBaseName = 'eventbus'
 group = 'org.greenrobot'
-version = '3.2.0'
-sourceCompatibility = 1.7
-
-dependencies {
-    compileOnly 'com.google.android:android:4.1.1.4'
-    compileOnly 'com.google.android:android-test:4.1.1.4'
-    compileOnly 'com.google.android:annotations:4.1.1.4'
-    compileOnly 'com.google.android:support-v4:r7'
-}
+version = '3.3.0-SNAPSHOT'
+java.sourceCompatibility = JavaVersion.VERSION_1_8
+java.targetCompatibility = JavaVersion.VERSION_1_8
 
 sourceSets {
     main {
@@ -21,39 +14,37 @@ sourceSets {
     }
 }
 
-apply from: rootProject.file("gradle/publish.gradle")
-
 javadoc {
     failOnError = false
     title = "EventBus ${version} API"
 	options.bottom = 'Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2012-2020 <a href="https://greenrobot.org">greenrobot.org</a>. All Rights Reserved.</i>'
 }
 
 task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
+    archiveClassifier.set("javadoc")
     from 'build/docs/javadoc'
 }
 
 task sourcesJar(type: Jar) {
+    archiveClassifier.set("sources")
     from sourceSets.main.allSource
-    classifier = 'sources'
 }
 
-artifacts {
-    archives jar
-    archives javadocJar
-    archives sourcesJar
-}
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Common setup is defined in publish.gradle.
-
-            pom.project {
-               name 'EventBus'
-               description 'EventBus is a publish/subscribe event bus optimized for Android.'
-           }
+apply from: rootProject.file("gradle/publish.gradle")
+// Set project-specific properties
+afterEvaluate {
+    publishing.publications {
+        mavenJava(MavenPublication) {
+            artifactId = "eventbus-java"
+
+            from components.java
+            artifact javadocJar
+            artifact sourcesJar
+            pom {
+                name = "EventBus"
+                description = "EventBus is a publish/subscribe event bus."
+                packaging = "jar"
+            }
         }
     }
 }

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

@@ -15,6 +15,7 @@
  */
 package org.greenrobot.eventbus;
 
+import org.greenrobot.eventbus.android.AndroidDependenciesDetector;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -139,6 +140,12 @@ public EventBus() {
      * ThreadMode} and priority.
      */
     public void register(Object subscriber) {
+        if (AndroidDependenciesDetector.isAndroidSDKAvailable() && !AndroidDependenciesDetector.areAndroidComponentsAvailable()) {
+            // Crash if the user (developer) has not imported the Android compatibility library.
+            throw new RuntimeException("It looks like you are using EventBus on Android, " +
+                    "make sure to add the \"eventbus\" Android library to your dependencies.");
+        }
+
         Class<?> subscriberClass = subscriber.getClass();
         List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
         synchronized (this) {

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

@@ -15,11 +15,8 @@
  */
 package org.greenrobot.eventbus;
 
-import android.os.Looper;
-
-import org.greenrobot.eventbus.android.AndroidLogger;
+import org.greenrobot.eventbus.android.AndroidComponents;
 import org.greenrobot.eventbus.meta.SubscriberInfoIndex;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
@@ -146,8 +143,7 @@ public EventBusBuilder addIndex(SubscriberInfoIndex index) {
     /**
      * Set a specific log handler for all EventBus logging.
      * <p/>
-     * By default all logging is via {@link android.util.Log} but if you want to use EventBus
-     * outside the Android environment then you will need to provide another log target.
+     * By default, all logging is via {@code android.util.Log} on Android or System.out on JVM.
      */
     public EventBusBuilder logger(Logger logger) {
         this.logger = logger;
@@ -165,24 +161,13 @@ Logger getLogger() {
     MainThreadSupport getMainThreadSupport() {
         if (mainThreadSupport != null) {
             return mainThreadSupport;
-        } else if (AndroidLogger.isAndroidLogAvailable()) {
-            Object looperOrNull = getAndroidMainLooperOrNull();
-            return looperOrNull == null ? null :
-                    new MainThreadSupport.AndroidHandlerMainThreadSupport((Looper) looperOrNull);
+        } else if (AndroidComponents.areAvailable()) {
+            return AndroidComponents.get().defaultMainThreadSupport;
         } else {
             return null;
         }
     }
 
-    static Object getAndroidMainLooperOrNull() {
-        try {
-            return Looper.getMainLooper();
-        } catch (RuntimeException e) {
-            // Not really a functional Android (e.g. "Stub!" maven dependencies)
-            return null;
-        }
-    }
-
     /**
      * Installs the default EventBus returned by {@link EventBus#getDefault()} using this builders' values. Must be
      * done only once before the first usage of the default EventBus.

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

@@ -15,9 +15,7 @@
  */
 package org.greenrobot.eventbus;
 
-import android.os.Looper;
-import org.greenrobot.eventbus.android.AndroidLogger;
-
+import org.greenrobot.eventbus.android.AndroidComponents;
 import java.util.logging.Level;
 
 public interface Logger {
@@ -64,19 +62,11 @@ public void log(Level level, String msg, Throwable th) {
 
     class Default {
         public static Logger get() {
-            // also check main looper to see if we have "good" Android classes (not Stubs etc.)
-            return AndroidLogger.isAndroidLogAvailable() && getAndroidMainLooperOrNull() != null
-                    ? new AndroidLogger("EventBus") :
-                    new Logger.SystemOutLogger();
-        }
-
-        static Object getAndroidMainLooperOrNull() {
-            try {
-                return Looper.getMainLooper();
-            } catch (RuntimeException e) {
-                // Not really a functional Android (e.g. "Stub!" maven dependencies)
-                return null;
+            if (AndroidComponents.areAvailable()) {
+                return AndroidComponents.get().logger;
             }
+
+            return new SystemOutLogger();
         }
     }
 

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

@@ -15,8 +15,6 @@
  */
 package org.greenrobot.eventbus;
 
-import android.os.Looper;
-
 /**
  * Interface to the "main" thread, which can be whatever you like. Typically on Android, Android's main thread is used.
  */
@@ -25,24 +23,4 @@ public interface MainThreadSupport {
     boolean isMainThread();
 
     Poster createPoster(EventBus eventBus);
-
-    class AndroidHandlerMainThreadSupport implements MainThreadSupport {
-
-        private final Looper looper;
-
-        public AndroidHandlerMainThreadSupport(Looper looper) {
-            this.looper = looper;
-        }
-
-        @Override
-        public boolean isMainThread() {
-            return looper == Looper.myLooper();
-        }
-
-        @Override
-        public Poster createPoster(EventBus eventBus) {
-            return new HandlerPoster(eventBus, looper, 10);
-        }
-    }
-
 }

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

@@ -20,7 +20,7 @@
  *
  * @author William Ferguson
  */
-interface Poster {
+public interface Poster {
 
     /**
      * Enqueue an event to be posted for a particular subscription.

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

@@ -0,0 +1,48 @@
+package org.greenrobot.eventbus.android;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+@SuppressWarnings("TryWithIdenticalCatches")
+public class AndroidDependenciesDetector {
+
+    public static boolean isAndroidSDKAvailable() {
+
+        try {
+            Class<?> looperClass = Class.forName("android.os.Looper");
+            Method getMainLooper = looperClass.getDeclaredMethod("getMainLooper");
+            Object mainLooper = getMainLooper.invoke(null);
+            return mainLooper != null;
+        }
+        catch (ClassNotFoundException ignored) {}
+        catch (NoSuchMethodException ignored) {}
+        catch (IllegalAccessException ignored) {}
+        catch (InvocationTargetException ignored) {}
+
+        return false;
+    }
+
+    private static final String ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME = "org.greenrobot.eventbus.android.AndroidComponentsImpl";
+
+    public static boolean areAndroidComponentsAvailable() {
+
+        try {
+            Class.forName(ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME);
+            return true;
+        }
+        catch (ClassNotFoundException ex) {
+            return false;
+        }
+    }
+
+    public static AndroidComponents instantiateAndroidComponents() {
+
+        try {
+            Class<?> impl = Class.forName(ANDROID_COMPONENTS_IMPLEMENTATION_CLASS_NAME);
+            return (AndroidComponents) impl.getConstructor().newInstance();
+        }
+        catch (Throwable ex) {
+            return null;
+        }
+    }
+}