如何在 Kotlin Multiplatform Project 的共享模块中使用 @Parcelize 注解

Question

我正在开发一个 Kotlin 多平台应用程序，我想在我的模型类中使用 @Parcelize 注释。但是在 Kotlin Multiplatform 插件中，@Parcelize 注释在我使用的 kotlin 版本中位于 android.extensions 插件中，它适用于 androidApp 模块。

关于我的 build.gradle.kts(androidApp)

plugins {
  id("com.android.application")
  kotlin("android")
  kotlin("android.extensions")
  kotlin("kapt")
  id("kotlinx-serialization")
  id("androidx.navigation.safeargs.kotlin")
}

android {
  compileSdkVersion(Versions.compileSdk)

  compileOptions{
    sourceCompatibility = org.gradle.api.JavaVersion.VERSION_1_8
    targetCompatibility = org.gradle.api.JavaVersion.VERSION_1_8
  }

  kotlinOptions{
    jvmTarget = JavaVersion.VERSION_1_8.toString()
  }

  kapt{
    generateStubs = true
    correctErrorTypes = true
  }

  androidExtensions{
    isExperimental = true
  }

  buildFeatures{
    dataBinding = true
    viewBinding = true
  }

  defaultConfig {
    applicationId = "com.jshvarts.kmp.android"
    minSdkVersion(Versions.minSdk)
    targetSdkVersion(Versions.targetSdk)
    versionCode = 1
    versionName = "1.0"

    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  }

  buildTypes {
    getByName("release") {
      isMinifyEnabled = false
      proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
    }
  }

  packagingOptions {
    exclude("META-INF/*.kotlin_module")
  }
}

dependencies {
  implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
  implementation(kotlin("stdlib-jdk8", Versions.kotlin))
  implementation(Coroutines.android)
  implementation(AndroidX.appCompat)
  implementation(AndroidX.constraintLayout)
  implementation(AndroidX.recyclerView)
  implementation(AndroidX.lifecycleExtensions)
  implementation(AndroidX.lifecycleViewModelKtx)
  implementation(material)
  implementation(AndroidX.swipeToRefreshLayout)
  implementation(timber)
  implementation(picasso)
  implementation(AndroidX.navigation)
  implementation(AndroidX.navigation_ui)
  implementation(Serialization.runtime)
  //implementation(Serialization.core)
  //Dependency for googlePay
  implementation("com.google.android.gms:play-services-wallet:16.0.1")
  kapt(databinding)
  implementation(glide){
    exclude( "com.android.support")
  }
  kapt(glide)
  implementation(project(":shared"))

}

build.gradle.kts（共享）

plugins {
  id("com.android.library")
  kotlin("multiplatform")
  kotlin("plugin.serialization")
  //id("kotlinx-serialization")
  id("org.jetbrains.kotlin.native.cocoapods")
  id("com.squareup.sqldelight")
}
// CocoaPods requires the podspec to have a version.
version = "1.0"

android {
  compileSdkVersion(Versions.compileSdk)
  buildToolsVersion(Versions.androidBuildTools)

  defaultConfig {
    minSdkVersion(Versions.minSdk)
    targetSdkVersion(Versions.targetSdk)
    versionCode = 1
    versionName = "1.0"
  }
}

version = "1.0"
dependencies {
  implementation("com.google.firebase:firebase-crashlytics-buildtools:2.8.1")
  implementation(project(mapOf("path" to ":androidApp")))
}

