Merge branch 'develop' into 'master'

Develop

See merge request !4

Author: Stan Wijckmans

mvvm/build.gradle

@@ -8,8 +8,8 @@ android {
     defaultConfig {
         minSdkVersion 16
         targetSdkVersion 25
-        versionCode 1
-        versionName "1.0.0.0"
+        versionCode 4
+        versionName "1.0.3"
     }
 
     dataBinding {
@@ -18,7 +18,7 @@ android {
 }
 
 dependencies {
-    compile 'com.android.support:appcompat-v7:25.1.1'
+    compile 'com.android.support:appcompat-v7:25.2.0'
     compile 'com.google.dagger:dagger:2.9'
 }
 
@@ -43,7 +43,7 @@ publishing {
         maven(MavenPublication) {
             groupId 'be.stannieman'
             artifactId 'mvvm'
-            version '1.0.0.0'
+            version '1.0.3'
             artifact "$buildDir\\outputs\\aar\\signed-${project.getName()}-release.aar"
             artifact createJavaDocJar
             artifact createSourcesJar
@@ -66,4 +66,4 @@ publishing {
             url "$buildDir\\repo"
         }
     }
-}
+}

mvvm/src/main/java/stannieman/mvvm/helpers/MainThreadHelper.java

@@ -3,12 +3,15 @@
 import android.os.Handler;
 import android.os.Looper;
 
+import javax.inject.Inject;
+
 /**
  * Class to run a runnable on the main thread.
  */
 public final class MainThreadHelper implements IMainThreadHelper {
     private final Handler mainThreadHandler;
 
+    @Inject
     public MainThreadHelper() {
         mainThreadHandler = new Handler(Looper.getMainLooper());
     }

mvvm/src/main/java/stannieman/mvvm/messaging/IHandle.java

@@ -2,11 +2,13 @@
 
 /**
  * Defines a class that can receive messages.
+ * @param <T> type of the message to receive
  */
-public interface IHandle {
+
+public interface IHandle<T> {
     /**
      * Handles a published message.
      * @param message published message
      */
-    void Handle(Object message);
+    void Handle(T message);
 }

mvvm/src/main/java/stannieman/mvvm/messaging/IMessenger.java

@@ -7,21 +7,23 @@
 public interface IMessenger {
     /**
      * Subscribes a handler to the messenger.
-     * The subscribed handler will receive all published messages.
+     * The subscribed handler will receive all published messages
+     * for which it has IHandle<T> implemented where T is the type of the message.
      * @param subscriber handler to subscribe
      */
-    void subScribe(IHandle subscriber);
+    void subscribe(Object subscriber);
 
     /**
-     * Unsuibscribes a handler from the messenger.
+     * Unsubscribes a handler from the messenger.
      * The handler will no longer receive any messages.
      * @param subscriber handler to unsubscribe
      */
-    void unSubscribe(IHandle subscriber);
+    void unsubscribe(Object subscriber);
 
     /**
-     * Publishes a message to all subscribed handlers.
+     * Publishes a message to all subscribed handlers that can receive this type of message.
      * @param message message to publish
+     * @param <T> Type of the message to send.
      */
-    void publish(Object message);
+    <T> void publish(T message);
 }

mvvm/src/main/java/stannieman/mvvm/messaging/Messenger.java

@@ -1,7 +1,10 @@
 package stannieman.mvvm.messaging;
 
-import java.util.HashSet;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Map;
 import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
@@ -17,32 +20,38 @@ public final class Messenger implements IMessenger {
     private final IMainThreadHelper mainThreadHelper;
 
     private final Lock subscribersLock = new ReentrantLock();
-    private final Set<IHandle> subscribers = new HashSet<>();
+    private final Map<Object, Object> subscribers;
 
+    /**
+     * Constructor that takes an IMainTreadHelper.
+     * @param mainThreadHelper helper to invoke message handlers on the main thread.
+     */
     @Inject
     public Messenger(final IMainThreadHelper mainThreadHelper) {
         this.mainThreadHelper = mainThreadHelper;
+        subscribers = new WeakHashMap<>();
     }
 
     /**
      * Subscribes a handler to the messenger.
-     * The subscribed handler will receive all published messages.
+     * The subscribed handler will receive all published messages
+     * for which it has IHandle<T> implemented where T is the type of the message.
      * @param subscriber handler to subscribe
      */
     @Override
-    public void subScribe(final IHandle subscriber) {
+    public void subscribe(final Object subscriber) {
         subscribersLock.lock();
-        subscribers.add(subscriber);
+        subscribers.put(subscriber, null);
         subscribersLock.unlock();
     }
 
     /**
-     * Unsuibscribes a handler from the messenger.
+     * Unsubscribes a handler from the messenger.
      * The handler will no longer receive any messages.
      * @param subscriber handler to unsubscribe
      */
     @Override
-    public void unSubscribe(final IHandle subscriber) {
+    public void unsubscribe(final Object subscriber) {
         subscribersLock.lock();
         subscribers.remove(subscriber);
         subscribersLock.unlock();
@@ -52,17 +61,28 @@ public void unSubscribe(final IHandle subscriber) {
      * Publishes a message to all subscribed handlers.
      * @param message message to publish
      */
+    @SuppressWarnings("unchecked")
     @Override
-    public void publish(final Object message) {
+    public <T> void publish(final T message) {
         subscribersLock.lock();
-        final Set<IHandle> copiedSubscribers = new HashSet<>(subscribers);
+        final Set<Object> copiedSubscribers = subscribers.keySet();
         subscribersLock.unlock();
 
         mainThreadHelper.postToMainThreadIfNeeded(new Runnable() {
             @Override
             public void run() {
-                for (IHandle subscriber : copiedSubscribers) {
-                    subscriber.Handle(message);
+                for (Object subscriber : copiedSubscribers) {
+                    Type[] genericInterfaces = subscriber.getClass().getGenericInterfaces();
+                    for (Type genericInterface : genericInterfaces) {
+                        if (genericInterface instanceof ParameterizedType) {
+                            Type[] genericTypes = ((ParameterizedType) genericInterface).getActualTypeArguments();
+                            for (Type type : genericTypes) {
+                                if (type == message.getClass()) {
+                                    ((IHandle<T>)subscriber).Handle(message);
+                                }
+                            }
+                        }
+                    }
                 }
             }
         });