# module-cf-common

**Repository Path**: yangji/module-cf-common

## Basic Information

- **Project Name**: module-cf-common
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2019-11-22
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## <center>模块化使用步骤</center><br/>
### 一、模块化创建项目
##### 第一、创建项目

1. sunpeople-module-user 创建项目目录文件夹 
2. module-user 创建项目文件夹 

##### 第二、拷贝文件
* **build.gradle**
* **settings** 文件夹
* **settings.gradle**

##### 第四、通过以下任意一种实例化项目
1. 使用名称初始化项目
    * **gradle cW** 创建所有项目统一管理gradle版本
    * **gradle build** 初始化项目、并自动创建相关文件
    
2. 使用AndroidStudio 初始化项目
    * 直接使用 AndroidStudio 打开项目即可

-------
##### 第五、目录介绍

```
sunpeople-module-user
    -module-user
        -src
            -app 独立运行时使用环境（差异包）
                -java 独立运行时环境-java代码
                -res 独立运行时环境-资源文件
                -AndroidManifest.xml 独立运行时环境-配置文件
                
            -library 模块化环境使用（差异包）
                -java 模块化-java代码
                -res 模块化-资源文件
                -AndroidManifest.xml -模块化配置文件
                
            -main 项目文件
                -java  项目文件 java文件
                -res 项目文件 资源文件
                -AndroidManifest.xml 项目文件配置文件
                
        -build.gradle 项目 Gradle 管理

    settings 模块化组件    
    
    build.gradle root 项目 Gradle
    
    settings.gradle 项目配置

```
##### 第六、module-user 介绍
1. **build.gradle** 本文件自动生成

```groovy
ext {
    //是否是可运行APP；true 可运行；false 模块化库文件
    //注意如果是false 当前项目可发布到 maven；如果是 true 发布命令是没有的
    isApplication = false 
    
     //是否创建一个独立 可用的 Application
    isAddApplication = false
    
    //如果项目可运行 独立包名
    ext_packageName = 'com.cf.module.user' 
    
    //当前模块版本号
    ext_versionCode = 0010  
    
    //当前模块版本名（maven 发布版本）
    ext_versionName = '0.0.1' 
}
apply from: ext.path.module //引用模块化

def moduleVersion = ext.moduleVersion //其他模块库集合
def versions = ext.versions //第三方资源库集合

//依赖库
dependencies {

    //如果当前项目可运行 主题
    if (isApplication) {
        //可运行临时主题（主项目独立集成）maven 时不参与打包
        implementation moduleVersion.theme
    }
}

```

初始化网络框架，最后打包放入到 App 结合使用场景使用

```java
HttpManager
    .getInstance().registerProvider("USER", (HttpManager.ServiceProvider) s ->
        RetrofitService.RetrofitBeanBuilder.create().moduleName("USER")
                .baseUrl(
                    // SpCore 依赖 lib-sp-core
                    SpCore.getSystem("HTTP_USER_BASE_URL","http://api.sunpeople.com")
                )
                .client(new OkHttpClient.Builder())
                .header(new HeaderProvider() {}) // 配置头
                .retrofitFactory(FastJsonConverterFactory.create(),
                        RxJava2CallAdapterFactory.create())
                .errorAdapter(
                        new DefaultBodyErrorAdapter<ErrorResponse>(
                                FastJsonEngine.create()) {})
                .build()
);
```

##### 第七、发布到 **maven** 
在 gradle -> module-user -> upload -> **uploadArchives** 点击即可 注意版本号

-------
### 二、模块化目前已有工具
1. **lib-comm**:工具库
2. **lib-http**:网络使用库
3. **lib-mvp**: MVP使用
4. **lib-sp-core**: SP使用
5. **lib-theme**: 模块化临时使用主题

#### lib-comm
1. **BaseApplication** 模块中 app 中的 AndroidManifest.xml 可以使用或者继承使用
2. **BaseConstrainMvpFragment** 支持 Mvp 模式的 Fragment
3. **BaseLinkageMvpFragment**  支持 Mvp 模式的 Fragment
4. **BaseMvpActivity** 支持 Mvp 模式的 Activity
5. **BaseSingleton** 单例工具类
6. **CommApplication** comm 自启动注册器 独立管理无需任何配置（无需实例化，无需Context）
7. **CurrentActivity** 
    - 全局获取可使用最顶层的 Activity；提供给框架层使用；不允许开发者使用
    - 置于后台无法获取（无需实例化，无需Context）