kotlin {
  targets {

    val sdkName: String? = System.getenv("SDK_NAME")

    val isiOSDevice = sdkName.orEmpty().startsWith("iphoneos")
    if (isiOSDevice) {
      iosArm64("iOS")
    } else {
      iosX64("iOS")
    }
    android()
  }

  cocoapods {
    // Configure fields required by CocoaPods.
    summary = "Description for a Kotlin/Native module"
    homepage = "Link to a Kotlin/Native module homepage"
  }

  sourceSets {
    all {
      languageSettings.apply {
        useExperimentalAnnotation("kotlinx.coroutines.ExperimentalCoroutinesApi")
      }
    }

    val commonMain by getting {
      dependencies {
        implementation(kotlin("stdlib-common"))
        implementation(Coroutines.Core.core)
        implementation(Ktor.Core.common)
        implementation(Ktor.Json.common)
        implementation(Ktor.Logging.common)
        implementation(Ktor.Serialization.common)
        implementation(SqlDelight.runtime)
        implementation(Serialization.runtime)
        //implementation(project(":androidApp"))
        //implementation("org.jetbrains.kotlin:kotlin-reflect:${Versions.kotlin}")
        //implementation("org.jetbrains.kotlin:kotlin-reflect:${Versions.kotlin}")
        //implementation ("org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.1")
      }
    }

    val commonTest by getting {
      dependencies {
        implementation(Ktor.Mock.jvm)
      }
    }

    val androidMain by getting {
      dependencies {
        implementation(kotlin("stdlib"))
        implementation(Coroutines.Core.core)
        implementation(Ktor.android)
        implementation(Ktor.Core.jvm)
        implementation(Ktor.Json.jvm)
        implementation(Ktor.Logging.jvm)
        implementation(Ktor.Logging.slf4j)
        implementation(Ktor.Mock.jvm)
        implementation(Ktor.Serialization.jvm)
        implementation(Serialization.runtime)
        //implementation(Serialization.core)
        implementation(SqlDelight.android)


      }
    }

    val androidTest by getting {
      dependencies {
        implementation(kotlin("test-junit"))
        implementation(Ktor.Mock.common)
      }
    }

    val iOSMain by getting {
      dependencies {
        implementation(Coroutines.Core.core)
        implementation(Ktor.ios)
        implementation(Ktor.Core.common)
        implementation(Ktor.Json.common)
        implementation(Ktor.Logging.common)
        implementation(Ktor.Serialization.jvm)
       // implementation(Serialization.runtimeNative)
        implementation(SqlDelight.runtime)
        implementation(Ktor.Mock.common)
      }
    }

    val iOSTest by getting {
      dependencies {
        implementation(Ktor.Mock.native)
      }
    }
  }
}


sqldelight {
  database("PetsDatabase") {
    packageName = "com.jshvarts.kmp.db"
    sourceFolders = listOf("sqldelight")
  }
}

还有我的项目 build.gradle.kts

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
      google()
      mavenCentral()
      jcenter()
    }

    dependencies {
        classpath("com.android.tools.build:gradle:4.0.0")
        classpath(kotlin("gradle-plugin", version = Versions.kotlin))
        classpath(kotlin("serialization", version = Versions.kotlin))
        classpath("com.squareup.sqldelight:gradle-plugin:${Versions.sqldelight}")
        classpath("com.github.ben-manes:gradle-versions-plugin:0.28.0")
        classpath ("androidx.navigation:navigation-safe-args-gradle-plugin:${Versions.navigation}")
        classpath ("org.jetbrains.kotlin:kotlin-android-extensions-runtime:${Versions.kotlin}")
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
        jcenter()
    }
}

//TODO("Probar bajando a kotlin version 1.3.72, y habilitando el android-extensions")
plugins {
  //kotlin("jvm") version "${Versions.kotlin}"
  id("org.jlleitschuh.gradle.ktlint") version "9.2.1"
  id ("com.github.ben-manes.versions") version "0.28.0"
  //kotlin("android") version "${Versions.kotlin}" apply false
  //id("org.jetbrains.kotlin.plugin.parcelize") version "${Versions.kotlin}"
}
apply(from = "quality/lint.gradle") 

所以我在 androidApp 和共享模块中创建了一个期望和实际的 Parcelable 和 Parcelize 类：

androidApp

actual typealias Parcelable = android.os.Parcelable

actual typealias Parcelize = kotlinx.android.parcel.Parcelize

在共享模块中

// Common Code

expect interface Parcelable

@UseExperimental(ExperimentalMultiplatform::class)
@OptionalExpectation
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.BINARY)
expect annotation class Parcelize()

因此，在那些课程中，我收到以下错误：

In Parcelable(shared)

Expected interface 'Parcelable' has no actual declaration in module KmpMVVMGooglePay.shared for JVM
Expected interface 'Parcelable' has no actual declaration in module KmpMVVMGooglePay.shared.iOSMain for Native

在android类中：

Actual typealias 'Parcelable' has no corresponding expected declaration

Actual typealias 'Parcelize' has no corresponding expected declaration

那么我对实际/预期关键字行为的遗漏是什么？

我在这里先向您的帮助表示感谢！

Answer 1

