组件化后不同模块之间Activity的跳转
组件化后，只有主工程模块依赖其他业务模块，而各个业务模块之间没有互相依赖关系。一个模块可以调用被依赖模块的类和方法，而被依赖的模块不能引用依赖模块的类（依赖只能单向传递）。所以，单个业务模块无法调用主模块和其他业务模块的类和方法，那么业务间Activity的跳转就需要使用隐式跳转：
- 直接跳转包名：
startActivity(new Intent(“com.example.boost”)) - 使用manifest中的action、category、data进行隐式跳转：
startActivity(new Intent(Intent.ACTION_VIEW, Uri.prase("xxxx"))) - 利用反射
以上这些方法，虽然都能实现不同模块间的Activity跳转。但是，隐式跳转容易被非法应用劫持，反射最大的弊端在于代码结构发生变化后，就需要修改相应的反射路径。
目前比较推荐的方法就是使用一套统一的路由框架，所有的业务模块、主模块都依赖于这个路由模块，路由模块中包含所有Activity的引用，这样，每个模块都可以互相调用不同的模块的Activity。
路由框架
搭建路由模块
路由模块需要包含所有Activity类的引用，并能进行跳转，所有需要建立一个Android Library。
[图片上传失败...(image-5ab90b-1571132614922)]
Route路由类的设计：
- Route类作为路由需要在每个模块中可以直接调用，那最方便的方法就是使用单例模式
- Route中要包含所有Activity的引用，那么就需要使用一个map将Activity和对应的名称关联起来
- 在使用路由进行页面跳转的时候需要有一个方法，方法要传入待跳转的Activity的名称和需要的参数
- Route需要一个方法，将Activity的引用和对应的名称传入路由中
具体的代码如下：
package com.example.route;
import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import dalvik.system.DexFile;
/**
* @Description: 路由
* @Author: jiazhu
* @Date: 2019-09-19 09:29
* @ClassName: Route
*/
public class Route {
private static Route route = new Route();
private Context mContext;
private Map<String, Class<? extends Activity>> activityList;
private Route() {
activityList = new HashMap<>();
}
public static Route getInstance() {
return route;
}
public void init(Application application) {
mContext = application;
List<String> classNames = getClassName("com.example.util");
for (String s : classNames) {
try {
Class<?> aClass = Class.forName(s);
if (IRoute.class.isAssignableFrom(aClass)) {
IRoute iRoute = (IRoute) aClass.newInstance();
iRoute.putActivity();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
private List<String> getClassName(String packageName) {
ArrayList<String> classList = new ArrayList<>();
String path = null;
try {
path = mContext.getPackageManager().getApplicationInfo(mContext.getPackageName(), 0).sourceDir;
DexFile dexFile = new DexFile(path);
Enumeration<String> entries = dexFile.entries();
while (entries.hasMoreElements()) {
String name = entries.nextElement();
if (name.contains(packageName)) {
classList.add(name);
}
}
return classList;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public void putActivity(String path, Class<? extends Activity> clazz) {
if (TextUtils.isEmpty(path)) {
return;
}
if (clazz == null) {
return;
}
activityList.put(path, clazz);
}
public void jumpActivity(String path, Bundle bundle) {
Class<? extends Activity> aClass = activityList.get(path);
if (aClass == null) {
return;
}
Intent intent = new Intent().setClass(mContext, aClass);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
if (bundle != null) {
intent.putExtra("bundle", bundle);
}
mContext.startActivity(intent);
}
}
对于init方法，在整个应用启动的时候需要被调用，这样可以获取Application作为以后跳转的context上下文；除此之外，还需要将每一个模块中的Activity获取到，传入Route中。
Route中有一个putActivity()的方法，这个方法可以将Activity的引用和名称传入Route中，那么在每一个模块中如何才能调用这个方法，将本模块的Activity传递给Route呢？
使用APT（注解处理工具）将每一个模块的Activity传入Route路由
APT全名：Annotation Processiong Tool。
使用APT需要有两个部分组成，一个是注解，另一个是处理注解。
1. 注解
这里不需要Android相关的内容，所有新建一个Java Library：
新建一个Java Library
这个模块中只需要创建注解类。
一个注解类主要有以下几个部分构成：
-
@Target()指定这个注解是针对哪类数据进行注解：TYPE：类；FIELD：元素；METHOD：方法；PARAMETER：参数... -
@Retention()指定这个注解的生效阶段：SOURCE：在源码阶段有效；CLASS：在编译期有效；RUNTIME：在运行时有效 -
@interface xxx{}注解类名称 - 注解的方法
针对路由框架，实现的注解如下：
/**
* @author jiazhu
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface BindPath {
String value();
}
可以看出：
- 这个注解类是针对类进行注解的
- 注解在编译期有效
- 注解BindPath中有一个方法：value()，这个方法获取一个String类型值
BindPath获取的值作为Activity的名称，Activity的引用可以在后面通过注解处理器进行获取。
2.处理注解
处理注解也是不需要Android相关的内容，所有新建一个Java Library。
做一个注解处理器的类，需要集成AbstractProcessor注解处理器抽象类。
在处理注解之前，需要实现三个方法：
-
初始化这个注解处理器，并拿到一个创建文件的对象：
@Override public synchronized void init(ProcessingEnvironment processingEnvironment) { super.init(processingEnvironment); mFiler = processingEnvironment.getFiler(); } -
配置需要处理的注解类
@Override public Set<String> getSupportedAnnotationTypes() { Set<String> types = new HashSet<>(); types.add(BindPath.class.getCanonicalName()); return types; } -
设置支持的代码版本
@Override public SourceVersion getSupportedSourceVersion() { return processingEnv.getSourceVersion(); }
然后需要重写父类的process方法，实现注解的处理。处理的步骤如下：
- 获取需要处理的被注解标注的对象，并获取对象的注解
- 将对象的名称和注解方法返回的值提取出来（对象名称就是Activity，注解方法的返回值就是Activity的名称）
- 通过Filer创建每个模块对应的添加路由的类，并用Writer写入刚才通过注解获取的Activity和名称。
最终代码如下：
/**
* @author jiazhu
*/
@AutoService(Processor.class)
public class AnnotationCompiler extends AbstractProcessor {
Filer mFiler;
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
mFiler = processingEnvironment.getFiler();
}
@Override
public Set<String> getSupportedAnnotationTypes() {
Set<String> types = new HashSet<>();
types.add(BindPath.class.getCanonicalName());
return types;
}
@Override
public SourceVersion getSupportedSourceVersion() {
return processingEnv.getSourceVersion();
}
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindPath.class);
HashMap<String, String> map = new HashMap<>();
String packageName = null;
for (Element element : elements) {
if (element instanceof TypeElement) {
TypeElement typeElement = (TypeElement) element;
BindPath annotation = typeElement.getAnnotation(BindPath.class);
String path = annotation.value();
String activityName = typeElement.getQualifiedName().toString();
if (packageName == null) {
packageName = activityName.substring(0, activityName.lastIndexOf("."));
packageName = packageName.replace('.', '_');
}
map.put(path, activityName);
}
}
if (map.size() > 0) {
Writer writer = null;
String utilName = "ActivityUtil_" + packageName;
try {
JavaFileObject javaFileObject = mFiler.createSourceFile("com.example.util." + utilName);
writer = javaFileObject.openWriter();
Iterator<String> iterator = map.keySet().iterator();
writer.write("package com.example.util;\n" +
"\n" +
"import com.example.route.IRoute;\n" +
"import com.example.route.Route;\n" +
"\n" +
"public class " + utilName + " implements IRoute {\n" +
" @Override\n" +
" public void putActivity() {\n");
while (iterator.hasNext()) {
String path = iterator.next();
String value = map.get(path);
writer.write("Route.getInstance().putActivity(\"" + path + "\"," + value + ".class);\n");
}
writer.write(" }\n" +
"}\n");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
return false;
}
}
通过注解，将各个模块的Activity添加注解，然后对代码进行一次编译。
在每一个模块生成的代码中会多出来一个类，这个类会将这个模块中的所有已注解的Activity和它们的名称传入Route类中。
跳转某个模块的Activity
当我们跳转某个模块的Activity的时候，只需要如下代码：
Route.getInstance().jumpActivity( "mapp/main", null);
