kotlin-android-extensions 外掛將被正式移除，如何無縫遷移？

---

theme: smartblue highlight: a11y-dark

---

前言

kotlin-android-extensions 外掛早在 2020 年就已經被宣佈廢棄了，並且將在 Kotlin 1.8 中被正式移除：Discontinuing Kotlin synthetics for views

如上圖示，移除 kotlin-android-extensions 的程式碼已經被 Merge 了，因此如果我們需要升級到 Kotlin 1.8，則必須要移除 KAE

那麼移除 kotlin-android-extensions 後，我們該如何遷移呢？

遷移方案

官方的遷移方案如上所示，官方建議我們老專案遷移到 ViewBinding，新專案直接遷移到 Jetpack Compose

對於新程式碼我們當然可以這麼做，但是對於大量存量程式碼，我們該如何遷移？由於 KAE 簡單易用的特性，它在專案中經常被大量使用，要遷移如此多的存量程式碼，並不是一個簡單的工作

存量程式碼遷移方案

KAE 存量程式碼主要有如圖3種遷移方式

最簡單也最直接的當然就是直接手動修改，這種方式的問題在於要遷移的程式碼數量龐大，遷移成本高。同時手動遷移容易出錯，也不容易回測，測試不能覆蓋到所有的頁面，導致引入線上 bug

第二個方案，是把 KAE 直接從 Kotlin 原始碼中抽取出來單獨維護，但是 KAE 中也大量依賴了 Kotlin 的原始碼，抽取成本較高。同時 KAE 中大量使用了 Kotlin 編譯器外掛的 API，而這部分 API 並沒有穩定，當 K2 編譯器正式釋出的時候很可能還會有較大的改動，而這也帶來較高的維護成本。

第三個方案就是本篇要重點介紹的 Kace

Kace 是什麼？

Kace 即 kotlin-android-compatible-extensions，一個用於幫助從 kotlin-android-extensions 無縫遷移的框架

目前已經開源，開源地址可見：https://github.com/kanyun-inc/Kace

相比其它方案，Kace 主要有以下優點

1. 接入方便，不需要手動修改舊程式碼，可以真正做到無縫遷移
2. 與 KAE 表現一致(都支援 viewId 快取，並在頁面銷燬時清除)，不會引入預期外的 bug
3. 統一遷移，回測方便，如果存在問題時，應該是批量存在的，避免手動修改可能引入線上 bug 的問題
4. 通過生成原始碼的方式相容 KAE，維護成本低

快速遷移

使用 Kace 完成遷移主要分為以下幾步

1. 新增外掛到 classpath

```kotlin // 方式 1 // 傳統方式，在根目錄的 build.gradle.kts 中新增以下程式碼 buildscript { repositories { mavenCentral() } dependencies { classpath("com.kanyun.kace:kace-gradle-plugin:1.0.0") } }

// 方式 2 // 引用外掛新方式，在 settings.gradle.kts 中新增以下程式碼 pluginManagement { repositories { mavenCentral() } plugins { id("com.kanyun.kace") version "1.0.0" apply false } } ```

2. 應用外掛

移除kotlin-android-extensions外掛，並新增以下程式碼