你需要一个空的actual interface 用于 iOS 中的 Parcelable。我不知道为什么它会给你 JVM 的错误，因为它不在你的目标中。我将介绍如何在通用代码here 中使用Parcelable 和@Parcelize。

Answer 2

这些 sn-ps 向您展示了如何在 KMM 项目中为任何类型的类（包括原语）使用 Android Parcelable。它向我们展示了注解、接口、泛型、对象、@TypeParceler、Parcelable、Parcelize，以及如何为通用代码、iOS 和 Android 实现每个平台。

在此示例中，我希望将 LocalDateTime 的非本地可打包类作为示例非本地可打包类。您可以使用任何类，只需更改实现即可。

在build.gradle.kts(:shared)

plugins {
    kotlin("multiplatform")
    id("com.android.library")
    id("kotlin-parcelize") // add this
    id("kotlin-kapt") // add this
    // ...rest of defintions...
}
kotlin {
    android()
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        it.binaries.framework {
            baseName = "shared"
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.4.0")  // LocalDateTime library written in Kotlin (can't use java libraries)
            }
        }
        // ...rest of definitions...
     }
  // ...rest of definitions...
}

在commonMain/.../Platform.kt

import kotlinx.datetime.LocalDateTime

// For Android @Parcelize
@OptIn(ExperimentalMultiplatform::class)
@OptionalExpectation
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.BINARY)
expect annotation class CommonParcelize()

// For Android Parcelable
expect interface CommonParcelable

// For Android @TypeParceler
@OptIn(ExperimentalMultiplatform::class)
@OptionalExpectation
@Retention(AnnotationRetention.SOURCE)
@Repeatable
@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY)
expect annotation class CommonTypeParceler<T, P : CommonParceler<in T>>()

// For Android Parceler
expect interface CommonParceler<T>

// For Android @TypeParceler to convert LocalDateTimeParceler
expect object LocalDateTimeParceler: CommonParceler<LocalDateTime>

在androidMain/.../Platform.kt

重要提示：必须导入kotlinx.parcelize.*不是kotlinx.android.parcel.*

import android.os.Parcel
import android.os.Parcelable
import kotlinx.datetime.LocalDateTime
import kotlinx.datetime.toLocalDateTime
import kotlinx.parcelize.Parceler
import kotlinx.parcelize.Parcelize
import kotlinx.parcelize.TypeParceler

actual typealias CommonParcelize = Parcelize
actual typealias CommonParcelable = Parcelable

actual typealias CommonParceler<T> = Parceler<T>
actual typealias CommonTypeParceler<T,P> = TypeParceler<T, P>
actual object LocalDateTimeParceler : Parceler<LocalDateTime> {
    override fun create(parcel: Parcel): LocalDateTime {
        val date = parcel.readString()
        return date?.toLocalDateTime()
            ?: LocalDateTime(0, 0, 0, 0, 0)
    }

    override fun LocalDateTime.write(parcel: Parcel, flags: Int) {
        parcel.writeString(this.toString())
    }
}

在iosMain/.../Platform.kt

import kotlinx.datetime.LocalDateTime
import kotlinx.wasm.jsinterop.Object

// Note: no need to define CommonParcelize here (bc its @OptionalExpectation)
actual interface CommonParcelable  // not used on iOS

// Note: no need to define CommonTypeParceler<T,P : CommonParceler<in T>> here (bc its @OptionalExpectation)
actual interface CommonParceler<T> // not used on iOS
actual object LocalDateTimeParceler : CommonParceler<LocalDateTime> // not used on iOS

在../shared/commonMain/.../domain/note/Note.kt

import kotlinx.datetime.LocalDateTime

@CommonParcelize
data class Note(
    val id: Long?,
    val title: String,
    val content: String,
    val colorHex: Long,

    @CommonTypeParceler<LocalDateTime, LocalDateTimeParceler>()
    val created: LocalDateTime,
): CommonParcelable {

    companion object {
        private val colors = listOf(RedOrangeHex, RedPinkHex, LightGreenHex, BabyBlueHex, VioletHex)
        fun generateRandomColor() = colors.random()
    }
}

我尝试实现@RawValue，但它没有记录（AFAIK），并且上述使用@TypeParcelers 的方法对于任何特定类都非常有效。我把它留给别人练习！

示例项目：https://github.com/realityexpander/NoteAppKMM