【Android】数据分层和依赖注入

一. 添加仓库和手动依赖注入

1.1. 拆分界面层和数据层

将代码拆分为不同的层可让您的应用具备更高的可伸缩性、更加稳定可靠、更易于测试。为不同的层定义清晰的边界还有助于多个开发者更轻松地开发同一应用,而不会对彼此产生负面影响

什么是数据层?

数据层负责应用的业务逻辑以及为应用寻源和保存数据。数据层使用单向数据流模式向界面层公开数据。数据可能来自多个来源,例如网络请求、本地数据库或设备上的文件。

一个应用甚至可能有多个数据源。当应用打开时,它会从设备上的本地数据库(第一个来源)检索数据。当应用运行时,它会向第二个来源发出网络请求以检索较新的数据。

通过将数据与界面代码放在不同的层中,您可以在代码的某一部分进行更改,而不会影响其他部分。这种方法属于关注点分离的设计原则。一段代码侧重于自身的关注点,并封装其内部运行,与其他代码相隔离。封装用于向代码的其他部分隐藏其内部运行。当一段代码需要与另一段代码进行交互时,就需要通过接口来实现。

界面层的关注点是显示所提供的数据。界面不再检索数据,因为这是数据层的关注点。

数据层由一个或多个仓库组成。仓库本身包含零个或多个数据源。

按照最佳实践,你应该为应用所使用的每种数据源类型都提供一个仓库。

在此应用中,只有一个数据源, 所以这里也只有一个仓库。对于此应用,从互联网检索数据的仓库将完成数据源的职责。为此,它会向API

发出网络请求。如果数据源码比较复杂或者添加了额外的数据源,则数据源职责会被封装在单独的数据源类中,而仓库将负责管理所有的数据源。

什么是仓库?

通常仓库的作用包括:

  • 向应用的其余部分公开数据
  • 集中管理数据的更改
  • 解决多个数据之间的冲突
  • 对应用其余部分的数据源进行抽象化处理
  • 存放业务逻辑

MarsPhoto应用只有一个数据源,即网络API的调用。它只检索数据因此没有任何业务逻辑。数据通过仓库类公开提供给应用,该类会对数据源进行抽象化处理。

1.2. 创建数据层

首先,您需要创建仓库类。Android 开发者指南指出,仓库类以其所负责的数据命名。仓库命名惯例是数据类型 + 仓库。

仓库实现代码:

kotlin 复制代码
package com.example.marsphotos.data

import com.example.marsphotos.model.MarsPhoto
import com.example.marsphotos.network.MarsApi
import kotlinx.serialization.InternalSerializationApi

interface MarsPhotosRepository {

    // 创建一个获取数据的抽象函数,该函数会返回MarsPhoto对象的列表。 系统将通过协程来调用它,因此请使用suspend进行声明。
    @OptIn(InternalSerializationApi::class)
    suspend fun getMarsPhotos(): List<MarsPhoto>
}

// 创建一个实现类, 实现上述的仓库的接口
class NetworkMarsPhotosRepository(): MarsPhotosRepository {
    @OptIn(InternalSerializationApi::class)
    override suspend fun getMarsPhotos(): List<MarsPhoto> {
        return MarsApi.retrofitService.getPhotos()
    }

}

ViewModel中需要做如下修改:

kotlin 复制代码
 @OptIn(InternalSerializationApi::class)
    fun getMarsPhotos() {
        viewModelScope.launch {
            marsUiState = MarsUiState.Loading
            marsUiState = try {
            // 这里使用数据仓库代替原来的直接调用底层API接口获取数据。改用从仓库获取数据。
                val marsPhotosRepository = NetworkMarsPhotosRepository()
                val listResult = marsPhotosRepository.getMarsPhotos()
                MarsUiState.Success(
                    "Success: ${listResult.size} Mars photos retrieved"
                )
            } catch (e: IOException) {
                MarsUiState.Error
            } catch (e: HttpException) {
                MarsUiState.Error
            }
        }
    }

然后运行项目, 显示的结果应该和之前是一样的。

