devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

MVVM+组件化+Arouter实现

作者：花生_TL007 | 2024-06-11 03:14:58

赞

踩

android mvvm arouter

code小生 一个专注大前端领域的技术平台公众号回复Android加入安卓技术群

作者：孤縌
链接：https://www.jianshu.com/p/452c40b9a11c
声明：本文已获孤縌授权发表，转发等请联系原作者授权

MVVM+组件化实现

模块概览

底层模块：common、network、resource

功能模块：player、firebase、pay

界面模块：mobile、tablet、tablet_login

壳模块: app

模块实现

1.公共模块的gradle配置

由于不同模块，可能引用相同的依赖库，那么对于这部分共同的模块则需要提取出来做统一的管理，因此在项目的根目录创建了common.gradle。

  1. //project是根项目，可以简单认为是个对象，对象持有一个名词为ext的成员变量
  2. project.ext {
  3.     
  4.     //基本的变量配合和版本控制
  5.     compileSdkVersion = 30
  6.     buildToolsVersion = "30"
  7.     minSdkVersion = 21
  8.     targetSdkVersion = 30
  9.     applicationId = "com.sdmc.xmediatv"
  10.     versionCode = 4
  11.     versionName = "4.7.0"
  12.  
  13.     //设置app配置
  14.     setAppDefaultConfig = {
  15.         extension ->
  16.             //指定为application，代表该模块可以单独调试
  17.             extension.apply plugin: 'com.android.application'
  18.             extension.description "app"
  19.             
  20.             //公共的apply 主要是用于三方库
  21.             extension.apply plugin: 'kotlin-android'
  22.             extension.apply plugin: 'kotlin-android-extensions'
  23.             extension.apply plugin: 'kotlin-kapt'
  24.           
  25.             //设置项目的android
  26.             setAppAndroidConfig extension.android
  27.             //设置项目的三方库依赖
  28.             setDependencies extension.dependencies
  29.  
  30.     }
  31.  
  32.     //设置lib配置（只可以作为lib,不可单独调试）
  33.     setLibDefaultConfig = {
  34.         extension ->
  35.             //library，代表只是单纯的库，不需要依赖其他模块
  36.             extension.apply plugin: 'com.android.library'
  37.             extension.description "lib"
  38.            
  39.             setLibAndroidConfig extension.android
  40.             setDependencies extension.dependencies
  41.     }
  42.  
  43.     //是否允许module单独调试
  44.     isModuleDebug = false
  45.     //动态改变，用于单模块调试
  46.     setAppOrLibDefaultConfig = {
  47.         extension ->
  48.             if (project.ext.isModuleDebug) {
  49.                 extension.apply plugin: 'com.android.application'
  50.                 extension.description "app"
  51.             } else {
  52.                 extension.apply plugin: 'com.android.library'
  53.                 extension.description "lib"
  54.  
  55.             }
  56.             extension.apply plugin: 'kotlin-android'
  57.             extension.apply plugin: 'kotlin-android-extensions'
  58.             extension.apply plugin: 'kotlin-kapt'
  59.             //设置通用Android配置
  60.             setAppOrLibAndroidConfig extension.android
  61.             //设置通用依赖配置
  62.             setDependencies extension.dependencies
  63.     }
  64.  
  65.     //设置application 公共的android配置
  66.     setAppAndroidConfig = {
  67.         extension -> //extension 相当于 android 对象
  68.             extension.compileSdkVersion project.ext.compileSdkVersion
  69.             extension.buildToolsVersion project.ext.buildToolsVersion
  70.             extension.defaultConfig {
  71.                 applicationId project.ext.applicationId
  72.                 minSdkVersion project.ext.minSdkVersion
  73.                 targetSdkVersion project.ext.targetSdkVersion
  74.                 versionCode project.ext.versionCode
  75.                 versionName project.ext.versionName
  76.  
  77.                 extension.flavorDimensions "versionCode"
  78.  
  79.  
  80.                 testInstrumentationRunner "android.support.tablet_test.runner.AndroidJUnitRunner"
  81.  
  82.                 //ARouter 编译生成路由
  83.                 kapt {
  84.                     arguments {
  85.                         arg("AROUTER_MODULE_NAME", project.getName())
  86.                         includeCompileClasspath = true
  87.                     }
  88.  
  89.                 }
  90.             }
  91.             extension.buildFeatures {
  92.                 dataBinding = true
  93.                 // for view binding :
  94.                 // viewBinding = true
  95.             }
  96.     }
  97.  
  98.     //设置lib 公共的android配置
  99.     setLibAndroidConfig = {
  100.         extension -> //extension 相当于 android 对象
  101.             extension.compileSdkVersion project.ext.compileSdkVersion
  102.             extension.buildToolsVersion project.ext.buildToolsVersion
  103.             extension.defaultConfig {
  104.                 minSdkVersion project.ext.minSdkVersion
  105.                 targetSdkVersion project.ext.targetSdkVersion
  106.                 versionCode project.ext.versionCode
  107.                 versionName project.ext.versionName
  108.  
  109.                 testInstrumentationRunner "android.support.tablet_test.runner.AndroidJUnitRunner"
  110.  
  111.                 //ARouter 编译生成路由
  112.                 /*kapt {
  113.                     arguments {
  114.                         arg("AROUTER_MODULE_NAME", project.getName())
  115.                     }
  116.                 }*/
  117.             }
  118.             extension.buildFeatures {
  119.                 dataBinding = true
  120.                 // for view binding :
  121.                 // viewBinding = true
  122.             }
  123.     }
  124.  
  125.     //设置通用的 android配置（可作为project单独调试）
  126.     setAppOrLibAndroidConfig = {
  127.         extension -> //extension 相当于 android 对象
  128.             extension.compileSdkVersion project.ext.compileSdkVersion
  129.             extension.buildToolsVersion project.ext.buildToolsVersion
  130.             extension.defaultConfig {
  131.                 minSdkVersion project.ext.minSdkVersion
  132.                 targetSdkVersion project.ext.targetSdkVersion
  133.                 versionCode project.ext.versionCode
  134.                 versionName project.ext.versionName
  135.  
  136.                 extension.flavorDimensions "versionCode"
  137.  
  138.  
  139.                 testInstrumentationRunner "android.support.tablet_test.runner.AndroidJUnitRunner"
  140.  
  141.                 //ARouter 编译生成路由
  142.                 kapt {
  143.                     arguments {
  144.                         arg("AROUTER_MODULE_NAME", project.getName())
  145.                         includeCompileClasspath = true
  146.                     }
  147.  
  148.                 }
  149.  
  150.             }
  151.             extension.buildFeatures {
  152.                 //启用自动绑定view id
  153.                 dataBinding = true
  154.             }
  155.         
  156.             //使用的jdk版本
  157.             extension.compileOptions {
  158.                 sourceCompatibility JavaVersion.VERSION_1_8
  159.                 targetCompatibility JavaVersion.VERSION_1_8
  160.             }
  161.             extension.kotlinOptions {
  162.                 jvmTarget = JavaVersion.VERSION_1_8
  163.             }
  164.  
  165.             //动态改变清单文件资源指向
  166.             extension.sourceSets {
  167.                 main {
  168.                     if (project.ext.isModuleDebug) {
  169.                         manifest.srcFile 'src/main/manifest/AndroidManifest.xml'
  170.                     } else {
  171.                         manifest.srcFile 'src/main/AndroidManifest.xml'
  172.                     }
  173.                 }
  174.             }
  175.  
  176.     }
  177.  
  178.  
  179.     //公用的三方库依赖，慎重引入，主要引入基础库依赖
  180.     setDependencies = {
  181.         extension ->
  182.             extension.implementation fileTree(dir: 'libs', include: ['*.jar'])
  183.             extension.kapt 'com.alibaba:arouter-compiler:1.2.2'
  184.  
  185.             //ARouter 路由apt插件，用于生成相应代码，每个module都需要
  186.             extension.implementation 'com.alibaba:arouter-api:1.5.0'
  187.             extension.implementation 'com.alibaba:arouter-compiler:1.2.2'
  188.             extension.implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  189.             extension.implementation 'androidx.core:core-ktx:1.3.1'
  190.             extension.implementation 'com.google.code.gson:gson:2.8.6'
  191.             extension.implementation 'androidx.appcompat:appcompat:1.2.0'
  192.             extension.implementation 'androidx.constraintlayout:constraintlayout:2.0.0'
  193.             extension.implementation 'androidx.recyclerview:recyclerview:1.0.0'
  194.     }
  195. }

