应用模板代码地址：https://github.com/thfhongfeng/AndroidAppTemplate

项目配置化介绍

项目配置化分两个方面：
项目构建配置
项目构建配置又分两块：
1. 通过gradle文件配置编译过程中的参数，主要包括编译打包参数配置和包依赖配置
2. 通过gradle文件配置应用中需要使用到的一些常量，主要包括基础url地址，第三方KEY和app第三方库提供者。其中app第三方库提供者的配置化使得我们可以根据需要来切换不同的外来库来实现相同的功能
业务功能配置
业务功能配置这是根据后台配置情况，给予不同的用户不同的功能访问权限。这是一个动态的配置。

项目配置化实现

项目配置化的实现主要在Config模块中

Config模块目录结构

同样分两个方面:

项目构建配置化

这个其实就是通过gradle的功能将编译过程中的参数集中起来管理。
这个只是gradle的一个简单的应用，就不在赘述。贴下示例代码

/**
 * 编译打包参数
 */
def build_versions = [:]
build_versions.compileSdkVersion = 28
……
……
ext.build_versions = build_versions

compileSdkVersion build_versions.compileSdkVersion

/**
 * app第三方SDK提供者
 */
def app_third_sdk_provider = [:]
// 路由提供者，默认使用arouter(目前可供选择项：arouter)
app_third_sdk_provider.router_provider = "arouter"
……
……
ext.app_third_sdk_provider = app_third_sdk_provider

buildConfigField "String", "APP_THIRD_ROUTER_PROVIDER", "\"${app_third_sdk_provider.router_provider}\""

业务功能配置

主要是ConfigSwitcherServer类

public class ConfigSwitcherServer {
    private static final String TAG = LogUtils.makeLogTag(ConfigSwitcherServer.class);

    private static volatile ConfigSwitcherServer mInstance;
    private ConfigSwitcherModel mConfigSwitcherModel = new ConfigSwitcherModel();

    private Map<String, Boolean> mGuestConfigStateMap = new HashMap();
    private Map<String, Boolean> mUserConfigStateMap = new HashMap();

    private volatile boolean mIsLogin;

    private ConfigSwitcherServer() {
        synchronized (mGuestConfigStateMap) {
            mGuestConfigStateMap.put(ConfigKey.BUNDLE_WELCOME_KEY, true);
            mGuestConfigStateMap.put(ConfigKey.BUNDLE_LOGIN_KEY, true);
            mGuestConfigStateMap.put(ConfigKey.BUNDLE_MAIN_KEY, true);
            mGuestConfigStateMap.put(ConfigKey.BUNDLE_USER_KEY, true);
            mGuestConfigStateMap.put(ConfigKey.BUNDLE_DB_SEVER_KEY, true);
        }

        synchronized (mUserConfigStateMap) {
            mUserConfigStateMap.putAll(mGuestConfigStateMap);
        }
    }

    public static ConfigSwitcherServer getInstance() {
        if (mInstance == null) {
            synchronized (ConfigSwitcherServer.class) {
                if (mInstance == null) {
                    mInstance = new ConfigSwitcherServer();
                }
            }
        }
        return mInstance;
    }

    public void setLogin(boolean isLogin) {
        mIsLogin = isLogin;
    }


    public void setEnable(String key, boolean enable) {
        if (mIsLogin) {
            synchronized (mUserConfigStateMap) {
                mUserConfigStateMap.put(key, enable);
            }
        } else {
            synchronized (mGuestConfigStateMap) {
                mGuestConfigStateMap.put(key, enable);
            }
        }
        LogUtils.releaseLog(TAG, "Set " + key + " fun " + (enable ? "open" : "close"));
    }

    public boolean isEnable(String key) {
        if (mIsLogin) {
            synchronized (mUserConfigStateMap) {
                return mUserConfigStateMap.containsKey(key) && mUserConfigStateMap.get(key);
            }
        } else {
            synchronized (mGuestConfigStateMap) {
                return mGuestConfigStateMap.containsKey(key) && mGuestConfigStateMap.get(key);
            }
        }
    }

    public void setConfig(List<ConfigSwitcherEntity> switcherEntityList) {
        if (mIsLogin) {
            synchronized (mUserConfigStateMap) {
                mUserConfigStateMap.clear();
                if (switcherEntityList != null && switcherEntityList.size() > 0) {
                    for (int i = 0; i < switcherEntityList.size(); i++) {
                        mUserConfigStateMap.put(switcherEntityList.get(i).getConfigKey(), switcherEntityList.get(i).getState() == 1);
                    }
                }
            }
        } else {
            synchronized (mGuestConfigStateMap) {
                mGuestConfigStateMap.clear();
                if (switcherEntityList != null && switcherEntityList.size() > 0) {
                    for (int i = 0; i < switcherEntityList.size(); i++) {
                        mGuestConfigStateMap.put(switcherEntityList.get(i).getConfigKey(), switcherEntityList.get(i).getState() == 1);
                    }
                }
            }
        }
    }

    public void setupConfigSwitcher(final IConfigSwitcherCallback callback) {
        mConfigSwitcherModel.requestBundleSwitcherData(new IModelAsyncResponse<ArrayList<ConfigSwitcherEntity>>() {
            @Override
            public void onResponse(ArrayList<ConfigSwitcherEntity> switcherEntities) {
                if (switcherEntities != null) {
                    setConfig(switcherEntities);
                }
                if (callback != null) {
                    callback.onSetupComplete();
                }
            }

            @Override
            public boolean onFail(Exception e) {
                if (callback != null) {
                    return callback.onSetupFail();
                }
                return false;
            }

            @Override
            public void onCancel() {
                if (callback != null) {
                    callback.onSetupFail();
                }
            }
        });
    }

    public interface IConfigSwitcherCallback {
        void onSetupComplete();

        boolean onSetupFail();
    }
}

业务功能配置这块也是比较简单的，就是预存一个基本配置，登陆后从后台拿配置保存起来。相关的功能使用的时候判断下该功能配置是否开启。