如何序列化/反序列化Jetpack Compose的Canvas Path并存储到Room数据库？

错误原因 #

androidx.compose.ui.graphics.Path是一个接口，Gson默认无法实例化接口类型对象，直接用Gson序列化/反序列化Path会抛出Interfaces can't be instantiated错误。

解决方案：自定义Path序列化逻辑 #

Path的本质是一系列绘图指令（moveTo、lineTo、quadTo等）的集合，我们可以把这些指令转换成可序列化的数据结构保存，反序列化时重新执行指令重建Path。

方法一：用简单的命令标识+参数列表实现（无需额外依赖）

修改PathConverter类，遍历Path的所有操作指令，将指令类型和参数转换成可序列化的列表，反序列化时重建Path：

object PathConverter {
    private val gson = Gson()

    @TypeConverter
    fun fromPath(path: Path): String {
        val commandList = mutableListOf<Pair<String, List<Float>>>()
        val iterator = path.iterator()
        
        while (iterator.hasNext()) {
            val segment = iterator.next()
            val commandType = when(segment.type) {
                PathSegment.Type.MoveTo -> "MOVE"
                PathSegment.Type.LineTo -> "LINE"
                PathSegment.Type.QuadTo -> "QUAD"
                PathSegment.Type.CubicTo -> "CUBIC"
                PathSegment.Type.Close -> "CLOSE"
            }
            commandList.add(commandType to segment.points.toList())
        }
        return gson.toJson(commandList)
    }

    @TypeConverter
    fun toPath(data: String): Path {
        val commandList = gson.fromJson<List<Pair<String, List<Float>>>>(
            data,
            object : TypeToken<List<Pair<String, List<Float>>>>() {}.type
        )
        val path = Path()
        
        commandList.forEach { (type, params) ->
            when(type) {
                "MOVE" -> path.moveTo(params[0], params[1])
                "LINE" -> path.lineTo(params[0], params[1])
                "QUAD" -> path.quadTo(params[0], params[1], params[2], params[3])
                "CUBIC" -> path.cubicTo(params[0], params[1], params[2], params[3], params[4], params[5])
                "CLOSE" -> path.close()
            }
        }
        return path
    }
}

方法二：用密封类封装指令（类型更安全）

如果希望类型更严谨，可以用密封类定义每种绘图指令，配合Gson的RuntimeTypeAdapterFactory实现序列化：

1. 先添加Gson extras依赖（和你的Gson版本保持一致）：

implementation 'com.google.code.gson:gson-extras:2.10.1'

2. 定义密封类保存指令：

sealed class PathCommand {
    data class MoveTo(val x: Float, val y: Float) : PathCommand()
    data class LineTo(val x: Float, val y: Float) : PathCommand()
    data class QuadTo(val x1: Float, val y1: Float, val x2: Float, val y2: Float) : PathCommand()
    data class CubicTo(val x1: Float, val y1: Float, val x2: Float, val y2: Float, val x3: Float, val y3: Float) : PathCommand()
    object Close : PathCommand()
}

3. 修改PathConverter：

object PathConverter {
    private val gson = GsonBuilder()
        .registerTypeAdapterFactory(RuntimeTypeAdapterFactory.of(PathCommand::class.java, "type"))
        .create()

    @TypeConverter
    fun fromPath(path: Path): String {
        val commands = mutableListOf<PathCommand>()
        val iterator = path.iterator()
        
        while (iterator.hasNext()) {
            val segment = iterator.next()
            val command = when(segment.type) {
                PathSegment.Type.MoveTo -> PathCommand.MoveTo(segment.points[0], segment.points[1])
                PathSegment.Type.LineTo -> PathCommand.LineTo(segment.points[0], segment.points[1])
                PathSegment.Type.QuadTo -> PathCommand.QuadTo(segment.points[0], segment.points[1], segment.points[2], segment.points[3])
                PathSegment.Type.CubicTo -> PathCommand.CubicTo(segment.points[0], segment.points[1], segment.points[2], segment.points[3], segment.points[4], segment.points[5])
                PathSegment.Type.Close -> PathCommand.Close
            }
            commands.add(command)
        }
        return gson.toJson(commands)
    }

    @TypeConverter
    fun toPath(data: String): Path {
        val commands = gson.fromJson<List<PathCommand>>(
            data,
            object : TypeToken<List<PathCommand>>() {}.type
        )
        val path = Path()
        
        commands.forEach { command ->
            when(command) {
                is PathCommand.MoveTo -> path.moveTo(command.x, command.y)
                is PathCommand.LineTo -> path.lineTo(command.x, command.y)
                is PathCommand.QuadTo -> path.quadTo(command.x1, command.y1, command.x2, command.y2)
                is PathCommand.CubicTo -> path.cubicTo(command.x1, command.y1, command.x2, command.y2, command.x3, command.y3)
                PathCommand.Close -> path.close()
            }
        }
        return path
    }
}

额外注意事项 #

1. ImageBitmap 序列化：你的PathProperties中使用了ImageBitmap，Room无法直接处理这个类型，需要添加对应的转换器：

object ImageBitmapConverter {
    @TypeConverter
    fun fromImageBitmap(imageBitmap: ImageBitmap?): ByteArray? {
        return imageBitmap?.let {
            val bitmap = Bitmap.createBitmap(it.width, it.height, Bitmap.Config.ARGB_8888)
            val canvas = android.graphics.Canvas(bitmap)
            canvas.drawImage(it, Offset.Zero, Paint())
            val outputStream = ByteArrayOutputStream()
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
            outputStream.toByteArray()
        }
    }

    @TypeConverter
    fun toImageBitmap(byteArray: ByteArray?): ImageBitmap? {
        return byteArray?.let {
            val bitmap = BitmapFactory.decodeByteArray(it, 0, it.size)
            bitmap.asImageBitmap()
        }
    }
}

然后在PathProperties的bitmap属性上添加@TypeConverters(ImageBitmapConverter::class)。

2. Rect 序列化：如果Rect序列化出现问题，同样可以自定义转换器，将其拆分为left、top、right、bottom四个Float值保存。

内容的提问来源于stack exchange，提问作者Adnan Aslam