根目录的build.gradle：

  1. buildscript {
  2.     //统一制定版本
  3.     ext.kotlin_version = '1.4.31'
  4.     ext.google_service_version = '19.7.0'
  5.     ext.exoplayer_version = '2.13.2'
  6.     
  7.     repositories {
  8.         //为当前的build.gradle设置依赖库中心
  9.         google()
  10.         jcenter()
  11.     }
  12.     dependencies {
  13.         //gradle版本
  14.         classpath "com.android.tools.build:gradle:4.0.1"
  15.         //kotlin依赖
  16.         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
  17.         //bintray.com maven的依赖
  18.         classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1.0"
  19.         //sonatype maven的依赖
  20.         classpath "com.github.dcendents:android-maven-gradle-plugin:1.5"
  21.         //黄油刀
  22.         classpath 'com.jakewharton:butterknife-gradle-plugin:10.2.3'
  23.         //谷歌服务
  24.         classpath 'com.google.gms:google-services:4.3.3'
  25.         // NOTE: Do not place your application dependencies here; they belong
  26.         // in the individual module build.gradle files
  27.     }
  28. }
  29.  
  30. allprojects {
  31.     repositories {
  32.         //jitpack库
  33.         maven { url 'http://www.jitpack.io' }
  34.         //bintray.com维护的Maven仓库
  35.         jcenter()
  36.         //谷歌maven库
  37.         maven { url "https://maven.google.com" }
  38.         google()
  39.         //阿里云镜像maven库地址
  40.         maven {
  41.             url "http://maven.aliyun.com/nexus/content/repositories/releases"
  42.         }
  43.     }
  44. }
  45.  
  46. task clean(type: Delete) {
  47.     delete rootProject.buildDir
  48. }
