// 文件名：gradle.properties
// 组件独立调试开关, 每次更改值后要同步工程
isAPK = false

// 文件：Root Project 的 build.gradle 文件
buildscript {
    Properties properties = new Properties()
    // 加载 local.properties 文件
    properties.load(project.rootProject.file('local.properties').newDataInputStream())
    // 读取 isAPK 属性，ext 为 Root Project 的 ext
    ext.isAPK = properties.get("isAPK") == "true"
}

// 文件名：业务组件的 build.gradle
// 注意 gradle.properties 中的数据类型都是 String 类型，使用其他数据类型需要自行转换
if (isAPK.toBoolean()){
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}
// 如果变量定义在 local.properties 中，则需要使用 rootProject.isAPK 进行判断
// if (rootProject.isAPK){
//     apply plugin: 'com.android.application'
// } else {
//     apply plugin: 'com.android.library'
// }

// 文件名：业务组件的 build.gradle
android {
    defaultConfig {
        // 使用 applicationId 
        if (isAPK.toBoolean()) {
            // 单独编译时添加 applicationId
            applicationId "com.example.xxx"
        }
    }

    sourceSets {
        main {
            // 单独编译时使用不同的清单文件
            if (isAPK.toBoolean()) {
                manifest.srcFile 'src/main/apk/AndroidManifest.xml'
            } else {
                manifest.srcFile 'src/main/module/AndroidManifest.xml'
            }
        }
    }
}

// apk/AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.xxx" >
    <application android:name=".XXXApplication"
        android:allowBackup="true"
        android:label="XXX"
        android:theme="@style/Theme.AppCompat">
        <activity android:name=".XXXMainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

// module/AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.xxx">
    <application>
        <activity android:name=".XXXActivity"></activity>
    </application>
</manifest>

# 文件名：maven_info.properties
# 用户名
user=android
# 密码
password=android123
# release 仓库地址
url.release=url:port/nexus/content/repositories/android-release/
# dev 仓库地址
url.dev=url:port/nexus/content/repositories/android-dev/
# POM 的名称，给用户提供的更为友好的项目名
# POM 全称是Project Object Model，即项目对象模型，它是 Maven 中工作的基本组成单位
pom.name=android
# 项目描述，在 maven 文档中保存
pom.description=example chat lib
# 项目组的编号，这在组织或项目中通常是独一无二的。
# 例如，一家银行集团 com.company.bank 拥有所有银行相关项目。
pom.groupId=com.example.test
# 项目的 ID。这通常是项目的名称
pom.artifactId=lib-chat
# 项目打包方式
pom.packaging=aar

# RELEASE 版本号
pom.version.release=1.0.0
# DEV 版本号
pom.version.dev=1.0.0-Dev
# 是否上传 dev 版本
isDev=false

// 文件名：maven_upload.gradle
// 使用 maven 插件
apply plugin: 'maven'

// 读取配置文件 maven_info.properties
Properties properties = new Properties()
properties.load(project.rootProject.file('maven_info.properties').newDataInputStream())
def userName = properties.getProperty("user")
def userPassword = properties.getProperty("password")
def releaseUrl = properties.getProperty("url.release")
def devUrl = properties.getProperty("url.dev")
def isDev = properties.getProperty("isDev").toBoolean()
def pomName = properties.getProperty("pom.name")
def pomDescription = properties.getProperty("pom.description")
def pomGroupId = properties.getProperty("pom.groupId")
def pomArtifactId = properties.getProperty("pom.artifactId")
def pomPackaging = properties.getProperty("pom.packaging")
def pomVersionRelease = properties.getProperty("pom.version.release")
def pomVersionDev = properties.getProperty("pom.version.dev")

def repoUrl
def pomVersion