仓库将提供数据,而不是有ViewModel直接出关于数据的网络请求。ViewModel不在直接引用MarsApi代码

此方法有助于让代码检索与ViewModel松散耦合的数据。通过松散耦合,您可以对ViewModel或仓库进行更改,而不会对其他部分产生不利影响,只要仓库具有名为getMarsPhotos()函数即可。

现在,我们可以在不影响调用方的情况下更改仓库内的实现。对于大型应用,此变更可支持多个调用方

1.3. 依赖注入

很多时候,类都需要其他类的对象才能正常运行。如果需要另外一个类,则所需的类称为依赖项。

在以下示例中,Car 对象依赖于 Engine 对象。

类可通过两种方法获取这些所需对象。一种方法是让类实例化所需的对象本身。

kotlin 复制代码
interface Engine {
    fun start()
}

class GasEngine : Engine {
    override fun start() {
        println("GasEngine started!")
    }
}

class Car {

    private val engine = GasEngine()

    fun start() {
        engine.start()
    }
}

fun main() {
    val car = Car()
    car.start()
}

另一种方法是将所需的对象作为实参传入。

kotlin 复制代码
interface Engine {
    fun start()
}

class GasEngine : Engine {
    override fun start() {
        println("GasEngine started!")
    }
}

class Car(private val engine: Engine) {
    fun start() {
        engine.start()
    }
}

fun main() {
    val engine = GasEngine()
    val car = Car(engine)
    car.start()
}

让类实例化所需的对象很简单,但是这种方法会导致代码不够灵活且更加难以测试,因为类所需要的对象是紧密耦合的。

调用类需要对象的构造方法,集中包含实现细节。如果构造函数发生更改,调用代码也需要更改。

为了提升代码的灵活性和适应性,类不得对其依赖的对象进行实例化。它所依赖的对象必须在类的外部进行实例化,然后在传入。这种方法可以创建更灵活的代码,因为类不在硬编码到特定的对象中。可以对所需对象的实现进行更改,而无需修改调用代码。

继续修改上面的代码:

kotlin 复制代码
interface Engine {
    fun start()
}

class ElectricEngine : Engine {
    override fun start() {
        println("ElectricEngine started!")
    }
}

class Car(private val engine: Engine) {
    fun start() {
        engine.start()
    }
}

fun main() {
    val engine = ElectricEngine()
    val car = Car(engine)
    car.start()
}

传入所需对象的过程称为依赖注入(DI).这种方法也称为控制反转。

依赖注入是指在运行时提供依赖,而不是将其硬编码到其中。

实现依赖注入:

  • 有助于提高代码的可重用性,代码不依赖特定对象,从而提高灵活性
  • 使用重够更轻松。代码是松散耦合的,因此重构一段代码不会影响另外一段代码
  • 有助于进行测试。可以在测试期间传入测试对象。

我们希望能够对ViewModel进行测试,但它目前依赖于进行实际的网络请求调用的仓库。使用真是的仓库进行测试,系统进行许多网络调用。若要解决此问题,我们需要能够决定并传递用于动态生产和测试的仓库实例,而不是由ViewModel来创建仓库。

实现此流程的方法是实现一个为MarsViewModel提供仓库的容器

容器是一个包含所需依赖项的对象。这些依赖项在整个项目中使用,因此它们必须位于所有Activity可以使用的通用位置。这样可以创建Application类的子类并存储对容器的引用。

创建依赖容器

  1. 创建容器接口类
  2. 在 AppContainer 接口内,添加一个名为 marsPhotosRepository 且类型为 MarsPhotosRepository 的抽象属性
kotlin 复制代码
interface AppContainer {
    val marsPhotosRepository: MarsPhotosRepository
}
  1. 在接口定义,创建一个名为DefaultAppContainer类来实现AppContainer接口,并且把network/MarsApiService.kt 文件中的网络请求代码转移到DefaultAppContainer类,让他们都用于维护在依赖中的容器中。

1.4. 将容器附加到应用

  1. 创建MarsPhotosApplication类,此类是继承自应用对象,因此你需要将类添加到类的申明中