2.壳app模块的实现
  1. //从项目的根目录中找到common.gradle
  2. apply from: "${rootProject.rootDir}/common.gradle"
  3.  
  4. //project.ext则是之前强调的common.gradle中的对象，该对象有setAppDefaultConfig
  5. project.ext.setAppDefaultConfig project
  6.  
  7. //由于setAppDefaultConfig中的android配置是通用配置，所以还需要针对壳本身新增配置
  8. android {
  9.  
  10.     //混淆规则配置
  11.     buildTypes {
  12.         release {
  13.             minifyEnabled true
  14.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  15.         }
  16.  
  17.         debug {
  18.             minifyEnabled false
  19.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  20.         }
  21.     }
  22.  
  23.     packagingOptions {
  24.         //nanohttpd轻量级数据库所需
  25.         exclude 'META-INF/nanohttpd/default-mimetypes.properties'
  26.         exclude 'META-INF/nanohttpd/mimetypes.properties'
  27.         //为了解决部分第三方库重复打包了META-INF的问题
  28.         exclude 'META-INF/NOTICE'
  29.         exclude 'META-INF/LICENSE'
  30.         //解决kotlin问题
  31.         exclude("META-INF/*.kotlin_module")
  32.     }
  33.  
  34.     compileOptions {
  35.         sourceCompatibility = '1.8'
  36.         targetCompatibility = '1.8'
  37.     }
  38.  
  39.     kotlinOptions {
  40.         jvmTarget = "1.8"
  41.     }
  42.  
  43.     //在本地loacl.propreties中配置打包所需信息
  44.     Properties properties = new Properties()
  45.     InputStream inputStream = project.rootProject.file('local.properties').newDataInputStream()
  46.     properties.load(inputStream)
  47.     def sdkDir = properties.getProperty('key.file')
  48.     def keyFile = file(sdkDir)
  49.     def key_keyAlias = properties.getProperty('keyAlias')
  50.     def key_keyPassword = properties.getProperty('keyPassword')
  51.     def key_storePassword = properties.getProperty('storePassword')
  52.  
  53.     signingConfigs {
  54.         release {
  55.             v2SigningEnabled true
  56.         }
  57.         debug {
  58.             storeFile file(keyFile)
  59.             storePassword key_storePassword
  60.             keyAlias key_keyAlias
  61.             keyPassword key_keyPassword
  62.         }
  63.  
  64.     }
  65.     /*android.applicationVariants.all {
  66.         variant ->
  67.             variant.outputs.all {
  68.                 output ->
  69.                     outputFileName = new File("../version/", "XMediaTV_Android_" +
  70.                             defaultConfig.versionName + "." + releaseTime() + "_" + variant.buildType.name + ".apk")
  71.             }
  72.     }*/
  73.  
  74.     //android打包提示check release builds false
  75.     lintOptions {
  76.         checkReleaseBuilds false
  77.         abortOnError false
  78.     }
  79. }
  80.  
  81. dependencies {
  82.     //壳工程所依赖的模块，implementation代表不依赖模块下的三分库
  83.     implementation project(path: ':mobile')
  84.     implementation project(path: ':tablet')
  85.     //api 代表依赖模块下所有的库
  86.     api project(path: ':common')
  87.     api project(path: ':firebase')
  88. }
  89. //设置仓库地址，用于辅助三方库依赖文件下载
  90. repositories {
  91.     mavenCentral()
  92. }
3.底层模块的model配置

common中的gradle文件：

common模块本身就是为了通用，那么对于一些常用的库，则需要在该模块做一定的依赖处理，以下对不同模块功能依赖做出了标注

  1. apply plugin: 'com.android.library'
  2. apply plugin: 'kotlin-android'
  3. apply plugin: 'kotlin-android-extensions'
  4. apply plugin: 'kotlin-kapt'
  5.  
  6. android {
  7.     compileSdkVersion 29
  8.     buildToolsVersion "29.0.3"
  9.  
  10.     defaultConfig {
  11.         minSdkVersion 21
  12.         targetSdkVersion 29
  13.         versionCode 1
  14.         versionName "1.0.0"
  15.         //设置预览界面的库支持
  16.         vectorDrawables.useSupportLibrary = true
  17.         testInstrumentationRunner "androidx.tablet_test.runner.AndroidJUnitRunner"
  18.         //混淆文件指定
  19.         consumerProguardFiles "consumer-rules.pro"
  20.  
  21.         //配合根目录的gradle.properties，代码中调用BuildConfig.SERVER_ADDRESS动态获取对应值，用于自动打包改服务地址
  22.         buildConfigField "String", "SERVER_ADDRESS", "\"${SERVER_ADDRESS}\""
  23.         buildConfigField "String", "TENANT_CODE", "\"${TENANT_CODE}\""
  24.         buildConfigField "String", "AD_SERVER_ADDRESS", "\"${AD_SERVER_ADDRESS}\""
  25.         buildConfigField "String", "PLAYER_SERVER_URI", "\"${PLAYER_SERVER_URI}\""
  26.         buildConfigField "Boolean", "FORCE_USE_TABLET", project.properties.get("FORCE_USE_TABLET")
  27.     }
  28.  
  29.     //设置arouter模块名称
  30.     kapt {
  31.         arguments {
  32.             arg("AROUTER_MODULE_NAME", project.getName())
  33.         }
  34.     }
  35.  
  36.     //资源前缀强制命名
  37.     resourcePrefix "common_"
  38.  
  39.     //混淆模式
  40.     buildTypes {
  41.         release {
  42.             minifyEnabled false
  43.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  44.         }
  45.     }
  46.  
  47.     //用于换肤，让所有model都可以拥有不同类型的资源目录
  48.     sourceSets {
  49.         main {
  50.             res.srcDirs = ['src/main/res',
  51.                            'src/main/res-light',
  52.                            'src/main/res-news']
  53.         }
  54.     }
  55.  
  56.     compileOptions {
  57.         sourceCompatibility JavaVersion.VERSION_1_8
  58.         targetCompatibility JavaVersion.VERSION_1_8
  59.     }
  60. }
  61.  
  62. dependencies {
  63.     implementation fileTree(dir: "libs", include: ["*.jar"])
  64.     //》》》》kotlin
  65.     //kotlin核心库配置，对应根目录的build.gradle版本
  66.     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  67.     implementation 'androidx.core:core-ktx:1.3.2'
  68.     //kotlin协程库
  69.     api 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3-native-mt'
  70.     api 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3-native-mt'
  71.  
  72.  
  73.     //》》》》视图
  74.     //android视图库
  75.     api 'androidx.appcompat:appcompat:1.2.0'
  76.     api 'com.google.android.material:material:1.3.0'
  77.     api 'androidx.constraintlayout:constraintlayout:2.0.1'
  78.     api 'androidx.recyclerview:recyclerview:1.1.0'
  79.  
  80.     //glide图片加载库
  81.     api 'com.github.bumptech.glide:glide:4.12.0'
  82.     //圆角的ImageView库
  83.     api 'com.makeramen:roundedimageview:2.3.0'
  84.     //recycleView的adapter库
  85.     api 'com.github.CymChad:BaseRecyclerViewAdapterHelper:3.0.4'
  86.     //下拉刷新库
  87.     implementation 'com.lcodecorex:tkrefreshlayout:1.0.7'
  88.     //头条的自适应库
  89.     api 'me.jessyan:autosize:1.2.1'
  90.     //换肤库
  91.     api 'skin.support:skin-support:4.0.5'                   // skin-support
  92.     api 'skin.support:skin-support-appcompat:4.0.5'         // skin-support 基础控件支持
  93.     api 'skin.support:skin-support-design:4.0.5'
  94.     // skin-support-design material design 控件支持[可选]
  95.     api 'skin.support:skin-support-cardview:4.0.5'
  96.     // skin-support-cardview CardView 控件支持[可选]
  97.     api 'skin.support:skin-support-constraint-layout:4.0.5'
  98.     // skin-support-constraint-layout ConstraintLayout 控件支持[可选]
  99.     //本地资源库
  100.     api project(path: ':resource')
  101.  
  102.     //》》》》网络
  103.     //用于retrofit2库依赖
  104.     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
  105.     implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
  106.     //用于retrofit2+kotlin+coroutines的回调库，可以直接加上suspend关键字获取到回调对象
  107.     implementation 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2'
  108.     //okhttp3库
  109.     implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.2'
  110.     //gson解析库
  111.     implementation 'com.google.code.gson:gson:2.8.6'
  112.  
  113.     //》》》》其余基本库
  114.     //郭霖的Litepal数据库
  115.     api 'org.litepal.guolindev:core:3.2.2'
  116.  
  117.     //sharePreference库
  118.     api 'com.orhanobut:hawk:2.0.1'
  119.  
  120.  
  121.     //阿里的路由库
  122.     kapt 'com.alibaba:arouter-compiler:1.2.2'
  123.     api 'com.alibaba:arouter-api:1.5.0'
  124.  
  125.     //谷歌的deeplink分享
  126.     implementation 'com.google.firebase:firebase-dynamic-links:19.1.0'
  127.  
  128.  
  129.     //--------------------------------------------------------------
  130.  
  131.     //》》》》lifecycle库，用于liveData和viewModle，使用与mvvm框架
  132.     def lifecycle_version = '2.2.0'
  133.     // ViewModel and LiveData
  134.     api "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
  135.     // alternatively - just ViewModel
  136. //    api "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
  137.     api 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.0'
  138.     // For Kotlin use lifecycle-viewmodel-ktx
  139.     // alternatively - just LiveData
  140. //    api "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
  141.     // 有生命周期感知的协程
  142.     api 'androidx.lifecycle:lifecycle-runtime-ktx:2.3.0'
  143.  
  144. }

