前言

Application的onCareate初始化：

Matrix.Builder builder = new Matrix.Builder(this);
Matrix.init(builder.build());

Matrix实现：

public class Matrix {
    private static final String TAG = "Matrix.Matrix";

    /**
     * volatie 可见性、有序性。(不具有原子性)
     */
    private static volatile Matrix sInstance;
    /**
     * 插件集合，使用HashSet保证不重复出现
     */
    private final HashSet<Plugin> plugins;
    private final Application     application;

    /**
     * 私有构造，单例
     * @param app application
     * @param listener 插件监听
     * @param plugins 插件列表
     * @param config 配置
     */
    private Matrix(Application app, PluginListener listener, HashSet<Plugin> plugins, MatrixLifecycleConfig config) {
        this.application = app;
        this.plugins = plugins;
        // 声明周期感知，application,配置
        MatrixLifecycleOwnerInitializer.init(app, config);
        ProcessSupervisor.INSTANCE.init(app, config.getSupervisorConfig());
        // 逐个初始化插件
        for (Plugin plugin : plugins) {
            plugin.init(application, listener);
        }
    }

    /**
     * 自定义日志实现
     */
    public static void setLogIml(MatrixLog.MatrixLogImp imp) {
        MatrixLog.setMatrixLogImp(imp);
    }

    /**
     * 是否已经初始化过，单例
     */
    public static boolean isInstalled() {
        return sInstance != null;
    }
    
    /**
     * 初始化
     * @param matrix 不可为空
     * @return
     */
    public static Matrix init(@NonNull Matrix matrix) {
        if (matrix == null) {
            throw new RuntimeException("Matrix init, Matrix should not be null.");
        }
        // 解决volatile多线程并发原子性问题：synchronized保证sInstance执行的原子性。
        synchronized (Matrix.class) {
            if (sInstance == null) {
                sInstance = matrix;
            } else {
                MatrixLog.e(TAG, "Matrix instance is already set. this invoking will be ignored");
            }
        }
        return sInstance;
    }

    /**
     * 如果未初始化抛出异常
     * @return 单例
     */
    public static Matrix with() throws RuntimeException{
        if (sInstance == null) {
            throw new RuntimeException("you must init Matrix sdk first");
        }
        return sInstance;
    }

    /**
     * 启动所有插件
     */
    public void startAllPlugins() {
        for (Plugin plugin : plugins) {
            plugin.start();
        }
    }

    /**
     * 暂停所有插件
     */
    public void stopAllPlugins() {
        for (Plugin plugin : plugins) {
            plugin.stop();
        }
    }
    /**
     * 销毁所有插件
     */
    public void destroyAllPlugins() {
        for (Plugin plugin : plugins) {
            plugin.destroy();
        }
    }

    public Application getApplication() {
        return application;
    }

    public HashSet<Plugin> getPlugins() {
        return plugins;
    }

    /**
     * 根据tag获取插件
     */
    public Plugin getPluginByTag(String tag) {
        for (Plugin plugin : plugins) {
            if (plugin.getTag().equals(tag)) {
                return plugin;
            }
        }
        return null;
    }

    public <T extends Plugin> T getPluginByClass(Class<T> pluginClass) {
        String className = pluginClass.getName();
        for (Plugin plugin : plugins) {
            if (plugin.getClass().getName().equals(className)) {
                return (T) plugin;
            }
        }
        return null;
    }

    /**
     * Builder模式
     */
    public static class Builder {
        private final Application application;
        /**
         * 插件监听
         */

        private PluginListener   pluginListener;
        /**
         * 生命周期配置
         */
        private MatrixLifecycleConfig mLifecycleConfig = new MatrixLifecycleConfig(); // default config

//        private SupervisorConfig supervisorConfig;
//        private boolean          enableFgServiceMonitor;
//        private boolean          enableOverlayWindowMonitor;
        /**
         * 插件集合
         */
        private final HashSet<Plugin> plugins = new HashSet<>();

        /**
         * 
         * @param app 不能为空
         */
        public Builder(@NonNull Application app) throws RuntimeException{
            if (app == null) {
                throw new RuntimeException("matrix init, application is null");
            }
            this.application = app;
        }

        /**
         * 放入插件；插件不能重复放入(根据tag)
         */
        public Builder plugin(Plugin plugin) throws RuntimeException{
            String tag = plugin.getTag();
            for (Plugin exist : plugins) {
                if (tag.equals(exist.getTag())) {
                    throw new RuntimeException(String.format("plugin with tag %s is already exist", tag));
                }
            }
            plugins.add(plugin);
            return this;
        }

        public Builder pluginListener(PluginListener pluginListener) {
            this.pluginListener = pluginListener;
            return this;
        }

        public Builder matrixLifecycleConfig(MatrixLifecycleConfig config) {
            this.mLifecycleConfig = config;
            return this;
        }

        public Matrix build() {
            if (pluginListener == null) {
                pluginListener = new DefaultPluginListener(application);
            }
            return new Matrix(application, pluginListener, plugins, mLifecycleConfig);
        }

    }
}