kotlin 复制代码
package com.example.marsphotos

import android.app.Application
import com.example.marsphotos.data.AppContainer
import com.example.marsphotos.data.DefaultAppContainer

class MarsPhotosApplication: Application() {
    // 声明一个AppContainer类型的变量,用于存储DefaultAppContainer对象,该变量会在调用onCreate()期间初始化。
    // 因此需要lateinit关键字来修饰
    lateinit var container : AppContainer
    override fun onCreate() {
        super.onCreate()
        container = DefaultAppContainer()
    }
}
  1. 需要更新Android中的清单,以便应用使用您刚才定义的应用类。打开 manifests/AndroidManifest.xml 文件
  2. 在application部分,添加值为应用类名称".MarsPhotosApplication""的android:name属性

1.5 将仓库添加到ViewModel

当我们做完上述操作后, ViewModel可以调用仓库对象来检索网络数据了。

ViewModel的代码,需要做如下修改:

kotlin 复制代码
/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.example.marsphotos.ui.screens

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.marsphotos.MarsPhotosApplication
import com.example.marsphotos.data.MarsPhotosRepository
import com.example.marsphotos.model.MarsPhoto
import kotlinx.coroutines.launch
import kotlinx.serialization.InternalSerializationApi
import retrofit2.HttpException
import java.io.IOException

/**
 * UI state for the Home screen
 */
sealed interface MarsUiState {
    data class Success(val photos: String) : MarsUiState
    object Error : MarsUiState
    object Loading : MarsUiState
}

class MarsViewModel(private  val marsPhotosRepository: MarsPhotosRepository) : ViewModel() {
// ....
    @OptIn(InternalSerializationApi::class)
    fun getMarsPhotos() {
        viewModelScope.launch {
            marsUiState = MarsUiState.Loading
            marsUiState = try {
            // 使用传递进来的仓库获取数据
                val listResult = marsPhotosRepository.getMarsPhotos()
                MarsUiState.Success(
                    "Success: ${listResult.size} Mars photos retrieved"
                )
            } catch (e: IOException) {
                MarsUiState.Error
            } catch (e: HttpException) {
                MarsUiState.Error
            }
        }
    }

    // 由于Android框架不允许在创建时向构造函数中的ViewModel传递值,
    // 因此我们实现一个ViewModelProvider.Factory的对象来绕过此限制
    // 有了伴生对象,我们便有了一个可供所有人使用的单一对象实例,而无需创建新的对象实例,从而避免增加开销。这是实现细节。在对其进行分离之后,我们可以轻松做出更改,而不会影响应用代码的其他部分。
    companion object {
        val Factory: ViewModelProvider.Factory = viewModelFactory {
            initializer {
                val application = (this[APPLICATION_KEY] as MarsPhotosApplication)
                val marsPhotosRepository = application.container.marsPhotosRepository
                MarsViewModel(marsPhotosRepository = marsPhotosRepository)
            }
        }
    }
}

APPLICATION_KEY 是 ViewModelProvider.AndroidViewModelFactory.Companion 对象的一部分,用于查找应用的 MarsPhotosApplication 对象,该对象具有 container 属性,用于检索依赖项注入所使用的仓库。

然后我们在使用ViewModel的地方,需要使用工厂方法来创建viewmodel对象

kotlin 复制代码
Surface(
            // ...
        ) {
            val marsViewModel: MarsViewModel =
   viewModel(factory = MarsViewModel.Factory)
            // ...
        }

此 marsViewModel 变量由对 viewModel() 函数的调用进行填充,该函数会将伴生对象中的 MarsViewModel.Factory 作为实参传递以创建 ViewModel

流程图总结:

1.6 本地测试

首先需要在app/build.gradle.kts中添加本地测试依赖项:

kotlin 复制代码
testImplementation("junit:junit:4.13.2")
testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.1")

然后创建测试目录:

  1. 创建一个本地测试目录,具体方法为:右键点击项目视图中的 src 目录,然后依次选择 New > Directory > test/java
  2. 在该测试目录中创建一个名为 com.example.marsphotos 的新软件包。