network中的gradle文件：

该模块为网络请求模块，用到的框架是retrofit2 + kotlin + coroutines，本质是请求耗时网络，通过kotlin使用coroutines的suspend挂起，来达到子线程请求，主线程接收数据的效果。

  1. apply plugin: 'com.android.library'
  2. apply plugin: 'kotlin-android'
  3. apply plugin: 'kotlin-android-extensions'
  4. apply plugin: 'kotlin-kapt'
  5. android {
  6.     compileSdkVersion 29
  7.  
  8.     defaultConfig {
  9.         minSdkVersion 21
  10.         targetSdkVersion 29
  11.         versionCode 1
  12.         versionName "1.0.0"
  13.         buildConfigField "String", "SERVER_ADDRESS", "\"${SERVER_ADDRESS}\""
  14.         buildConfigField "String", "TENANT_CODE", "\"${TENANT_CODE}\""
  15.         buildConfigField "String", "AD_SERVER_ADDRESS", "\"${AD_SERVER_ADDRESS}\""
  16.         buildConfigField "String", "PLAYER_SERVER_URI", "\"${PLAYER_SERVER_URI}\""
  17.         buildConfigField "Boolean", "FORCE_USE_TABLET", project.properties.get("FORCE_USE_TABLET")
  18.  
  19.     }
  20.     resourcePrefix "network_"
  21.  
  22.     buildTypes {
  23.         debug {
  24.             minifyEnabled true
  25.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  26.  
  27.         }
  28.         release {
  29.             minifyEnabled true
  30.         }
  31.     }
  32.  
  33.     compileOptions {
  34.         sourceCompatibility = '1.8'
  35.         targetCompatibility = '1.8'
  36.     }
  37.  
  38.  
  39. }
  40.  
  41. dependencies {
  42.     implementation fileTree(dir: "libs", include: ["*.jar"])
  43.  
  44.     //用于添加retrofit2拦截请求头用的
  45.     implementation 'com.squareup.okhttp3:logging-interceptor:4.8.1'
  46.     //Chuck辅助工具，用于打印各种http请求
  47.     debugImplementation 'com.readystatesoftware.chuck:library:1.1.0'
  48.     releaseImplementation 'com.readystatesoftware.chuck:library-no-op:1.1.0'
  49.  
  50.     //--------------------------------------------------------------
  51.     api project(path: ':common')
  52.     implementation files('libs\\XMediaCryptoJar_HKSC.jar')
  53. }

resoure的gradle:

该Model主要是用于存放抽取的颜色、多语言、以及与app相关的图标、占位图等

  1. apply plugin: 'com.android.library'
  2. apply plugin: 'kotlin-android'
  3. apply plugin: 'kotlin-android-extensions'
  4.  
  5. android {
  6.     compileSdkVersion 29
  7.     buildToolsVersion "29.0.3"
  8.  
  9.     defaultConfig {
  10.         minSdkVersion 21
  11.         targetSdkVersion 29
  12.         versionCode 1
  13.         versionName "1.0"
  14.  
  15.         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
  16.         consumerProguardFiles "consumer-rules.pro"
  17.     }
  18.  
  19.     buildTypes {
  20.         release {
  21.             minifyEnabled false
  22.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  23.         }
  24.     }
  25.  
  26.     sourceSets {
  27.         main {
  28.             res.srcDirs = ['src/main/res',
  29.                            'src/main/res-light',
  30.                            'src/main/res-news']
  31.         }
  32.     }
  33. }
  34.  
  35. dependencies {
  36.     implementation fileTree(dir: "libs", include: ["*.jar"])
  37.     //kotlin
  38.     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  39.     implementation 'androidx.core:core-ktx:1.3.2'
  40.  
  41.     //单元测试库
  42.     testImplementation 'junit:junit:4.13.2'
  43.     androidTestImplementation 'androidx.test.ext:junit:1.1.2'
  44.     androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
  45.  
  46. }

