Activity界面路由的一种简单实现-六虎

1. 引言

平常Android开发中，发动Activity对错常常见的操作，而翻开一个新Activity能够直接运用Intent，也能够每个Activity供给一个静态的发动办法。可是有些时分运用这些办法并不那么方便，比如：一个应用内的网页需求翻开一个原生Activity页面时。这种情况下，网页的调用代码可能是app.openPage("/testPage")这样，或者是用app.openPage("local://myapp.com/loginPage")这样的办法，咱们需求用一种办法把途径和页面相关起来。Android能够答应咱们在Manifest文件中装备<data>标签来到达相似作用，也能够运用ARouter结构来完结这样的功能。本文就用200行左右的代码完结一个相似ARouter的简易界面路由。

2. 示例

2.1 初始化

这个操作主张放在Application的onCreate办法中，在第一次调用Router来翻开页面之前。

public class AppContext extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Router.init(this);
    }
}

2.2 发动无参数Activity

这是最简略的情况，只需求供给一个途径，适合“关于咱们”、“隐私协议”这种简略无参数页面。

Activity装备：

@Router.Path("/testPage")
public class TestActivity extends Activity {
    //......
}

发动代码：

Router.from(mActivity).toPath("/testPage").start();
//或
Router.from(mActivity).to("local://my.app/testPage").start();

2.3 发动带参数Activity

这是比较常见的情况，需求在注解中声明需求的参数称号，这些参数都是必要参数，假如发动的时分没有供给对应参数，则宣布异常。

Activity装备：

@Router.Path(value = "/testPage",args = {"id", "type"})
public class TestActivity extends Activity {
        @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //加载布局...
        String id = getIntent().getStringExtra("id"); //获取参数
        int type = getIntent().getIntExtra("type", 0);//获取参数
    }
}

发动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

2.4 发动带有静态发动办法的Activity

有一些Activity需求通过它供给的静态办法发动，就能够运用Path中的method特点和Entry注解来声明进口，能够供给参数。在供给了method特点时，需求用Entry的args来声明参数。

Activity装备：

@Router.Path(value = "/testPage", method = "open")
public class TestActivity extends Activity {
    @Router.Entry(args = {"id", "type"})
    public static void open(Activity activity, Bundle args) {
        Intent intent = new Intent(activity, NestWebActivity.class);
        intent.putExtras(args);
        activity.startActivity(intent);
    }
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //加载布局...
        String id = getIntent().getStringExtra("id"); //获取参数
        int type = getIntent().getIntExtra("type", 0);//获取参数
    }
}

发动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

3. API介绍

3.1 Path注解

这个注解只能用于Activity的子类，表明这个Activity需求页面路由的功能。这个类有三个特点：

value：表明这个Activity的相对途径。
args：表明这个Activity需求的参数，都是必要参数，假如翻开页面时缺少指定参数，就会宣布异常。
method：假如这个Activity需求静态办法做为进口，就将这个特点指定为办法名，并给对应办法增加Entry注解。（留意：这个特点值不为空时，忽略这个注解中的args特点内容）

3.1 Entry注解

这个注解只能用于Activity的静态办法，表明这个办法作为翻开Activity的进口。仅包括一个特点：

args：表明这个办法需求的参数。

3.2 Router.init办法

办法签名：public static void init(Context context)
办法阐明：这个办法用于初始化页面路由表，必须在第一次用Router翻开页面之前完结初始化。主张在Application的onCreate办法中完结初始化。

3.3 Rouater.from办法

办法签名：public static Router from(Activity activity)
办法阐明：这个办法用于创建Router实例，传入的参数一般为当前Activity。例如，要从AActivity翻开BActivity，那么传入参数为AActivity的实例。

3.4 Rouater.to和Rouater.toPath办法

办法签名：

public RouterBuilder to(String urlString)

public RouterBuilder toPath(String path)

办法阐明：这个办法用于指定方针的途径，to需求执行绝对途径，而toPath需求指定相对途径。回来的RouterBuilder用于接收翻开页面需求的参数。

3.4 RouterBuilder.with办法

办法签名：

public RouterBuilder with(String key, String value)

public RouterBuilder with(String key, int value)

办法阐明：这个办法用于增加参数，对应Bundle的各个put办法。现在只要常用的String和int两个类型。如有需求可自行在RouterBuilder中增加对应的办法。

3.4 RouterBuilder.start办法

办法签名：public void start()
办法阐明：这个办法用于翻开页面。假如存在途径错误、参数错误等异常情况，会宣布对应运行时异常。