1.6.1. 为测试创建虚构数据和依赖项

接下来我们将学习如何依赖注入如何帮助您编写本地测试。上面创建了一个来API服务的仓库,然后修改了ViewModel,使其依赖仓库。

每个本地测试只需测试一项内容。例如,在测试视图模型的功能时,您不希望测试仓库或 API 服务的功能。同样,在测试仓库时,您不希望测试 API 服务。

通过使用接口并随后使用依赖项注入来包含从这些接口继承的类,您可以使用仅用于测试用途的虚构类来模拟这些依赖项的功能。通过注入虚构类和数据源来进行测试,您可以在隔离环境中单独测试代码,同时确保代码的可重复性和一致性。

首先,你需要再稍后创建的虚拟类中使用的虚构数据

数据类:

kotlin 复制代码
package com.example.marsphotos.fake

import com.example.marsphotos.model.MarsPhoto
import kotlinx.serialization.InternalSerializationApi

object FakeDataSource {
    const val idOne = "img1"
    const val idTwo = "img2"
    const val imgOne = "url.1"
    const val imgTwo = "url.2"
    @OptIn(InternalSerializationApi::class)
    val photosList = listOf(
        MarsPhoto(
            id = idOne,
            imgSrc = imgOne
        ),
        MarsPhoto(
            id = idTwo,
            imgSrc = imgTwo
        )
    )
}

要创建仓库测试,必须通过一个虚构 API 服务来返回您刚才创建的虚构数据。将此虚构 API 服务传入仓库之后,仓库会在系统调用虚构 API 服务中的方法时收到虚构数据。

服务类:

kotlin 复制代码
package com.example.marsphotos.fake

import com.example.marsphotos.model.MarsPhoto
import com.example.marsphotos.network.MarsApiService
import kotlinx.serialization.InternalSerializationApi

class FakeMarsApiService: MarsApiService {
    @OptIn(InternalSerializationApi::class)
    override suspend fun getPhotos(): List<MarsPhoto> {
        return FakeDataSource.photosList
    }
}

1.6.2. 编写仓库测试

在本部分中,您将测试 NetworkMarsPhotosRepository 类的 getMarsPhotos() 方法。

  1. 我们需要创建一个测试仓库类:NetworkMarsRepositoryTest
  2. 创建一个测试方法:networkMarsPhotosRepository_getMarsPhotos_verifyPhotoList
  3. 实现函数,创建一个NetworkMarsPhotosRepository的实例,并将FakeMarsApiService作为marsApiService形参传递

通过传递虚构的API服务,对仓库中的marsApiService属性任何调用都会导致调用FakeMarsApiService。通过依赖项传递虚构类,您可以精确控制依赖项返回的结果。这种方法可以确保您测试的代码不依赖于可能未经测试的代码或 API,因为这些代码或 API 可能会发生变化或出现意外问题。即使您所编写的代码没有任何问题,此类情况也可能会导致测试失败。虚构测试有助于创建更一致的测试环境、减少测试不稳定问题,以及简化针对单一功能的测试。

kotlin 复制代码
package com.example.marsphotos

import com.example.marsphotos.data.NetworkMarsPhotosRepository
import com.example.marsphotos.fake.FakeDataSource
import com.example.marsphotos.fake.FakeMarsApiService
import kotlinx.serialization.InternalSerializationApi
import org.junit.Assert.assertEquals
import org.junit.Test

class NetworkMarsRepositoryTest {

    @OptIn(InternalSerializationApi::class)
    @Test
    fun networkMarsPhotosRepository_getMarsPhotos_verifyPhotoList() {
        val repository = NetworkMarsPhotosRepository(marsApiService = FakeMarsApiService())
        // 断言 getMarsPhotos() 方法返回的数据等于 FakeDataSource.photosList
        assertEquals(FakeDataSource.photosList, repository.getMarsPhotos())
    }
}

目前代码有如下报错:

报错的原因是在 data/MarsPhotosRepository.kt 中,查看 NetworkMarsPhotosRepository 中的 getMarsPhotos() 实现,您会看到 getMarsPhotos() 函数是一个挂起函数。