基本模块配置都是作为library库使用，对于基本模块的内容有要求，就是一定是一项基础并且多模块共用的功能，才值得放在基础模块中。

4.功能模块或界面模块的依赖配置

对于模块依赖，只要弄清楚api和implementation的功能，并且清楚common.gradle，是如何使用的，就能很清晰的使用模块化项目开发。

  1. apply from: "${rootProject.rootDir}/common.gradle"
  2.  
  3. //使用common.gradle中的公用配置
  4. project.ext.setAppOrLibDefaultConfig project
  5.  
  6. android {
  7.     resourcePrefix "tablet_"
  8.  
  9.  
  10.     buildTypes {
  11.         release {
  12.             minifyEnabled false
  13.             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
  14.         }
  15.     }
  16.  
  17. }
  18.  
  19. dependencies {
  20.     //这里统一依赖了network，network中由于是api common，common api resource，所以只需要implementation network就行
  21.     implementation project(path: ':network')
  22.     //统一依赖功能model,播放器、Firebase、支付
  23.     implementation project(path: ':player')
  24.     implementation project(path: ':firebase')
  25.     implementation project(path: ':pay')
  26.     //依赖了一个界面模块，含各种平板的弹窗界面和登录
  27.     implementation project(path: ':tablet_login')
  28.     //下拉刷新库
  29.     implementation 'com.lcodecorex:tkrefreshlayout:1.0.7'
  30.     //轮播图库
  31.     implementation 'com.github.zhpanvip:BannerViewPager:3.1.6'
  32.     //谷歌支付库
  33.     implementation 'com.android.billingclient:billing:2.1.0'
  34.     //依次是，谷歌消息、DeepLink、广告
  35.     implementation 'com.google.firebase:firebase-messaging:20.1.2'
  36.     implementation 'com.google.firebase:firebase-dynamic-links:19.1.0'
  37.     implementation "com.google.android.gms:play-services-ads:$google_service_version"
  38. }

模块内容

1.common

base包：

存放着各种基类，其中主要的是MVVM，所以着重讲述MVVM框架搭建

ViewModel讲解：

首先，要继承ViewModel，导包，viewModel主要功能是，代替UI界面去做耗时操作，所以通过viewModelScope对象调用协程挂起，最终通过liveData绑定数据回调。

  1. api "androidx.lifecycle:lifecycle-extensions:$lifecycle_version" //viewModel+livedata
  2. api 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.0' //kotlin专用
  3. 由于ViewModel是配合Coroutine使用的，所以必需先认识CoroutineScope（协程范围）和withContext(Dispatchers.IO)中的Dispatchers模式，这里先讲Dispatchers的用途和具体场景。
  1. //实现LifecycleObserver接口，是为了通过activity的lifecycle.addObserver(LifecycleObserver) 绑定到生命周期中
  2. open class BaseViewModel : ViewModel(), LifecycleObserver {
  3.     
  4.     //viewModelScope是ViewModel中的成员对象，该对象实现了CoroutineScope接口
  5.     //suspend CoroutineScope.() -> Unit, suspend是kotlin线程挂起的标识，实际上去走了await()方法 
  6.     //CoroutineScope.() -> Unit 代表一个方法体，并且该方法体对象是CoroutineScope接口对象，主要是规范方法体类型，可除去CoroutineScope.
  7.     fun launchUI(block: suspend CoroutineScope.() -> Unit) = viewModelScope.launch {
  8.         try {
  9.             block()
  10.         } catch (e: Exception) {
  11.             e.printStackTrace()
  12.         }
  13.  
  14.     }
  15.     
  16.     //相比上个方法，主要是多了 withContext(Dispatchers.IO)，目的是切换到子线程做耗时操作
  17.     fun launchIO(block: suspend CoroutineScope.() -> Unit) = viewModelScope.launch {
  18.         withContext(Dispatchers.IO) {
  19.             try {
  20.                 block()
  21.             } catch (e: Exception) {
  22.                 e.printStackTrace()
  23.  
  24.             }
  25.         }
  26.     }
  27.     
  28.     //errorHandler 是为了统一处理网络异常
  29.     fun launchIO(
  30.         block: suspend CoroutineScope.() -> Unit,
  31.         errorHandler: (code: Int, message: String) -> Unit?,
  32.     ) = viewModelScope.launch {
  33.         withContext(Dispatchers.IO) {
  34.             try {
  35.                 if (NetWorkUtils.isNetConnect(CommonManager.context)) {
  36.                     block()
  37.                 } else {
  38.                     errorHandler(300, "No internet connection")
  39.                 }
  40.             } catch (e: Exception) {
  41.                 handlerErrorCode(e, errorHandler)
  42.                 e.printStackTrace()
  43.             }finally {
  44.                 //....
  45.             }
  46.         }
  47.     }
  48.  
  49.     private fun handlerErrorCode(
  50.         e: Exception,
  51.         errorHandler: (code: Int, message: String) -> Unit?,
  52.     ) {
  53.         when (e) {
  54.             is HttpException -> {
  55.                 errorHandler(e.code(), e.message())
  56.             }
  57.             is UnknownHostException -> {
  58.                 errorHandler(404, "Unable to connect to server")
  59.             }
  60.             is SocketTimeoutException -> {
  61.                 errorHandler(408, "Socket time out")//访问超时
  62.             }
  63.             is ConnectException -> {
  64.                 errorHandler(404, "Connect exception")
  65.             }
  66.             is SocketException -> {
  67.                 errorHandler(500, "Socket exception")
  68.             }
  69.             is EOFException -> {
  70.                 errorHandler(500, "EOF exception") //连接意外中断
  71.             }
  72.             is IllegalArgumentException -> {
  73.                 errorHandler(400, "Illegal argument exception")//参数错误
  74.             }
  75.             is SSLException -> {
  76.                 errorHandler(401, "SSL exception")//证书错误
  77.             }
  78.             is NullPointerException -> {
  79.                 errorHandler(600, "Null pointer exception")
  80.             }
  81.             else -> {
  82.                 errorHandler(700, "Unknown exception")
  83.             }
  84.         }
  85.     }
  86.  
  87.     fun Map<String, Any>.getBody(): RequestBody {
  88.         return Gson().toJson(this).toRequestBody("application/json".toMediaTypeOrNull())
  89.     }
  90.  
  91.     data class ErrorHandler(val code: Int, val message: String)
  92. }