4. 完结

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import androidx.annotation.Keep;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
@Keep
public class Router {
    public static final String SCHEME = "local";
    public static final String HOST = "my.app";
    public static final String URL_PREFIX = SCHEME + "://" + HOST;
    private static final Map<String, ActivityStarter> activityPathMap = new ConcurrentHashMap<>();
    public static void init(Context context) {
        try {
            PackageManager packageManager = context.getPackageManager();
            PackageInfo packageInfo = packageManager.getPackageInfo(
                    context.getPackageName(), PackageManager.GET_ACTIVITIES);
            for (ActivityInfo activityInfo : packageInfo.activities) {
                Class<?> aClass = Class.forName(activityInfo.name);
                Path annotation = aClass.getAnnotation(Path.class);
                if (annotation != null && !TextUtils.isEmpty(annotation.value())) {
                    activityPathMap.put(annotation.value(), (Activity activity, Bundle bundle) -> {
                        if (TextUtils.isEmpty(annotation.method())) {
                            for (String arg : annotation.args()) {
                                if (!bundle.containsKey(arg)) {
                                    throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));
                                }
                            }
                            Intent intent = new Intent(activity, aClass);
                            intent.putExtras(bundle);
                            activity.startActivity(intent);
                        } else {
                            try {
                                Method method = aClass.getMethod(annotation.method(), Activity.class, Bundle.class);
                                Entry entry = method.getAnnotation(Entry.class);
                                if (entry != null) {
                                    for (String arg : entry.args()) {
                                        if (!bundle.containsKey(arg)) {
                                            throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));
                                        }
                                    }
                                    method.invoke(null, activity, bundle);
                                } else {
                                    throw new IllegalStateException("can not find a method with [Entry] annotation!");
                                }
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }
                    });
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public static Router from(Activity activity) {
        return new Router(activity);
    }
    private final Activity activity;
    private Router(Activity activity) {
        this.activity = activity;
    }
    public RouterBuilder to(String urlString) {
        if (TextUtils.isEmpty(urlString)) {
            return new ErrorRouter(new IllegalArgumentException("argument [urlString] must not be null"));
        } else {
            return to(Uri.parse(urlString));
        }
    }
    public RouterBuilder toPath(String path) {
        return to(Uri.parse(URL_PREFIX + path));
    }
    public RouterBuilder to(Uri uri) {
        try {
            if (SCHEME.equals(uri.getScheme())) {
                if (HOST.equals(uri.getHost())) {
                    String path = uri.getPath();//note: 二级途径暂不考虑
                    ActivityStarter starter = activityPathMap.get(path);
                    if (starter == null) {
                        throw new IllegalStateException(String.format("path [%s] is not support", path));
                    } else {
                        NormalRouter router = new NormalRouter(activity, starter);
                        for (String key : uri.getQueryParameterNames()) {
                            if (!TextUtils.isEmpty(key)) {
                                router.with(key, uri.getQueryParameter(key));
                            }
                        }
                        return router;
                    }
                } else {
                    throw new IllegalArgumentException(String.format("invalid host : %s", uri.getHost()));
                }
            } else {
                throw new IllegalArgumentException(String.format("invalid scheme : %s", uri.getScheme()));
            }
        } catch (RuntimeException e) {
            return new ErrorRouter(e);
        }
    }
    public static abstract class RouterBuilder {
        public abstract RouterBuilder with(String key, String value);
        public abstract RouterBuilder with(String key, int value);
        public abstract void start();
    }
    private static class ErrorRouter extends RouterBuilder {
        private final RuntimeException exception;
        private ErrorRouter(RuntimeException exception) {
            this.exception = exception;
        }
        @Override
        public RouterBuilder with(String key, String value) {
            return this;
        }
        @Override
        public RouterBuilder with(String key, int value) {
            return this;
        }
        @Override
        public void start() {
            throw exception;
        }
    }
    private static class NormalRouter extends RouterBuilder {
        final Activity activity;
        final Bundle bundle = new Bundle();
        final ActivityStarter starter;
        private NormalRouter(Activity activity, ActivityStarter starter) {
            this.activity = Objects.requireNonNull(activity);
            this.starter = Objects.requireNonNull(starter);
        }
        @Override
        public RouterBuilder with(String key, String value) {
            bundle.putString(key, value);
            return this;
        }
        @Override
        public RouterBuilder with(String key, int value) {
            bundle.putInt(key, value);
            return this;
        }
        @Override
        public void start() {
            starter.start(activity, bundle);
        }
    }
    @FunctionalInterface
    private interface ActivityStarter {
        void start(Activity activity, Bundle bundle);
    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Path {
        String value();
        String method() default "";
        String[] args() default {};
    }
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Entry {
        String[] args() default {};
    }
}

5. 留意

这个东西的一些功能与ARouter相似，实际项目中主张运用ARouter。假如有特殊需求，例如，页面参数的查看或定制详细翻开行为，能够考虑基于这个东西进行修正。
运用了Path的method特点时留意增加对应的混淆设置，避免因混淆而导致找不到对应办法。

Activity界面路由的一种简单实现

1. 引言

2. 示例

2.1 初始化

2.2 发动无参数Activity

2.3 发动带参数Activity

2.4 发动带有静态发动办法的Activity

3. API介绍

3.1 Path注解

3.1 Entry注解

3.2 Router.init办法

3.3 Rouater.from办法

3.4 Rouater.to和Rouater.toPath办法

3.4 RouterBuilder.with办法

3.4 RouterBuilder.start办法

4. 完结

5. 留意

相关文章

都什么年代了，还在用传统方式写代码？

Ikigai: 享受生命的意义

Swift 5.9 新特性—C++互操作性

tensorflow 1.x 实战教程(十一)—模型的保存与恢复

作者信息