当您从 MarsViewModel 调用此函数时,系统将通过一个协程来调用此方法,即通过传递到 viewModelScope.launch() 的 lambda 来进行调用。此外,您还需要在测试中通过协程来调用挂起函数。

1.6.3. 测试协程

修改测试方法, 以便运行协程测试方法:

  1. 修改测试函数networkMarsPhotosRepository_getMarsPhotos_verifyPhotoList为表达式
  2. 将表达式设置为等于 runTest() 函数。此方法需要 lambda。

协程测试库提供 runTest() 函数。该函数接受您在 lambda 中传递的方法,并通过 TestScope(从 CoroutineScope 继承而来)运行该方法。

注意:为便于您参考,在您创建的 ViewModel 中调用仓库时,您可以使用 viewModelScope(最终为 CoroutineScope)来调用 getMarsPhotos()。

kotlin 复制代码
class NetworkMarsRepositoryTest {

    @OptIn(InternalSerializationApi::class)
    @Test
    fun networkMarsPhotosRepository_getMarsPhotos_verifyPhotoList() = runTest {
        val repository = NetworkMarsPhotosRepository(marsApiService = FakeMarsApiService())
        assertEquals(FakeDataSource.photosList, repository.getMarsPhotos())
    }
}

1.6.4. 编写ViewModel的测试

我们将通过MarsViewModel为getMarsPhotos()函数编写一项测试。MarsViewModel依赖于MarsPhotosRepository。因此,如需编写测试,您需要创建一个虚构的MarsPhotosRepository。此外,除了使用 runTest() 方法之外,还需要为协程考虑一些额外的步骤。

创建虚构仓库

虚构仓库(FakeNetworkMarsPhotosRepository)示例代码:

kotlin 复制代码
package com.example.marsphotos.fake

import com.example.marsphotos.data.MarsPhotosRepository
import com.example.marsphotos.model.MarsPhoto
import kotlinx.serialization.InternalSerializationApi

class FakeNetworkMarsPhotosRepository: MarsPhotosRepository {
    @OptIn(InternalSerializationApi::class)
    override suspend fun getMarsPhotos(): List<MarsPhoto> {
        return FakeDataSource.photosList
    }
}

ViewModel的测试类:

kotlin 复制代码
package com.example.marsphotos

import com.example.marsphotos.fake.FakeDataSource
import com.example.marsphotos.fake.FakeNetworkMarsPhotosRepository
import com.example.marsphotos.ui.screens.MarsUiState
import com.example.marsphotos.ui.screens.MarsViewModel
import kotlinx.coroutines.test.runTest
import kotlinx.serialization.InternalSerializationApi
import org.junit.Assert.assertEquals
import org.junit.Test

class MarsViewModelTest {
    @OptIn(InternalSerializationApi::class)
    @Test
    fun marsViewModel_getMarsPhotos_verifyMarsUiStateSuccess() = runTest {
        // 创建一个ViewModel,然后传递我们创建的虚构仓库
        val marsViewModel = MarsViewModel(FakeNetworkMarsPhotosRepository())
        // 断言ViewModel实例的marsUiState与成功调用的FakeNetworkMarsPhotosRepository的结果匹配
        assertEquals(
            MarsUiState.Success("Success: ${FakeDataSource.photosList.size} Mars " +
                    "photos retrieved"),
            marsViewModel.marsUiState
        )
    }
}

如果你想运行这个测试方法, 会发生报如下错误:

kotlin 复制代码
Exception in thread "Test worker @coroutine#1" java.lang.IllegalStateException: Module with the Main dispatcher had failed to initialize. For tests Dispatchers.setMain from kotlinx-coroutines-test module can be used

回想一下,ViewModel使用viewModelScope.launch()调用仓库。此指令会在默认协程调度(称为Main调度程序)下启动一个新的协程。Main调度程序会封装Android界面线程。出现此错误的原因是Android界面线程在单元测试中不可用。单元测试是在工作站(而非Android设备或者模拟器)上执行的。如果本地单元测试的代码引用Main调度程序,则在单元测试时会抛出异常(如上所示)。为解决问题,您需要在运行单元测试明确定义默认调度程序。