BaseVMActivity讲解:

  1. //持有俩个泛型，VM和DB，分别是BaseViewModel和ViewDataBinding的实现类
  2. abstract class BaseVMActivity<VM : BaseViewModel, DB : ViewDataBinding> : BaseActivity(){
  3.     
  4.     //是否打印生命周期
  5.     var openLifecycle: Boolean = false
  6.     lateinit var viewModel: VM
  7.     lateinit var dataBinding: DB
  8.     
  9.     override fun onCreate(savedInstanceState: Bundle?) {
  10.         super.onCreate(savedInstanceState)
  11.         LogUtil.e(TAG, "onCreate", openLifecycle)
  12.         //绑定视图，获取到dataBinding
  13.         dataBinding = DataBindingUtil.setContentView(this, provideContentViewId())
  14.         tvTitle = dataBinding.root.findViewById(R.id.title)
  15.         back = dataBinding.root.findViewById(R.id.back)
  16.         //实例化ViewModel
  17.         viewModel = initVM()
  18.         //让viewModel关联生命周期
  19.         lifecycle.addObserver(viewModel)
  20.         //开始接口监听回调
  21.         startObserve()
  22.     }
  23.  
  24.     abstract fun initVM(): VM
  25.  
  26.     abstract fun startObserve()
  27.  
  28.     override fun onResume() {
  29.         super.onResume()
  30.         LogUtil.e(TAG, "onResume", openLifecycle)
  31.     }
  32.  
  33.     override fun onPause() {
  34.         super.onPause()
  35.         LogUtil.e(TAG, "onPause", openLifecycle)
  36.     }
  37.  
  38.     override fun onStart() {
  39.         super.onStart()
  40.         LogUtil.e(TAG, "onStart", openLifecycle)
  41.     }
  42.  
  43.     override fun onRestart() {
  44.         super.onRestart()
  45.         LogUtil.e(TAG, "onRestart", openLifecycle)
  46.     }
  47.  
  48.     override fun onStop() {
  49.         super.onStop()
  50.         LogUtil.e(TAG, "onStop", openLifecycle)
  51.     }
  52.  
  53.     override fun onDestroy() {
  54.         super.onDestroy()
  55.         LogUtil.e(TAG, "onDestroy", openLifecycle)
  56.     }
  57.     
  58.     //Arouter路由跳转封装， action代表Postcard方法体回调
  59.     fun open(path: String, requestCode: Int = 0, action: Postcard.() -> Unit = {}) {
  60.         val postcard = ARouter.getInstance().build(path)
  61.         postcard.action()
  62.         postcard.navigation(this, requestCode)
  63.     }
  64.     
  65.     fun openWithFinish(path: String, action: Postcard.() -> Unit = {}) {
  66.         open(path, 0, action)
  67.         finish()
  68.     }
  69. }

router包：

路由本意是，为了解决不同模块之间无法访问各自界面问题

路由指定，首先需要定义路径名，然后在对应的类中新增注解@Route(path = RouterPath.MOBILE_HOME)，之后通过Arouter的navigation()方法跳转到不同模块的界面，从而实现跨模块的跳转。

  1. interface RouterPath {
  2.     companion object {
  3.         //mobile
  4.         const val MOBILE_HOME = "/mobile/home_activity"
  5.         const val MOBILE_SPLASH = "/mobile/splash"
  6.         const val MOBILE_VOD_DETAIL = "/mobile/vod_detail"
  7.         const val MOBILE_LIVE = "/mobile/live"
  8.         const val MOBILE_PAY = "/mobile/pay/activity"
  9.         const val MOBILE_EVENT = "/mobile/event"
  10.  
  11.  
  12.         //tablet
  13.         const val TABLET_HOME = "/tablet/home_activity"
  14.         const val TABLET_VOD_DETAIL = "/tablet/vod_detail"
  15.         const val TABLET_SPLASH = "/tablet/splash"
  16.         const val TABLET_EVENT = "/tablet/event"
  17.  
  18.         const val PAY_ACTIVITY = "/pay/activity"
  19.  
  20.     }
  21. }

view包：

adapterItemDecoration是存放recycleview的装饰类ItemDecoration

viewExpand是存放所有视图相关的kotlin方法扩展，例如ImageView的加载图片封装

其余的则为view包中的一些常用的自定义view视图

2.network：

在了解network模块之前，必需对retrofit的使用由清晰的认识，所以接下来就看一个正常的retrofit是如何调用的。