kotlin plugins { id("com.kanyun.kace") id("kotlin-parcelize") // 可選，當使用了`@Parcelize`註解時需要新增 }

3. 配置外掛（可選）

預設情況下 Kace 會解析模組內的每個 layout 並生成程式碼，使用者也可以自定義需要解析的 layout

kotlin kace { whiteList = listOf() // 當 whiteList 不為空時，只有 whiteList 中的 layout 才會被解析 blackList = listOf("activity_main.xml") // 當 blackList 不為空時，blackList 中的 layout 不會被解析 }

經過以上幾步，遷移就完全啦~

支援的型別

如上所示，Kace 目前支援了以上四種最常用的型別，其他 kotlin-android-extensions 支援的型別如 android.app.Fragment, android.app.Dialog, kotlinx.android.extensions.LayoutContainer 等，由於被廢棄或者使用較少，Kace 目前沒有做支援

版本相容

| | Kotlin | AGP | Gradle | |--------|--------|-------|--------| | 最低支援版本 | 1.7.0 | 4.2.0 | 6.7.1 |

由於 Kace 的目標是幫助開發者更方便地遷移到 Kotlin 1.8，因此 Kotlin 最低支援版本比較高

原理解析：前置知識

編譯器外掛是什麼？

Kotlin 的編譯過程，簡單來說就是將 Kotlin 原始碼編譯成目標產物的過程，具體步驟如下圖所示：

Kotlin 編譯器外掛，通過利用編譯過程中提供的各種Hook時機，讓我們可以在編譯過程中插入自己的邏輯，以達到修改編譯產物的目的。比如我們可以通過 IrGenerationExtension 來修改 IR 的生成，可以通過 ClassBuilderInterceptorExtension 修改位元組碼生成邏輯

Kotlin 編譯器外掛可以分為 Gradle 外掛，編譯器外掛，IDE 外掛三部分，如下圖所示

kotlin-android-extensions 是怎麼實現的

我們知道，KAE 是一個 Kotlin 編譯器外掛，當然也可以分為 Gradle 外掛，編譯器外掛，IDE 外掛三部分。我們這裡只分析 Gradle 外掛與編譯器外掛的原始碼，它們的具體結構如下：

1. AndroidExtensionsSubpluginIndicator是KAE外掛的入口
2. AndroidSubplugin用於配置傳遞給編譯器外掛的引數
3. AndroidCommandLineProcessor用於接收編譯器外掛的引數
4. AndroidComponentRegistrar用於註冊如圖的各種Extension

關於更細節的分析可以參閱：kotlin-android-extensions 外掛到底是怎麼實現的？

總的來說，其實 KAE 主要做了兩件事

1. KAE 會將 viewId 轉化為 findViewByIdCached 方法呼叫
2. KAE 會在頁面關閉時清除 viewId cache

那麼我們要無縫遷移，就也要實現相同的效果

Kace 原理解析

第一次嘗試

我們首先想到的是解析 layout 自動生成擴充套件屬性，如下圖所示

```kotlin // 生成的程式碼 val AndroidExtensions.button1 get() = findViewByIdCached(R.id.button1)

val AndroidExtensions.buttion2 get() = findViewByIdCached(R.id.button1)

// 給 Activity 新增 AndroidExtensions 介面 class MainActivity : AppCompatActivity(), AndroidExtensions { private val androidExtensionImpl by lazy { AndroidExtensionsImpl() }

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    lifecycle.addObserver(androidExtensionImpl)
}

override fun <T : View?> findViewByIdCached(owner: AndroidExtensionsBase, id: Int): T {
    return androidExtensionImpl.findViewByIdCached(id)
}

} ```

如上所示，主要做了這麼幾件事：

1. 通過 gradle 外掛，自動解析 layout 生成AndroidExtensions介面的擴充套件屬性
2. 給 Activity 新增 AndroidExtensions 介面
3. 由於需要支援快取，因此也需要新增一個全域性的變數：androidExtensionImpl
4. 由於需要在頁面關閉時清除快取，因此也需要新增lifecycle Observer
5. 重寫findViewByIdCached方法，將具體工作委託給AndroidExtensionsImpl

通過以上步驟，其實 KAE 的功能已經實現了，我們可以在 Activity 中通過button1，button2等 viewId 獲取對應的 View

但是這樣還是太麻煩了，修改一個頁面需要新增這麼多程式碼，還能再優化嗎？

第二次嘗試

```kotlin private inline val AndroidExtensions.button1 get() = findViewByIdCached

(this, R.id.button1)

val AndroidExtensions.buttion2 get() = findViewByIdCached(this, R.id.button1)

class MainActivity : AppCompatActivity(), AndroidExtensions by AndroidExtensionsImpl() {

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
}

} ```

1. 我們通過委託簡化了程式碼呼叫，只需要新增一行AndroidExtensions by AndroidExtensionsImpl()就可以實現遷移
2. 我們不需要在初始化的時候手動新增lifecycle observer，這是因為我們在呼叫findViewByIdCached方法時會將this傳遞過去，因此可以在第一次呼叫時初始化，自動新增lifecycle observer

可以看出，現在已經比較簡潔了，只需要新增一行程式碼就可以實現遷移，但如果專案中有幾百個頁面使用了 KAE 的話，改起來還是有點痛苦的，目前還不能算是真正的無縫遷移

那麼還能再優化嗎?

第三次嘗試

第3次嘗試就是 Kace 的最終方案，結構如圖所示

下面我們就來介紹一下

kace-compiler 實現

kace-compiler 是一個 Kotlin 編譯器外掛，它的作用是給目標型別（Activity 或者 Fragment）自動新增介面與實現

如上所示，kace-compiler 的作用就是通過KaceSyntheticResolveExtension擴充套件新增介面，以及KaceIrGenerationExtension擴充套件新增實現

處理後的程式碼如下所示：

```kotlin class MainActivity : AppCompatActivity(), AndroidExtensions { private val $$androidExtensionImpl by lazy { AndroidExtensionsImpl() }

override fun <T : View?> findViewByIdCached(owner: AndroidExtensionsBase, id: Int): T {
    return $$androidExtensionImpl.findViewByIdCached(id)
}

} ```

你可能還記得，前面說過由於編譯器外掛 API 還沒有穩定，因此將 KAE 抽取出來獨立維護成本較高，那麼我們這裡為什麼還使用了編譯器外掛呢？

這是因為我們這裡使用的編譯器外掛是比較少的，生成的程式碼也很簡單，將來維護起來並不複雜，但是可以大幅的降低遷移成本，實現真正的無縫遷移

kace-gradle-plugin 生成程式碼

kace-gradle-plugin 的主要作用就是解析 layout 然後生成程式碼，生成的程式碼如下所示

```kotlin package kotlinx.android.synthetic.debug.activity_main

private inline val AndroidExtensionsBase.button1 get() = findViewByIdCached(this, R.id.button1) internal inline val Activity.button1 get() = (this as AndroidExtensionsBase).button1 internal inline val Fragment.button1 get() = (this as AndroidExtensionsBase).button1 ```

```kotlin package kotlinx.android.synthetic.main.activity_main.view

internal inline val View.button1 get() = findViewById(R.id.button1) ```

1. 給 Activity, Fragment, View 等型別新增擴充套件屬性
2. 給 View 新增的擴充套件屬性目前不支援快取，而是直接通過finidViewById實現
3. 支援根據不同的variant，生成不同的package的程式碼，比如debug

Kace 效能優化

明確輸入輸出

前面介紹了 kace-gradle-plugin 的主要作用就是解析 layout 然後生成程式碼，但是對於一個比較大的模組，layout 可能有幾百個，如果每次編譯時都要執行這個 Task，會帶來一定的效能損耗

理想情況下，在輸入輸出沒有發生變化的情況下，應該跳過這個 Task

比如 Gradle 中內建的 JavaCompilerTask，在原始碼與 jdk 版本沒有發生變化的時候，會自動跳過（標記為 up-to-date）

Gradle 需要我們明確 Task 的輸入與輸出是什麼，這樣它才能決定是否可以自動跳過這個Task，如下所示：

```kotlin abstract class KaceGenerateTask : DefaultTask() {

@get:Internal
val layoutDirs: ConfigurableFileCollection = project.files()

@get:Incremental
@get:InputFiles
@get:PathSensitive(PathSensitivity.RELATIVE)
internal open val androidLayoutResources: FileCollection = layoutDirs
    .asFileTree
    .matching { patternFilterable ->
        patternFilterable.include("**/*.xml")
    }

@get:Input
abstract val layoutVariantMap: MapProperty<String, String>

@get:Input
abstract val namespace: Property<String>

@get:OutputDirectory
abstract val sourceOutputDir: DirectoryProperty

} ```

如上所示，通過註解的方式明確了 Task 的輸入輸出，在輸入與輸出都沒有發生改變的時候，該 Task 會被標記為 up-to-date ，通過編譯避免的方式提高編譯效能

並行 Task

KaceGenerateTask的主要作用其實就是解析 layout 然後生成程式碼，每個 layout 都是相互獨立的，在這種情況下就特別適合使用並行 Task

要實現並行 Task，首先要將 Task 轉化為 Worker API

```kotlin abstract class KaceGenerateAction : WorkAction { interface Parameters : WorkParameters { val destDir: DirectoryProperty val layoutFile: RegularFileProperty val variantName: Property val namespace: Property }

override fun execute() {
    val item = LayoutItem(
        parameters.destDir.get().asFile,
        parameters.layoutFile.get().asFile,
        parameters.variantName.get()
    )
    val namespace = parameters.namespace.get()
    val file = item.layoutFile
    val layoutNodeItems = parseXml(saxParser, file, logger)
    writeActivityFragmentExtension(layoutNodeItems, item, namespace)
    writeViewExtension(layoutNodeItems, item, namespace)
}

} ```

1. 第一步：首先我們需要定義一個介面來表示每個Action需要的引數，即KaceGenerateAction.Parameters
2. 第二步：您需要將自定義Task中為每個單獨檔案執行工作的部分重構為單獨的類，即KaceGenerateAction
3. 第三步：您應該重構自定義Task類以將工作提交給 WorkerExecutor，而不是自己完成工作

接下來就是將KaceGenerateAction提交給WorkerExector

```kotlin abstract class KaceGenerateTask : DefaultTask() { @get:Inject abstract val workerExecutor: WorkerExecutor

@TaskAction
fun action(inputChanges: InputChanges) {
    val workQueue = workerExecutor.noIsolation()
    // ...
    changedLayoutItemList.forEach { item ->
        workQueue.submit(KaceGenerateAction::class.java) { parameters ->
            parameters.destDir.set(destDir)
            parameters.layoutFile.set(item.layoutFile)
            parameters.variantName.set(item.variantName)
            parameters.namespace.set(namespace)
        }
    }
    workQueue.await() // 等待所有 Action 完成，計算耗時
    val duration = System.currentTimeMillis() - startTime
}

} ```

1. 您需要擁有WorkerExecutor服務才能提交Action。這裡我們添加了一個抽象的workerExecutor並添加註解，Gradle 將在執行時注入服務
2. 在提交Action之前，我們需要通過不同的隔離模式獲取WorkQueue，這裡使用的是執行緒隔離模式
3. 提交Action時，指定Action實現，在這種情況下呼叫KaceGenerateAction並配置其引數

經過測試，在一個包括 500 個 layout 的模組中，在開啟並行 Task 前全量編譯耗時約 4 秒，而開啟後全量編譯耗時減少到 2 秒左右，可以有 100% 左右的提升

支援增量編譯

還有一種常見的場景，當我們只修改了一個 layout 時，如果模組內的所有 layout 都需要重新解析並生成程式碼，也是非常浪費效能的

理想情況下，應該只需要重新解析與處理我們修改的 layout 就行了，Gradle 同樣提供了 API 供我們實現增量編譯

```kotlin abstract class KaceGenerateTask : DefaultTask() { @get:Incremental @get:InputFiles @get:PathSensitive(PathSensitivity.RELATIVE) internal open val androidLayoutResources: FileCollection = layoutDirs .asFileTree .matching { patternFilterable -> patternFilterable.include("*/.xml") }

@TaskAction
fun action(inputChanges: InputChanges) {
    val changeFiles = getChangedFiles(inputChanges, androidLayoutResources)
    // ...        
}

private fun getChangedFiles(
    inputChanges: InputChanges,
    layoutResources: FileCollection
) = if (!inputChanges.isIncremental) {
    ChangedFiles.Unknown()
} else {
    inputChanges.getFileChanges(layoutResources)
        .fold(mutableListOf<File>() to mutableListOf<File>()) { (modified, removed), item ->
            when (item.changeType) {
                ChangeType.ADDED, ChangeType.MODIFIED -> modified.add(item.file)
                ChangeType.REMOVED -> removed.add(item.file)
                else -> Unit
            }
            modified to removed
        }.run {
            ChangedFiles.Known(first, second)
        }
}

} ```

通過以下步驟，就可以實現增量編譯

1. androidLayoutResources使用@Incremental註解標識，表示支援增量處理的輸入
2. 給TaskAction方法新增inputChange引數
3. 通過inputChanges方法獲取輸入中發生了更改的檔案，如果發生了更改則重新處理，如果被刪除了則同樣刪除目標目錄中的檔案，沒有發生更改的檔案則不處理

通過支援增量編譯，當只修改或者新增一個 layout 時，增量編譯耗時可以減少到 8ms 左右，大幅減少了編譯耗時

總結

本文主要介紹瞭如何使用 Kace ，以及 Kace 到底是如何實現的，如果有任何問題，歡迎提出 Issue，如果對你有所幫助，歡迎點贊收藏 Star ~

開源地址

https://github.com/kanyun-inc/Kace