Kotlin Android 开发脚手架封装

Kotlin Android 开发脚手架封装（模块化版本）

我将按照模块化设计原则，将脚手架拆分为多个文件，每个文件负责特定功能领域：

1. 核心初始化模块

文件路径: core/AppScaffold.kt

object AppScaffold {

    lateinit var context: Context
        private set

    fun initialize(appContext: Context) {
        context = appContext.applicationContext
        initLogger()
        NetworkModule.init(context)
        DatabaseModule.init(context)
        PreferencesModule.init(context)
        WorkManagerModule.init(context)
        AnalyticsModule.init()
        CrashReportingModule.init()
    }

    private fun initLogger() {
        Timber.plant(if (BuildConfig.DEBUG) Timber.DebugTree() else ReleaseLogTree())
    }

    private class ReleaseLogTree : Timber.Tree() {
        override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {
            // 生产环境日志实现（可集成Firebase/Crashlytics等）
        }
    }
}

2. 网络模块

文件路径: network/NetworkModule.kt

object NetworkModule {

    lateinit var retrofit: Retrofit
        private set

    fun init(context: Context) {
        retrofit = Retrofit.Builder()
            .baseUrl(BuildConfig.BASE_URL)
            .client(createOkHttpClient(context))
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(CoroutineCallAdapterFactory())
            .build()
    }

    private fun createOkHttpClient(context: Context): OkHttpClient {
        return OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .addInterceptor(LoggingInterceptor())
            .addInterceptor(AuthInterceptor())
            .addInterceptor(ConnectivityInterceptor(context))
            .build()
    }

    inline fun <reified T> createService(): T = retrofit.create(T::class.java)
}

3. 数据库模块

文件路径: persistence/DatabaseModule.kt

object DatabaseModule {

    lateinit var database: AppDatabase
        private set

    fun init(context: Context) {
        database = Room.databaseBuilder(
            context,
            AppDatabase::class.java, "app-database"
        ).fallbackToDestructiveMigration()
            .build()
    }
}

4. 偏好设置模块

文件路径: persistence/PreferencesModule.kt

object PreferencesModule {

    lateinit var preferences: SharedPreferences
        private set

    fun init(context: Context) {
        preferences = EncryptedSharedPreferences.create(
            context,
            "secure_preferences",
            MasterKey.Builder(context).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build(),
            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
        )
    }
}

// 文件路径: `persistence/SessionManager.kt`
object SessionManager {
    var accessToken: String?
        get() = PreferencesModule.preferences.getString("access_token", null)
        set(value) = PreferencesModule.preferences.edit().putString("access_token", value).apply()
    
    var userId: Long
        get() = PreferencesModule.preferences.getLong("user_id", -1L)
        set(value) = PreferencesModule.preferences.edit().putLong("user_id", value).apply()
}

5. 后台任务模块

文件路径: work/WorkManagerModule.kt

object WorkManagerModule {

    lateinit var workManager: WorkManager
        private set

    fun init(context: Context) {
        workManager = WorkManager.getInstance(context)
    }

    fun schedulePeriodicSync() {
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .setRequiresBatteryNotLow(true)
            .build()

        val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(
            repeatInterval = 1, 
            repeatIntervalTimeUnit = TimeUnit.HOURS
        ).setConstraints(constraints)
         .build()

        workManager.enqueueUniquePeriodicWork(
            "syncWork",
            ExistingPeriodicWorkPolicy.KEEP,
            syncRequest
        )
    }
}

6. 分析模块

文件路径: analytics/AnalyticsModule.kt

object AnalyticsModule {

    fun init() {
        // 初始化Firebase/Mixpanel等分析工具
    }

    fun trackEvent(eventName: String, params: Map<String, Any> = emptyMap()) {
        // 事件跟踪实现
    }
}

7. 崩溃报告模块

文件路径: crashreporting/CrashReportingModule.kt

object CrashReportingModule {

    fun init() {
        // 初始化Firebase Crashlytics/Sentry等
    }
}

8. 扩展函数模块

文件路径: extensions/ContextExtensions.kt

fun Context.showToast(message: String, duration: Int = Toast.LENGTH_SHORT) {
    Toast.makeText(this, message, duration).show()
}

fun Context.isNetworkAvailable(): Boolean {
    val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = connectivityManager.activeNetwork
    val capabilities = connectivityManager.getNetworkCapabilities(network)
    return capabilities != null && 
           (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR))
}

9. 资源管理模块