调用库的依赖：

  1. //retrofit核心库，这个在我们的common包中就有依赖
  2. api 'com.squareup.retrofit2:retrofit:2.9.0'
  3. //加上这个之后，你可以省略输入流转Gson的步骤
  4. api 'com.squareup.retrofit2:converter-gson:2.9.0'
  5. //使用之后，支持接口回调返回Deferred<T>对象，该对象是延迟结果发送的意思，可以使用suspend代替
  6. api 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2'

实现步骤：

  1. //1.定义接口，并申明请求方式和对应的返回结果
  2. interface TestApi {
  3.     //get请求，（https://www.baidu.com/test/{body}）
  4.     @GET("/test/{body}")
  5.     fun getTest(@Path("test") body: String): Deferred<Test>
  6. }
  7.  
  8. //2.使用retrofit初始化TestApi接口的实现对象
  9. val myTestApi by lazy {
  10.     val retrofit = retrofit2.Retrofit.Builder()
  11.             .baseUrl("https://www.baidu.com")
  12.             //添加Gson转换
  13.             .addConverterFactory(GsonConverterFactory.create())
  14.             //添加Deferred转换
  15.             .addCallAdapterFactory(CoroutineCallAdapterFactory())
  16.             .build()
  17.     
  18.     //创建实现TestApi接口的MyTestApi对象，通过该对象就可以调用getTest()方法去走对应的网络请求
  19.     retrofit.create(MyTestApi::class.java)
  20. }
  21.  
  22. //3.使用协程实现简洁回调
  23. //确保在UI线程中调用，当getTest方法执行后，回调用await()挂起，如果在方法中申明suspend，则可以省略，直接让getTest()返回Test
  24. GlobalScope.launch(Dispatchers.Main) {
  25.     try {
  26.         //回调UI线程中刷新界面数据
  27.         onResponseUI(myTestApi.getTest("test").await())
  28.     } catch (e: Exception) {
  29.         prink(e)
  30.     }
  31. }
  32.  
  33. //4.搭配LiveData的进阶用法
  34. interface HistoryApi {
  35.     //用了post请求，并且加了suspend，直接让接口返回对象本身
  36.     @POST(AppConfig.BO_API + "/play/list")
  37.     suspend fun getPlayHistory(@Body body: RequestBody): WatchHistoryData
  38. }
  39.  
  40. class HistoryViewModel : BaseViewModel() {
  41.     private var historyApi = NetWorkManager.historyApiSingleton
  42.     //声明并初始化一个LiveData对象
  43.     var playHistoryData: MutableLiveData<WatchHistoryData> = MutableLiveData()
  44.  
  45.     fun getPlayHistory(
  46.         page: Int = 0, pageSize: Int = 12, type: String = XMediaConst.CONTENT_TYPE_VOD
  47.     ) = launchIO {
  48.  
  49.         var parameter: HashMap<String, Any> = hashMapOf()
  50.         parameter["type"] = type
  51.         parameter["page"] = page
  52.         parameter["pageSize"] = pageSize
  53.         //调用方法返回对象
  54.         val resultData = historyApi.getPlayHistory(parameter.getBody())
  55.         if (resultData.resultCode == 0)
  56.             //让liveData对象绑定接口返回对象值
  57.             playHistoryData.postValue(resultData)
  58.     }
  59. }
  60.  
  61. //在starObserve中做回调监听，playHistoryData是一个liveData类型，当数据改变就会回调
  62. historyViewModel.run {
  63.     //this传的是一个lifecycleOwner对象，通常是activity或fragment持有
  64.     playHistoryData.observe(this@VodFragment) {
  65.  
  66.     }
  67. }

Network包中的组成：

api包：存放所有网络请求接口API

  1. interface HistoryApi {
  2.     //用了post请求，并且加了suspend，直接让接口返回对象本身
  3.     @POST(AppConfig.BO_API + "/play/list")
  4.     suspend fun getPlayHistory(@Body body: RequestBody): WatchHistoryData
  5. }

bean包：存放Bean对象

  1. data class WatchHistoryData(
  2.     val contents: List<Content>,
  3.     val description: String,
  4.     val pageCount: Int,
  5.     val resultCode: Int
  6. )

viewModel包：存放ViewModel实现类

NetworkManager: 用于retrofit网络请求头参数统一配置，retrofit的对象初始化，以及初始化viewModel实现类对象

  1. // lazy默认模式就是同步锁，其余模式暂不展开
  2. val historyApiSingleton: HistoryApi by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  3.             retrofit.create(HistoryApi::class.java)
  4.         }
  5.  
  6. val client = OkHttpClient.Builder()
  7.             //.cache(Cache(file, cacheSize))
  8.             .connectTimeout(DEFAULT_TIME, TimeUnit.SECONDS) //连接超时设置
  9.             .readTimeout(DEFAULT_TIME, TimeUnit.SECONDS) //读取超时设置
  10.             .writeTimeout(WRITE_TIME, TimeUnit.SECONDS) //写入超时设置
  11.             .addInterceptor(headInterceptor()) //请求头拦截
  12.             .addInterceptor(ChuckInterceptor(context)) //chunk工具类拦截
  13.             //.addNetworkInterceptor(responseCacheInterceptor()) //缓存拦截
  14.             .addInterceptor(HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)) //提交和接收数据的拦截器
  15.             .build()
  16.  
  17. var retrofit = Retrofit.Builder()
  18.             .baseUrl(AppConfig.SERVER_ROOT_URI)
  19.             .addConverterFactory(GsonConverterFactory.create()) //gson解析
  20.             .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) //Rxjava
  21.             .addCallAdapterFactory(CoroutineCallAdapterFactory()) //协程Coroutine
  22.             .client(client)
  23.             .build()
3.功能模块和界面模块

