refactor(DeepLinking): Add support for multi module projects

Author: Hussein Aladeen

extra/gradle/libraries.gradle

@@ -30,6 +30,8 @@ ext {
     mockitoVersion = '1.10.19'
 
     javaPoetVersion = '1.8.0'
+    autoCommon = '0.8'
+    autoService = '1.0-rc3'
 
 
     libraries = [
@@ -39,7 +41,10 @@ ext {
 
             rxJava       : "io.reactivex.rxjava2:rxjava:${rxJavaVersion}",
             rxAndroid    : "io.reactivex.rxjava2:rxandroid:${rxAndroidVersion}",
-            javaPoet     : "com.squareup:javapoet:${javaPoetVersion}"
+            javaPoet     : "com.squareup:javapoet:${javaPoetVersion}",
+
+            autoCommon   : "com.google.auto:auto-common:${autoCommon}",
+            autoService  : "com.google.auto.service:auto-service:${autoService}"
     ]
 
     testLibraries = [

flowr-annotations/src/main/java/com/fueled/flowr/annotations/DeepLinkHandler.java

@@ -0,0 +1,15 @@
+package com.fueled.flowr.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Created by [email protected] on 05/06/2017.
+ * Copyright (c) 2017 Fueled. All rights reserved.
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+public @interface DeepLinkHandler {
+}

flowr-compiler/build.gradle

@@ -7,7 +7,11 @@ version = libraryVersion
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile project(path: ':flowr-annotations')
+
     compile libraries.javaPoet
+    compile libraries.autoCommon
+    compile libraries.autoService
+
     testCompile testLibraries.hamcrest
     testCompile testLibraries.junit
     testCompile testLibraries.mockito

flowr-compiler/src/main/java/com/fueled/flowr/compilers/DeepLinkAnnotationCompiler.java

@@ -15,7 +15,7 @@ public class DeepLinkAnnotationCompilerTest {
 
     private static final String TEST_PACKAGE = "com.fueled.flowr.sample";
 
-    DeepLinkAnnotationCompiler compiler;
+    private DeepLinkAnnotationCompiler compiler;
 
     @Before
     public void setup() {
@@ -27,39 +27,4 @@ public void process() throws Exception {
 
     }
 
-    @Test
-    public void generateCanonicalNameOneFragmentTest() throws Exception {
-        List<String> fragmentList = new ArrayList<>();
-        fragmentList.add("com.fueled.flowr.sample.DemoFragment");
-        String handlerPackage = compiler.generateCanonicalName(fragmentList);
-        assertEquals(handlerPackage, TEST_PACKAGE);
-    }
-
-    @Test
-    public void generateCanonicalNameTwoFragmentSamePackageTest() throws Exception {
-        List<String> fragmentList = new ArrayList<>();
-        fragmentList.add(TEST_PACKAGE + ".DemoFragment");
-        fragmentList.add(TEST_PACKAGE + ".TestFragment");
-        String handlerPackage = compiler.generateCanonicalName(fragmentList);
-        assertEquals(handlerPackage, TEST_PACKAGE);
-    }
-
-    @Test
-    public void generateCanonicalNameTwoFragmentDifferentPackageTest() throws Exception {
-        List<String> fragmentList = new ArrayList<>();
-        fragmentList.add(TEST_PACKAGE + ".demo.DemoFragment");
-        fragmentList.add(TEST_PACKAGE + ".TestFragment");
-        String handlerPackage = compiler.generateCanonicalName(fragmentList);
-        assertEquals(handlerPackage, TEST_PACKAGE);
-    }
-
-    @Test
-    public void generateCanonicalNameTwoFragmentDifferentPackage2Test() throws Exception {
-        List<String> fragmentList = new ArrayList<>();
-        fragmentList.add(TEST_PACKAGE + ".demo.DemoFragment");
-        fragmentList.add(TEST_PACKAGE + ".test.TestFragment");
-        String handlerPackage = compiler.generateCanonicalName(fragmentList);
-        assertEquals(handlerPackage, TEST_PACKAGE);
-    }
-
 }

flowr-compiler/src/main/resources/META-INF/services/javax.annotation.processing.Processor

@@ -13,14 +13,13 @@
 import android.util.Log;
 import android.view.View;
 
-import com.fueled.flowr.internal.FlowrConfig;
 import com.fueled.flowr.internal.FlowrDeepLinkHandler;
 import com.fueled.flowr.internal.FlowrDeepLinkInfo;
 import com.fueled.flowr.internal.TransactionData;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Created by [email protected] on 31/05/2016.
@@ -29,23 +28,30 @@
 public class Flowr implements FragmentManager.OnBackStackChangedListener,
         View.OnClickListener {
 
-    public final static String DEEP_LINK_URL = "DEEP_LINK_URL";//to be used as Bundle key for deep links.
-    public final static String FLOWR_CONFIG = "com.fueled.flowr.FlowrConfigImpl"; //Generated file that contain the path to the DeepLinkHandler class.
+    /**
+     * To be used as Bundle key for deep links.
+     */
+    public final static String DEEP_LINK_URL = "DEEP_LINK_URL";
 
     private final static String KEY_REQUEST_BUNDLE = "KEY_REQUEST_BUNDLE";
     private final static String KEY_FRAGMENT_ID = "KEY_FRAGMENT_ID";
     private final static String KEY_REQUEST_CODE = "KEY_REQUEST_CODE";
+
     private final static String TAG = Flowr.class.getSimpleName();
+
     private final FragmentsResultPublisher resultPublisher;
     private final int mainContainerId;
+
     private FlowrScreen screen;
     private ToolbarHandler toolbarHandler;
     private DrawerHandler drawerHandler;
+
     private Fragment currentFragment;
+
     private boolean overrideBack;
     private String tagPrefix;
 
-    private FlowrDeepLinkHandler deepLinkHandler;
+    private List<FlowrDeepLinkHandler> deepLinkHandlers;
 
 
     /**
@@ -117,6 +123,8 @@ public Flowr(@IdRes int mainContainerId, FlowrScreen screen, ToolbarHandler tool
         setToolbarHandler(toolbarHandler);
         setDrawerHandler(drawerHandler);
 
+        deepLinkHandlers = new ArrayList<>();
+
         syncScreenState();
     }
 
@@ -146,16 +154,6 @@ public static ResultResponse getResultsResponse(Bundle arguments, int resultCode
         return resultResponse;
     }
 
-    private Constructor<? extends FlowrDeepLinkHandler> findBindingConstructorForClass() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
-        //Use reflexion because:
-        //1. The FlowrDeepLinkHandlerImpl location is dynamic based on the location of all the Fragment that support deep link, so we can't rely on a static position like Dagger.
-        //2. Because the FlowrDeepLinkHandlerImpl is generated only when a @DeepLink is used, if the project doesn't use deep linking, the class will never be generated and the project won't compile
-        FlowrConfig config = (FlowrConfig) getClass().getClassLoader().loadClass(FLOWR_CONFIG).getConstructor().newInstance();
-        Class<?> bindingClass = getClass().getClassLoader().loadClass(config.getHandlerPackage());
-        //noinspection unchecked
-        return (Constructor<? extends FlowrDeepLinkHandler>) bindingClass.getConstructor();
-    }
-
 
     /**
      * Returns the {@link FlowrScreen} used for this router.
@@ -221,6 +219,20 @@ public void setDrawerHandler(DrawerHandler drawerHandler) {
         this.drawerHandler = drawerHandler;
     }
 
+    /**
+     * Specify a collection of {@link FlowrDeepLinkHandler} to be used when routing deep link
+     * intents replacing all previously set handlers.
+     *
+     * @param handlers the collection of handlers to be used.
+     */
+    public void setDeepLinkHandlers(FlowrDeepLinkHandler... handlers) {
+        this.deepLinkHandlers.clear();
+
+        if (handlers != null) {
+            Collections.addAll(deepLinkHandlers, handlers);
+        }
+    }
+
     /**
      * Returns the prefix used for the backstack fragments tag
      *
@@ -277,18 +289,20 @@ protected <T extends Fragment & FlowrFragment> void displayFragment(TransactionD
     }
 
     /**
-     * Parse the intent set by {@link TransactionData#deepLinkIntent} and if this intent contains Deep Link info, update the {@link #currentFragment} and the Transaction data.
+     * Parse the intent set by {@link TransactionData#deepLinkIntent} and if this intent contains
+     * Deep Link info, update the {@link #currentFragment} and the Transaction data.
      *
-     * @param data The Transaction data to extend if Deep link info are found in the {@link TransactionData#deepLinkIntent}.
+     * @param data The Transaction data to extend if Deep link info are found in
+     *             the {@link TransactionData#deepLinkIntent}.
      * @param <T>  The generic type for a valid Fragment.
      */
     @SuppressWarnings("unchecked")
     private <T extends Fragment & FlowrFragment> void injectDeepLinkInfo(TransactionData<T> data) {
         Intent deepLinkIntent = data.getDeepLinkIntent();
         if (deepLinkIntent != null) {
-            deepLinkHandler = getDeepLinkHandler();
-            if (deepLinkHandler != null) {
-                FlowrDeepLinkInfo info = deepLinkHandler.routeIntentToScreen(deepLinkIntent);
+            for (FlowrDeepLinkHandler handler : deepLinkHandlers) {
+                FlowrDeepLinkInfo info = handler.getDeepLinkInfoForIntent(deepLinkIntent);
+
                 if (info != null) {
                     data.setFragmentClass(info.fragment);
                     Bundle dataArgs = data.getArgs();
@@ -297,6 +311,8 @@ private <T extends Fragment & FlowrFragment> void injectDeepLinkInfo(Transaction
                     } else {
                         data.setArgs(info.data);
                     }
+
+                    break;
                 }
             }
         }
@@ -604,25 +620,6 @@ public void onDestroy() {
         setDrawerHandler(null);
     }
 
-    /**
-     * return the {@link FlowrDeepLinkHandler} if already initialized or initialize one.
-     *
-     * @return Initialized {@link FlowrDeepLinkHandler}
-     */
-    public FlowrDeepLinkHandler getDeepLinkHandler() {
-        try {
-            if (deepLinkHandler == null) {
-                Constructor<? extends FlowrDeepLinkHandler> deepLinkCtor = findBindingConstructorForClass();
-                if (deepLinkCtor != null) {
-                    deepLinkHandler = deepLinkCtor.newInstance();
-                }
-            }
-        } catch (Exception e) {
-            Log.e(TAG, "Error retrieving DeeplinkHandler", e);
-        }
-        return deepLinkHandler;
-    }
-
     /**
      * This builder class is used to show a new fragment inside the current activity
      */
@@ -691,7 +688,8 @@ public Builder replaceCurrentFragment(boolean replaceCurrentFragment) {
          * @param exitAnim  the fragment exit animation.
          */
         public Builder setCustomTransactionAnimation(@AnimRes int enterAnim, @AnimRes int exitAnim) {
-            return setCustomTransactionAnimation(enterAnim, FragmentTransaction.TRANSIT_NONE, FragmentTransaction.TRANSIT_NONE, exitAnim);
+            return setCustomTransactionAnimation(enterAnim, FragmentTransaction.TRANSIT_NONE,
+                    FragmentTransaction.TRANSIT_NONE, exitAnim);
         }
 
 
@@ -703,8 +701,8 @@ public Builder setCustomTransactionAnimation(@AnimRes int enterAnim, @AnimRes in
          * @param popEnterAnim The animation resource to be used when the previous fragment enters on back pressed.
          * @param popExitAnim  The animation resource to be used when the current fragment exits on back pressed..
          */
-        public Builder setCustomTransactionAnimation(@AnimRes int enterAnim,
-                                                     @AnimRes int exitAnim, @AnimRes int popEnterAnim, @AnimRes int popExitAnim) {
+        public Builder setCustomTransactionAnimation(@AnimRes int enterAnim, @AnimRes int exitAnim,
+                                                     @AnimRes int popEnterAnim, @AnimRes int popExitAnim) {
             data.setEnterAnim(enterAnim);
             data.setExitAnim(exitAnim);
             data.setPopEnterAnim(popEnterAnim);

flowr-compiler/src/test/java/com/fueled/flowr/compilers/DeepLinkAnnotationCompilerTest.java

@@ -0,0 +1,115 @@
+package com.fueled.flowr.internal;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+
+import com.fueled.flowr.Flowr;
+import com.fueled.flowr.FlowrFragment;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Created by [email protected] on 04/06/2017.
+ * Copyright (c) 2017 Hussein Ala. All rights reserved.
+ */
+public class AbstractFlowrDeepLinkHandler<T extends Fragment & FlowrFragment>
+        implements FlowrDeepLinkHandler {
+
+    private static final String NAMED_PARAM_REGEX = "\\(\\?<([a-zA-Z][a-zA-Z0-9]*)>";
+    private static final Pattern NAMED_PARAM_PATTERN = Pattern.compile(NAMED_PARAM_REGEX);
+
+    private final Map<String, Class<? extends T>> linkFragmentMap;
+
+    public AbstractFlowrDeepLinkHandler() {
+        linkFragmentMap = new HashMap<>();
+    }
+
+    /**
+     * Add a new link between a specific URL pattern and a specific fragment class.
+     *
+     * @param url      the URL pattern to link the fragment class to.
+     * @param fragment the fragment class to be linked to the URL pattern.
+     */
+    protected void addFragment(String url, Class<? extends T> fragment) {
+        linkFragmentMap.put(url, fragment);
+    }
+
+    /**
+     * Generates a bundle of the url named path variables and parameters.
+     *
+     * @param uri     the url to generate the bundle from.
+     * @param pattern the pattern to extract named path variables with.
+     * @return a bundle containing all path variables and parameters as strings.
+     */
+    @Nullable
+    private static Bundle bundleUriInfo(Uri uri, String pattern) {
+        String regex = getRegexPattern(pattern);
+        String path = uri.getPath();
+        Matcher m = Pattern.compile(regex).matcher(path);
+
+        if (m.matches()) {
+            Bundle data = new Bundle();
+            data.putString(Flowr.DEEP_LINK_URL, uri.toString());
+            Iterator<String> params = getNamedGroupCandidates(regex).iterator();
+
+            //start at 1 because 0 is the searched string
+            int i = 1;
+            while (params.hasNext()) {
+                String bip = params.next();
+                data.putString(bip, m.group(i));
+                i++;
+            }
+
+            return data;
+        }
+
+        return null;
+    }
+
+    private static String getRegexPattern(String pattern) {
+        return pattern.replaceAll("\\{(.+?)\\}", "(?<$1>\\.+?)");
+    }
+
+    private static List<String> getNamedGroupCandidates(String regex) {
+        List<String> namedGroups = new ArrayList<>();
+
+        Matcher m = NAMED_PARAM_PATTERN.matcher(regex);
+
+        while (m.find()) {
+            String test = m.group(1);
+            namedGroups.add(test);
+        }
+
+        return namedGroups;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    @Nullable
+    public FlowrDeepLinkInfo getDeepLinkInfoForIntent(@NonNull Intent intent) {
+        Uri uri = intent.getData();
+
+        if (uri != null) {
+            for (String uriPattern : linkFragmentMap.keySet()) {
+                Bundle data = bundleUriInfo(uri, uriPattern);
+                if (data != null) {
+                    return new FlowrDeepLinkInfo<>(data, linkFragmentMap.get(uriPattern));
+                }
+            }
+        }
+
+        return null;
+    }
+
+}