// uploadArchives 是一个 task
uploadArchives {
    if(isDev) {
        repoUrl = devUrl
        pomVersion = pomVersionDev
    } else {
        repoUrl = releaseUrl
        pomVersion = pomVersionRelease
    }
    // maven 部署器
    repositories.mavenDeployer {
        // 指定用户名，密码
        repository(url: repoUrl) {
            authentication(userName: userName, password: userPassword)
        }
        // 调用 gradle 的 uploadArchives 的 task 就可以上传了
        // 对这部分感兴趣的可以搜索下 pom.xml
        pom.project {
            name pomName
            description pomDescription
            url repoUrl
            groupId pomGroupId
            artifactId pomArtifactId
            version pomVersion
            packaging pomPackaging
        }
    }
}

// library 的 build.gradle 文件
if (isAPK.toBoolean()) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}
// 引用本地的 gradle 文件
apply from: "${rootDir}/maven_upload.gradle"

// 文件名：config.gradle
ext{
    // 用户名
    user="android"
    // 密码
    password="android123"
    // release 仓库地址
    url.release="url:port/nexus/content/repositories/android-release/"
    // dev 仓库地址
    url.dev="url:port/nexus/content/repositories/android-dev/"
    // POM 的名称，给用户提供的更为友好的项目名
    // POM 全称是Project Object Model，即项目对象模型，它是 Maven 中工作的基本组成单位
    pom.name="android"
    // 项目描述，在 maven 文档中保存
    pom.description="example chat lib"
    // 项目组的编号，这在组织或项目中通常是独一无二的。
    // 例如，一家银行集团 com.company.bank 拥有所有银行相关项目。
    pom.groupId="com.example.test"
    // 项目的 ID。这通常是项目的名称
    pom.artifactId="lib-chat"
    // 项目打包方式
    pom.packaging="aar"
    
    // RELEASE 版本号
    pom.version.release="1.0.0"
    // DEV 版本号
    pom.version.dev="1.0.0-Dev"
    // 是否上传 dev 版本
    isDev=false
}

// 文件名：maven_upload.gradle
// 使用 maven 插件
apply plugin: 'maven'
apply from: "${rootDir}/config.gradle"

def repoUrl
def pomVersion

// uploadArchives 是一个 task
uploadArchives {
    if(isDev) {
        repoUrl = url_dev
        pomVersion = pom_version_dev
    } else {
        repoUrl = url_release
        pomVersion = pom_version_release
    }
    // maven 部署器
    repositories.mavenDeployer {
        // 指定用户名，密码
        if(isDev) {
            // Dev 作为快照版本
            snapshotRepository(url: repoUrl) {
                authentication(userName: user, password: password)
            }
        } else {
            // 非 Dev 作为正式版本
            repository(url: repoUrl) {
                authentication(userName: user, password: password)
            }
        }
        // 调用 gradle 的 uploadArchives 的 task 就可以上传了
        // 对这部分感兴趣的可以搜索下 pom.xml
        pom.project {
            name pom_name
            description pom_description
            url repoUrl
            groupId pom_groupId
            artifactId pom_artifactId
            version pomVersion
            packaging pom_packaging
        }
    }
}

// library 的 build.gradle 文件
if (isAPK.toBoolean()) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}
// 引用本地的 gradle 文件
apply from: "${rootDir}/maven_upload.gradle"

// 文件名：maven_upload.gradle
// 代码是固定模版

// 打包注释，生成 javadoc.jar
// 使用 .sourceFiles 时，gradle 筛选了 .java 类型的文件进行打包
// 而使用 .getSrcDirs() 把整个目录作为参数时，gradle 不再排查文件后缀，把所有目录下所有文件都打包进来了。
task androidJavadocsJar(type: Jar, dependsOn: Javadoc) {
    // classifier = 'javadoc'
    // from android.sourceSets.main.java.sourceFiles
    // 指定文档名称
    archiveClassifier.set('javadoc')
    from android.sourceSets.main.java.getSrcDirs()
}
// 打包源码，生成 sources.jar
task androidSourcesJar(type: Jar) {
    // classifier = 'sources'
    // from android.sourceSets.main.java.sourceFiles
    archiveClassifier.set('sources')
    from android.sourceSets.main.java.getSrcDirs()
}
// 处理 Maven 需要上传的包
artifacts {
    if (isDev) {
        archives androidSourcesJar
        archives androidJavadocsJar
    }
}