功能模块没什么好讲的，就是功能封装，调用方式也很简洁，而界面模块，主要描述一下MVVM的Activity是怎么实现的

  1. //HomeViewModel，即我们之前将的ViewModel实现类， TabletActivityCategoryBinding则是系统通过xml自动生成的，具体请看下述的xml
  2. class TabletCategoryActivity : BaseVMActivity<HomeViewModel, TabletActivityCategoryBinding>() {
  3.     //分类内容列表，具体数据需要调网络请求接口获取
  4.     private var categoryContentList: MutableList<CategoryContentData.Content> = mutableListOf()
  5.     private var categoryAdapter: TabletCategoryAdapter? = null
  6.  
  7.     companion object {
  8.         const val CATEGORY_ID = "category_id"
  9.         const val CATEGORY_TYPE = "category_type"
  10.         const val CATEGORY_TITLE = "category_title"
  11.     }
  12.  
  13.     //HomeViewModel初始化，BaseVMActivity重写方法1
  14.     override fun initVM(): HomeViewModel = HomeViewModel()
  15.     //指定xml布局id，BaseVMActivity重写方法2
  16.     override fun provideContentViewId(): Int = R.layout.tablet_activity_category
  17.  
  18.     override fun onCreate(savedInstanceState: Bundle?) {
  19.         super.onCreate(savedInstanceState)
  20.         initRecyclerView()
  21.         initData()
  22.     }
  23.  
  24.     private fun initData() {
  25.         //判断跳转前是否携带CATEGORY_ID参数
  26.         intent.getStringExtra(CATEGORY_ID)?.let {
  27.             if (it.isNotEmpty()) {
  28.                 //调用getCategoryContentList()的网络请求接口
  29.                 viewModel.getCategoryContentList(it)
  30.             }
  31.         }
  32.         //tv_title自动绑定视图 是在app/build.gradle 中开启了buildFeatures { dataBinding = true }
  33.         intent.getStringExtra(CATEGORY_TITLE)?.let {
  34.             tv_title.text = it
  35.         }
  36.     }
  37.     
  38.     //recyclerView的初始化
  39.     private fun initRecyclerView() {
  40.         categoryAdapter = TabletCategoryAdapter()
  41.         recycler_view.layoutManager = GridLayoutManager(this, 6)
  42.         recycler_view.addItemDecoration(
  43.             GridSpacingItemDecoration(
  44.                 6, 6f.dpInt, false))
  45.         recycler_view.adapter = categoryAdapter
  46.         categoryAdapter?.setOnItemClickListener { _, _, position ->
  47.             TabletVodDetailsActivity.actionActivity(this,
  48.                 categoryContentList[position].contentId,
  49.                 0)
  50.         }
  51.  
  52.         nav_back.setOnClickListener { finish() }
  53.     }
  54.     
  55.     //监听viewModel实现类中的LiveData数据，BaseVMActivity重写方法3
  56.     override fun startObserve() {
  57.         viewModel.categoryContentListData.observe(this, { categoryContentData ->
  58.             //categoryContentData即网络请求结果对象                                            
  59.             categoryContentData.contents.let {
  60.                 if (it.isNotEmpty()) {
  61.                     categoryContentList.addAll(it)
  62.                     //刷新数据
  63.                     categoryAdapter?.setList(it)
  64.                 }
  65.             }
  66.         })
  67.     }
  68. }
  1. ?xml version="1.0" encoding="utf-8"?>
  2. <layout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools">
  5.     <-- 生成TabletActivityCategoryBinding类的关键 -->
  6.     <data>
  7.  
  8.     </data>
  9.  
  10.     <androidx.constraintlayout.widget.ConstraintLayout
  11.         android:layout_width="match_parent"
  12.         android:layout_height="match_parent"
  13.         android:background="@drawable/theme_bg"
  14.         android:fitsSystemWindows="true">
  15.  
  16.         <ImageView
  17.             android:id="@+id/nav_back"
  18.             android:layout_width="32dp"
  19.             android:layout_height="32dp"
  20.             android:layout_marginStart="14dp"
  21.             android:clickable="true"
  22.             android:focusable="true"
  23.             android:padding="8dp"
  24.             android:src="@drawable/nav_back"
  25.             app:layout_constraintStart_toStartOf="parent"
  26.             app:layout_constraintTop_toTopOf="parent" />
  27.  
  28.         <TextView
  29.             android:id="@+id/tv_title"
  30.             android:layout_width="wrap_content"
  31.             android:layout_height="wrap_content"
  32.             android:textColor="@color/main_text_color"
  33.             android:textSize="24sp"
  34.             app:layout_constraintBottom_toBottomOf="@id/nav_back"
  35.             app:layout_constraintEnd_toEndOf="parent"
  36.             app:layout_constraintStart_toStartOf="parent"
  37.             app:layout_constraintTop_toTopOf="@id/nav_back" />
  38.  
  39.         <androidx.recyclerview.widget.RecyclerView
  40.             android:id="@+id/recycler_view"
  41.             android:layout_width="match_parent"
  42.             android:layout_height="match_parent"
  43.             android:layout_marginTop="34dp"
  44.             app:layoutManager="androidx.recyclerview.widget.GridLayoutManager"
  45.             app:layout_constraintEnd_toEndOf="parent"
  46.             app:layout_constraintStart_toStartOf="parent"
  47.             app:layout_constraintTop_toBottomOf="@id/nav_back"
  48.             app:spanCount="6"
  49.             tools:listitem="@layout/tablet_item_category_vertical" />
  50.  
  51.     </androidx.constraintlayout.widget.ConstraintLayout>
  52. </layout>

MVVM模式总结：

相关推荐

Android Jetpack 架构开发组件化应用实战

Android 组件化工程结构以及项目具体实施方案

一篇文章搞懂 Android 组件化

Android 彻底组件化—如何使用 Arouter

Android路由框架ARouter的集成、基本使用以及踩坑全过程

我是code小生，喜欢可以随手点个在看、转发给你的朋友，谢谢~

  1.  
  2. 如果你有写博客的好习惯
  3. 欢迎投稿
点个“在看”小生感恩❤️
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/701468
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号