Matrix主要是初始插件plugin、plugin监听、生命周期、配置等，使用单例实现(volatile synchronized解决并发问题)，其中使用Build模式来对pugin进行配置。

Plugin

public abstract class Plugin implements IPlugin, IssuePublisher.OnIssueDetectListener, IAppForeground {
    private static final String TAG = "Matrix.Plugin";

    /**
     * plugin的生命周期状态5个：create/inited/started/stoped/destroyed
     */
    public static final int PLUGIN_CREATE = 0x00;
    public static final int PLUGIN_INITED = 0x01;
    public static final int PLUGIN_STARTED = 0x02;
    public static final int PLUGIN_STOPPED = 0x04;
    public static final int PLUGIN_DESTROYED = 0x08;

    private PluginListener pluginListener;
    private Application application;

    private boolean isSupported = true;
    /**
     * 默认create状态
     */
    private int status = PLUGIN_CREATE;

    /**
     * 初始化Plugin
     * 更新当前状态为inited
     */
    @Override
    public void init(Application app, PluginListener listener) {
        if (application != null || pluginListener != null) {
            throw new RuntimeException("plugin duplicate init, application or plugin listener is not null");
        }
        status = PLUGIN_INITED;
        this.application = app;
        this.pluginListener = listener;
        listener.onInit(this);
        ProcessUILifecycleOwner.INSTANCE.addListener(this);
    }

    /**
     * 上报问题
     * @param issue 问题
     */
    @Override
    public void onDetectIssue(Issue issue) {
        if (issue.getTag() == null) {
            // set default tag
            issue.setTag(getTag());
        }
        issue.setPlugin(this);
        JSONObject content = issue.getContent();
        // add tag and type for default
        try {
            if (issue.getTag() != null) {
                content.put(Issue.ISSUE_REPORT_TAG, issue.getTag());
            }
            if (issue.getType() != 0) {
                content.put(Issue.ISSUE_REPORT_TYPE, issue.getType());
            }
            content.put(Issue.ISSUE_REPORT_PROCESS, MatrixUtil.getProcessName(application));
            content.put(Issue.ISSUE_REPORT_TIME, System.currentTimeMillis());

        } catch (JSONException e) {
            MatrixLog.e(TAG, "json error", e);
        }

        //MatrixLog.e(TAG, "detect issue:%s", issue);
        // 简单统一的数据上报方法
        pluginListener.onReportIssue(issue);
    }

    @Override
    public Application getApplication() {
        return application;
    }

    /**
     * 是否在前台
     */
    public boolean isForeground() {
        return ProcessUILifecycleOwner.INSTANCE.isProcessForeground();
    }
}

Plugin是抽象类，继承IPlugin接口(约束插件的共性接口)，是所有插件的父类。实现相同功能插件的能力来解耦。感知生命周期5种状态和App前后台状态。 TracePlugin:

public class TracePlugin extends Plugin {
/**
 * trace配置
 */
private final TraceConfig traceConfig;
/**
 * 慢函数监控
 */
private EvilMethodTracer evilMethodTracer;
/**
 * 启动监控
 */
private StartupTracer startupTracer;
/**
 * 帧率监控
 */
private FrameTracer frameTracer;
/**
 * ANR监控
 */
private LooperAnrTracer looperAnrTracer;
/**
 * 信号ANR监控
 */
private SignalAnrTracer signalAnrTracer;
/**
 * 卡顿监控
 */
private IdleHandlerLagTracer idleHandlerLagTracer;
/**
 * touch事件监控
 */
private TouchEventLagTracer touchEventLagTracer;
}
@Override
public void init(Application app, PluginListener listener) {
    super.init(app, listener);
    MatrixLog.i(TAG, "trace plugin init, trace config: %s", traceConfig.toString());
    // 小于API16则不支持TracePlugin
    if (sdkInt < Build.VERSION_CODES.JELLY_BEAN) {
        MatrixLog.e(TAG, "[FrameBeat] API is low Build.VERSION_CODES.JELLY_BEAN(16), TracePlugin is not supported");
        unSupportPlugin();
        return;
    }
    // anr检测
    looperAnrTracer = new LooperAnrTracer(traceConfig);
    // 帧率检测
    frameTracer = new FrameTracer(traceConfig);
    // 慢函数检测
    evilMethodTracer = new EvilMethodTracer(traceConfig);
    // 启动检测
    startupTracer = new StartupTracer(traceConfig);
}
}

TracePlugin在低于sdk16是不支持的。

1. 慢函数监控：EvilMethodTracer
2. 启动监控：StartupTracer
3. 帧率监控：FrameTracer
4. ANR监控：LooperAnrTracer
5. 信号量ANR监控：signalAnrTracer
6. 卡顿监控：IdleHandlerLagTracer
7. touch事件监控：touchEventLagTracer

总结

Matrix通过构造者模式构建，遍历plugins并执行plugin.init，Plugin子类会覆写init并初始化子任务，每个Plugin都有start和stop。