// 文件名：maven_upload.gradle
task cleanDir(type:Delete) {
    delete buildDir
}

// 上传后，执行清除任务
uploadArchives.mustRunAfter 'cleanDir'

allprojects {
    repositories {
        google()
        jcenter()
        //私有 maven 仓库地址
        maven {
            url 'http://xxx'
        }
    }
}

dependencies {
    implementation 'com.example.test:xxx:xxx'
    // ......
}

// common 组件的 build.gradle 文件
android {
    defaultConfig {
        javaCompileOptions.annotationProcessorOptions {
            arguments = [AROUTER_MODULE_NAME: getProject().getName()]
        }
    }
}

dependencies {
    // 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    implementation 'com.alibaba:arouter-api:1.5.1'
    annotationProcessor 'com.alibaba:arouter-compiler:1.5.1'
}

public class TestApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        // 这两行必须写在 init 之前，否则这些配置在 init 过程中将无效
        if (BuildConfig.DEBUG) {
            // 打印日志
            ARouter.openLog();
            // 开启调试模式。如果在 InstantRun 模式下运行，必须开启调试模式！
            // 而线上版本需要关闭,否则有安全风险
            ARouter.openDebug();
        }
        // 尽可能早，推荐在 Application 中初始化
        ARouter.init(this);
    }
}

// 1. 在 Activity/Fragment 类上面定义路由
@Route(path = "/app/activity_main")
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 2. 在 Activity/Fragment 类里面进入 Arouter 注入
        ARouter.getInstance().inject(this);
        findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 3. 构建路由，进行跳转
                ARouter.getInstance().build("/app/activity_second").navigation();
            }
        });
    }
}

ARouter.getInstance()
    .build("/app/activity_second")
    .withString("name", "zhang") //携带参数 1
    .withInt("age", 3) //携带参数 2
    .navigation();

@Route(path = "/app/activity_second")
public class SecondActivity extends AppCompatActivity {
    @Autowired
    private String name;
    @Autowired(name = "age")
    private int age;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        ARouter.getInstance().inject(this);
    }
}

ARouter.getInstance().build(path)
    .navigation(context, new NavigationCallback() {
        @Override
        public void onFound(Postcard postcard) {
            // 找到了要打开的 activity
        }

        @Override
        public void onLost(Postcard postcard) {
            // 找不到要打开的 activity
        }

        @Override
        public void onArrival(Postcard postcard) {
            // 已经打开了目标activity
        }

        @Override
        public void onInterrupt(Postcard postcard) {
            // 跳转请求被拦截了
        }
    });

ARouter.getInstance().build("app/activity_second")
    .withTransition(enterAnimId, exitAnimId)
    .navigation();

// 文件名：LoginApi.java
// 启动登录页
public static void startLoginPage(Activity activity) {
  // 具体实现省略
}

// 文件名：LoginApi.api
public class LoginApi {
    public static void startLoginPage(Context context) {
        // 实现省略
    }
}

// 同步任务(Sync)继承自复制任务(Copy)，当它执行时，它会复制源文件到目标目录中，然后从目标目录中的删除所有非复制的文件
task copyApiToJava(type: Sync) {
    // 第 1 步，获取所有子模块
    Set<Project> projects = project.subprojects
    if(projects == null || projects.size() <= 0) {
        return
    }
    // 第 2 步，获取 common 模块
    // 注：project 的 path 是在 name 前加上 :，表示相对路径
    Project comProject = project.rootProject.findProject(":common")
    // 拷贝所有组件的接口到 common 组件中
    projects.each {
        from "${rootDir}/${it.name}/src/main/java/com/xxx/xxx/api"
        into "${rootDir}/${comProject.name}/src/main/java/com/xxx/xxx/api/${it.name}"
        //排除所有的.java文件
        exclude '**/*.java'
        //包括所有的.api文件
        include '**/*.api'
        rename { String fileName ->
            fileName.replace(".api", ".java")
        }
    }
}