8. **VisibilityTracker** 前后台监听器（无需实例化，无需Context）
9. **DisplayUtils** 全局单位转换（无需实例化，无需Context）
10. **ResourcesUtils** 全局资源获取（无需实例化，无需Context）
11. **ThemeUtils** 从 主题中获取数据（需传入当前主题）
12. **WatermarkUtils** 全局管理水印 需要 App 打包配置，全局配置一次
13. **SunToolbar** 应用程序 titleView

#### lib-http
https://github.com/cityfruit/HttpCore
#### lib-mvp

目录结构

```text
mvp
    -contracts  :契约 管理当前任务的 model、presenter、view
        ...
    -model      :MvpModel 具体业务实现类
        ...
    -presenter  :MvpPresenter 业务逻辑层（具体业务实现类）
        ...
    -view       :MvpView: MvpActivity \ MvpFragment UI层
        ...
    
```

1、建立契约
MainContract.java
```java
public interface MainContract {

    interface View extends IBaseView {
        /**
         * 登录成功
         */
        void loginSuccess();

        /**
         * 登录失败
         */
        void loginFailed();
    }

    interface Presenter extends IPresenter<View> {
        /**
         * @param name 用户名
         * @param pwd  用户秘密
         */
        void requestLogin(String name, String pwd);

        /**
         * model 回来数据（可不使用model）
         *
         * @param info model 登录结果
         */
        void responseLogin(UserInfo info);
    }

    // 可以不使用 model
    interface Model extends IModel<Presenter> {
        /**
         * 去执行网络操作 进行登录
         *
         * @param name 用户名
         * @param pwd  用户密码
         */
        void login(String name, String pwd, LifecycleTransformer transformer);
    }

}
```
2、第二步 使用 Mvp 的 View

 实现其中 BaseMvpActivity、BaseConstrainMvpFragment、BaseLinkageMvpFragment
 
```java

// MainPresenter 具体实现；如果没有可以暂时不加注解
@Presenter(MainPresenter.class)
public class MainView extends BaseMvpActivity<MainContract.Presenter> 
                      implements MainContract.View {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getPresenter().requestLogin("admin","123456");
    }

    @Override
    public void loginSuccess() {
        System.out.println("登录成功");
    }

    @Override
    public void loginFailed() {
        System.out.println("登录失败");
    }
}

```
3、实现 MainPresenter

```java
/**
 * @author yangji
 */
public class MainPresenter extends BasePresenter<MainModel, MainContract.View> 
                           implements MainContract.Presenter {
    @Override
    public void requestLogin(String name, String pwd) {
        HttpManager.getInstance().create(UserApi.class)
                .login(name, pwd)
                 //绑定生命周期 当 onDestroy 自动取消下游
                .compose(bindEvent())
                //绑定生命周期 当 onStop 自动取消下游
                .compose(bindEvent(Event.ON_STOP)) 
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new DefaultObserver<BaseInfo<UserInfo>>() {
                    @Override
                    public void onNext(BaseInfo<UserInfo> userInfoBaseInfo) {
                        getMvpView().loginSuccess();
                    }

                    @Override
                    public void onError(Throwable e) {
                        getMvpView().loginFailed();
                    }

                    @Override
                    public void onComplete() {
                    }
                });

    }


    /**
     * 配合Mvp Model 使用
     */
    @Override
    public void responseLogin(UserInfo info) {

    }
```
4、接口 UserApi

```java

// @Module 配合网络框架使用
@Module("USER")
public interface UserApi {

    /**
     * 用户登录
     *
     * @param name 用户名
     * @param pwd  用户密码
     * @return 用户登录数据
     */
    @POST("/v1/login")
    Observable<BaseInfo<UserInfo>> login(@Part("userName") String name, @Part("userPwd") String pwd);

}

```

#### lib-sp-core
使用方法
1. **初始化** SpCore.init(Context).build()
2. **存** SpCore.put("user", userInfo);
3. **取** UserInfo info = SpCore.get("user")
4. **统计数量** SpCore.count()
5. **存在？** SpCore.contains(key)
6. **删除** SpCore.remove(key)
7. **清空** SpCore.clear()

#### lib-theme
* 提供 每个独立模块 进行独立打包使用，正式打包 maven 不集成到项目中