创建测试调度程序

由于Main调度程序仅适用于界面上下文,因此必须将其替换成支持单元测的调度程序。Kotlin协程库为此提供了一个名为TestDispatcher的协程调度程序。在任何创建新协程的单元测试中,都需要使用TestDispatcher(而非Main调度程序)类似于视图模型中的getMarsPhotos()函数。

如需在任何情况下将Main调度程序替换为TestDispatcher,请使用Dispatchers.setMain()函数。您可以使用Dispatchers.setMain()函数将线程调度程序重置为Main调度程序。为避免在每次测试中重复会用替换Main调度程序代码, 您可以将其提取到JUnit测试规则中。TestRule提供了一种控制运行测试的环境的方法。TestRule可能会添加其他检查,对是执行必要的设置或清理,或者观察测试作业以向其他位置报告。可以在测试类之间轻松共享这些测试规则。

创建一个专有类来编写 TestRule在这里插入代码片 以替换 Main 调度程序。如需实现自定义 TestRule,请完成以下步骤:

  1. 在测试目录创建一个名为rules的新软件包
  2. 在rules目录中,新建一个名为TestDispatcherRule的类
  3. 使用TestWatcher扩展TestDispatcherRule。借助TestWatcher类, 你可以在不同执行阶段执行操作。
kotlin 复制代码
package com.example.marsphotos.rules

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.rules.TestWatcher
import org.junit.runner.Description

class TestDispatcherRule @OptIn(ExperimentalCoroutinesApi::class) constructor(
// 此形参可让您使用不同的调度程序,例如 StandardTestDispatcher。此构造函数形参需要将默认值设置为 UnconfinedTestDispatcher 对象的实例。UnconfinedTestDispatcher 类继承自 TestDispatcher 类,并指定不得以任何特定顺序执行任务。这种执行模式适用于简单的测试,因为系统会自动处理协程。与 UnconfinedTestDispatcher 不同,StandardTestDispatcher 类可以支持对协程执行进行全面的控制。这种方法更适合需要手动方法的复杂测试,
    val testDispatcher: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {

    @OptIn(ExperimentalCoroutinesApi::class)
    override fun starting(description: Description?) {
        Dispatchers.setMain(testDispatcher)
    }

    @OptIn(ExperimentalCoroutinesApi::class)
    override fun finished(description: Description?) {
        Dispatchers.resetMain()
    }
}

定义的 TestDispatcherRule对象已可供重复使用, 我们需要再ViewMode中对 TestDispatcherRule 类进行实例化并将其分配给 testDispatcher 只读属性。

kotlin 复制代码
class MarsViewModelTest {

    // 声明成只读属性, 只需加这个注解即可
    @get:Rule
    val testDispatcher = TestDispatcherRule()
    }
相关推荐
传奇开心果编程1 小时前
【Jetpack Compose娓娓道来】第44课:持久化——让数据“关掉App也不丢”
android·kotlin·移动开发·数据持久化·jetpack compose·ui框架·声明式ui
星空孤辰2 小时前
【camera 008】android camera id 注册、状态监控等状态变化 全流程梳理
android·windows
恋猫de小郭3 小时前
iOS for Web ,把原生 iOS App 跑到进浏览器里面,倒反天罡
android·前端·ios
思想觉悟4 小时前
Android启动流程之点rc文件
android·linux·面试
_祝你今天愉快15 小时前
Android 高级绘制:[四] Canvas-实际案例操作
android
三少爷的鞋15 小时前
Android 工程师的技术信仰崩塌史
android
AirDroid_cn18 小时前
Android 15 权限回溯:已授予的麦克风权限如何批量回收?
android
Mr_万能胶18 小时前
官方发布,不烧心的 AOSP 编译提速技巧
android·ci/cd·架构
booboosui19 小时前
安卓 8.1 也能装了:代价是一条黄字和两个静默 bug
android