//在preBuild之前，必须先运行 copyApiToJava
preBuild.dependsOn copyApiToJava

// 通知
public class NotifyRequest {
    // 代码省略
}

// 通知响应
public class NotifyResponse {
    // 代码省略
}

// 通知方
public interface NotifyParty {
    // 收到被通知方的通知响应
    void onReceivedResponse(NotifyResponse response);
}

// 被通知方
public interface NotifiedParty {
    // 收到通知
    void onReceivedNotify(NotifyRequest notify);
}

// 通知管理器
public class NotifyManager {
    // 发送通知
    public boolean sendNotify(NotifyRequest notify) {
        boolean isSendSuccess = false;
        // 通过通信总线发送通知
        return isSendSuccess;
    }
    // 发送通知响应
    public boolean sendResponse(NotifyResponse response) {
        boolean isSendSuccess = false;
        // 通过通信总线发送通知响应
        return isSendSuccess;
    }
}

// 通信总线
public class NotifyBus {
    // 下发通知
    public boolean dispatchNotify(NotifyRequest notify) {
        boolean isSendSuccess = false;
        // 通过通信总线发送通知
        return isSendSuccess;
    }
    // 下发通知响应
    public boolean dispatchResponse(NotifyResponse response) {
        boolean isSendSuccess = false;
        // 通过通信总线发送通知响应
        return isSendSuccess;
    }
}

// 该接口表示组件的执行流程
public interface IModuleTask {
    // 第 1 步：建立组件依赖
    void dependency();
    // 第 2 步：配置组件
    void configure();
    // 第 3 步：组件执行
    void execute();
}

// 所有组件默认依赖于根组件
public class RootModule extends Module {
    @Override
    public void dependency() { }
    @Override
    public void configure() { }
    @Override
    public void execute() { }
}

// 所有组件的父类
public abstract class Module implements IModuleTask {
    // 当前的生命周期状态
    private ModuleLifecycle lifecycle;

    @Override
    public void dependency() {
        dependOn(RootModule.class);
    }

    public void dependOn(Class<? extends Module> clsParent) {
        ModuleManager.dependOn(clsParent, getClass());
    }

    public ModuleLifecycle getLifecycle() {
        return lifecycle;
    }
    public Module setLifecycle(ModuleLifecycle lifecycle) {
        this.lifecycle = lifecycle;
        return this;
    }
}

// 组件的生命周期
public enum ModuleLifecycle {
    // 组件已注册
    REGISTERED,
    // 组件已配置
    CONFIGURED,
    // 组件已执行
    EXECUTED
}

// A 组件依赖于 B 组件和 Root 组件
public class AModule extends Module {
    @Override
    public void dependency() {
        super.dependency();
        dependOn(BModule.class);
    }
    @Override
    public void configure() { }
    @Override
    public void execute() { }
}

// B 组件依赖于 C 组件和 Root 组件
public class BModule extends Module {
    @Override
    public void dependency() {
        super.dependency();
        dependOn(CModule.class);
    }
    @Override
    public void configure() { }
    @Override
    public void execute() { }
}

// C 组件依赖于 Root 组件
public class CModule extends Module {
    @Override
    public void dependency() {
        super.dependency();
    }
    @Override
    public void configure() { }
    @Override
    public void execute() { }
}

// D 组件依赖于 B 组件和 Root 组件
public class DModule extends Module {
    @Override
    public void dependency() {
        super.dependency();
        dependOn(BModule.class);
    }
    @Override
    public void configure() { }
    @Override
    public void execute() { }
}