文件路径: core/ResourceManager.kt

object ResourceManager {

    fun getString(@StringRes resId: Int, vararg args: Any): String {
        return AppScaffold.context.getString(resId, *args)
    }
    
    fun getColor(@ColorRes resId: Int): Int {
        return ContextCompat.getColor(AppScaffold.context, resId)
    }
}

10. 依赖注入模块

文件路径: di/ServiceLocator.kt

object ServiceLocator {
    private val services = mutableMapOf<String, Any>()
    
    inline fun <reified T : Any> register(instance: T) {
        services[T::class.java.name] = instance
    }
    
    inline fun <reified T : Any> get(): T {
        return services[T::class.java.name] as? T
            ?: throw IllegalStateException("Service ${T::class.java.name} not registered")
    }
}

11. MVVM架构基础

文件路径: architecture/BaseActivity.kt

abstract class BaseActivity : AppCompatActivity() {
    abstract val layoutId: Int
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(layoutId)
        initView()
        initData()
        observeViewModel()
    }
    
    open fun initView() {}
    open fun initData() {}
    open fun observeViewModel() {}
}

文件路径: architecture/BaseViewModel.kt

abstract class BaseViewModel : ViewModel() {
    private val _isLoading = MutableLiveData<Boolean>()
    val isLoading: LiveData<Boolean> = _isLoading
    
    private val _errorMessage = MutableLiveData<String>()
    val errorMessage: LiveData<String> = _errorMessage
    
    protected fun showLoading() {
        _isLoading.postValue(true)
    }
    
    protected fun hideLoading() {
        _isLoading.postValue(false)
    }
    
    protected fun showError(message: String) {
        _errorMessage.postValue(message)
        hideLoading()
    }
}

12. 工具类模块

文件路径: utils/SecurityUtils.kt

object SecurityUtils {
    fun encrypt(data: String): String {
        // AES加密实现
    }
    
    fun decrypt(encryptedData: String): String {
        // AES解密实现
    }
}

文件路径: utils/ThemeManager.kt

object ThemeManager {
    fun applyTheme(context: Context, themeRes: Int) {
        context.setTheme(themeRes)
        // 动态主题应用逻辑
    }
}

使用示例

文件路径: MyApplication.kt

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        AppScaffold.initialize(this)
        // 注册服务
        ServiceLocator.register(DataRepositoryImpl())
    }
}

文件路径: MainActivity.kt

class MainActivity : BaseActivity() {
    override val layoutId = R.layout.activity_main

    private val viewModel: MainViewModel by viewModels()

    override fun initData() {
        viewModel.loadData()
    }

    override fun observeViewModel() {
        viewModel.data.observe(this) { data ->
            // 处理数据
        }
    }
}

项目结构

app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           ├── core/
│   │   │           │   ├── AppScaffold.kt
│   │   │           │   └── ResourceManager.kt
│   │   │           ├── network/
│   │   │           │   ├── NetworkModule.kt
│   │   │           │   └── interceptors/
│   │   │           ├── persistence/
│   │   │           │   ├── DatabaseModule.kt
│   │   │           │   ├── PreferencesModule.kt
│   │   │           │   └── SessionManager.kt
│   │   │           ├── work/
│   │   │           │   └── WorkManagerModule.kt
│   │   │           ├── analytics/
│   │   │           │   └── AnalyticsModule.kt
│   │   │           ├── crashreporting/
│   │   │           │   └── CrashReportingModule.kt
│   │   │           ├── di/
│   │   │           │   └── ServiceLocator.kt
│   │   │           ├── architecture/
│   │   │           │   ├── BaseActivity.kt
│   │   │           │   └── BaseViewModel.kt
│   │   │           ├── extensions/
│   │   │           │   └── ContextExtensions.kt
│   │   │           ├── utils/
│   │   │           │   ├── SecurityUtils.kt
│   │   │           │   └── ThemeManager.kt
│   │   │           ├── MyApplication.kt
│   │   │           └── MainActivity.kt
│   │   └── res/

这种模块化设计具有以下优点：

1. 高内聚低耦合：每个模块专注于单一职责
2. 易于维护：修改一个模块不影响其他功能
3. 可扩展性强：添加新功能只需添加新模块
4. 便于团队协作：不同开发者可并行开发不同模块
5. 测试友好：模块可单独进行单元测试

这个脚手架封装了Android开发的核心基础设施，遵循现代Android开发最佳实践，可显著提高开发效率和代码质量。