// 组件管理器
public class ModuleManager {
    // key 是被依赖的组件(A)，value 是依赖于 A 的组件
    private static LinkedHashMap<Class<? extends Module>, Dependency> dependencies = new LinkedHashMap<>();
    // 当前已注册的组件的实例缓存
    private static LinkedHashMap<Class<? extends Module>, Module> modules = new LinkedHashMap<>();
    // 组件初始化
    public static void init() {
        // 1. 注册组件
        registerModules();
        // 2. 构建 Root 组件节点
        Dependency rootDependency = new Dependency();
        rootDependency.father = RootModule.class;
        rootDependency.children = new LinkedHashSet<>();
        dependencies.put(rootDependency.father, rootDependency);
        // 3. 遍历组件，生成依赖关系
        for(Module module: modules.values()) {
            module.dependency();
        }
        // 4. 深度遍历，配置组件
        deepTraverse(rootDependency, new Task() {
            @Override
            public void doTask(Module module) {
                // 已配置过了
                if(module.getLifecycle() == ModuleLifecycle.CONFIGURED) {
                    return;
                }
                // 配置组件，并更新组件的生命周期状态
                module.configure();
                module.setLifecycle(ModuleLifecycle.CONFIGURED);
            }
        });
        // 4. 深度遍历，组件执行
        deepTraverse(rootDependency, new Task() {
            @Override
            public void doTask(Module module) {
                // 已执行过了
                if(module.getLifecycle() == ModuleLifecycle.EXECUTED) {
                    return;
                }
                // 组件执行，并更新组件的生命周期状态
                module.execute();
                module.setLifecycle(ModuleLifecycle.EXECUTED);
            }
        });
    }
    // 注册组件
    private static void registerModules() {
        registerModule(AModule.class);
        registerModule(BModule.class);
        registerModule(CModule.class);
        registerModule(DModule.class);
        registerModule(RootModule.class);
    }
    // 注册单个组件
    private static void registerModule(Class<? extends Module> cls) {
        Module component = modules.get(cls);
        if (component != null) {
            return;
        }
        try {
            Module module = cls.newInstance();
            module.setLifecycle(ModuleLifecycle.REGISTERED);
            modules.put(cls, module);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 添加依赖关系
    static void dependOn(Class<? extends Module> clsFather, Class<? extends Module> clsChild) {
        Dependency existDependency = findDependency(clsFather);
        if (existDependency != null) {
            existDependency.children.add(clsChild);
            return;
        }

        existDependency = new Dependency();
        existDependency.father = clsFather;
        existDependency.children = new LinkedHashSet<>();
        existDependency.children.add(clsChild);
        dependencies.put(existDependency.father, existDependency);
    }

    private static Dependency findDependency(Class<?> clsFather) {
        if (clsFather == null) {
            return null;
        }
        return dependencies.get(clsFather);
    }

    private static void deepTraverse(Dependency root, Task task) {
        if (root == null) {
            return;
        }
        // 执行被依赖项 A
        Module module = modules.get(root.father);
        task.doTask(module);
        // 执行依赖于 A 的组件
        for (Class<? extends Module> child : root.children) {
            Dependency dependency = findDependency(child);
            // 无依赖项，说明深度遍历到底了
            if (dependency == null) {
                // 调用 子组件的方法
                module = modules.get(child);
                task.doTask(module);
            } else {
                // 有依赖项，继续递归的去深度遍历
                deepTraverse(dependency, task);
            }
        }
    }

    // 依赖关系封装类
    private static class Dependency {
        // 被依赖的组件
        Class<? extends Module> father;
        // 依赖于 father 组件的组件列表
        LinkedHashSet<Class<? extends Module>> children;
    }
    // 初始化过程中需要执行的任务
    private interface Task {
        void doTask(Module module);
    }
}

defaultConfig {
    consumerProguardFiles 'consumer-rules.pro'
}

buildTypes {
    release {
        minifyEnabled false
        // 存在多个混淆文件
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

// A 组件的混淆配置
android {
    defaultConfig {
        // A 组件的混淆配置是 proguard-rules.pro
        consumerProguardFiles 'proguard-rules.pro'
    }
}

// B 组件的混淆配置
android {
    defaultConfig {
        consumerProguardFiles 'proguard-rules.pro', proguard-second.pro
    }
}

// app 组件的混淆配置
android {
    defaultConfig {
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-system.pro', 'proguard-second.pro', 'proguard-third.pro'
    }
}