如何使 UIImage 符合 Codable？

Question

Swift 4 有 Codable，它很棒。但是UIImage默认不符合。我们该怎么做？

我试过singleValueContainer和unkeyedContainer

extension UIImage: Codable {
  // 'required' initializer must be declared directly in class 'UIImage' (not in an extension)
  public required init(from decoder: Decoder) throws {
    let container = try decoder.singleValueContainer()
    let data = try container.decode(Data.self)
    guard let image = UIImage(data: data) else {
      throw MyError.decodingFailed
    }

    // A non-failable initializer cannot delegate to failable initializer 'init(data:)' written with 'init?'
    self.init(data: data)
  }

  public func encode(to encoder: Encoder) throws {
    var container = encoder.singleValueContainer()
    guard let data = UIImagePNGRepresentation(self) else {
      return
    }

    try container.encode(data)
  }
}

我收到 2 个错误

1. “必需”初始化程序必须直接在“UIImage”类中声明（而不是在扩展中）
2. 不可失败的初始化程序不能委托给用“init?”编写的可失败初始化程序“init(data:)”

一种解决方法是使用包装器。但是还有其他方法吗？

Answer 1

解决方案：滚动您自己的符合 Codable 的包装类。

一个解决方案，因为对UIImage 的扩展已经结束，所以将图像包装在您拥有的新类中。否则，您的尝试基本上是直接的。我看到这在 Hyper Interactive 的缓存框架中完美地完成了，称为 Cache。

虽然您需要访问该库以深入了解依赖项，但您可以通过查看他们的 ImageWrapper 类来了解这个想法，该类是为这样使用而构建的：

let wrapper = ImageWrapper(image: starIconImage)
try? theCache.setObject(wrapper, forKey: "star")

let iconWrapper = try? theCache.object(ofType: ImageWrapper.self, forKey: "star")
let icon = iconWrapper.image

这是他们的包装类：

// Swift 4.0
public struct ImageWrapper: Codable {
  public let image: Image

  public enum CodingKeys: String, CodingKey {
    case image
  }

  // Image is a standard UI/NSImage conditional typealias
  public init(image: Image) {
    self.image = image
  }

  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    let data = try container.decode(Data.self, forKey: CodingKeys.image)
    guard let image = Image(data: data) else {
      throw StorageError.decodingFailed
    }

    self.image = image
  }

  // cache_toData() wraps UIImagePNG/JPEGRepresentation around some conditional logic with some whipped cream and sprinkles.
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    guard let data = image.cache_toData() else {
        throw StorageError.encodingFailed
    }

    try container.encode(data, forKey: CodingKeys.image)
  }
}

我很想听听你最终使用的是什么。

更新：事实证明OP 编写了我引用的代码（Swift 4.0 更新到缓存）来解决问题。当然，代码应该放在这里，但我也会不加编辑，因为这一切都具有戏剧性的讽刺意味。 :)

Answer 2

最简单的方法是直接使用Data 而不是UIImage：

public struct SomeImage: Codable {

    public let photo: Data
    
    public init(photo: UIImage) {
        self.photo = photo.pngData()!
    }
}

反序列化图像：

UIImage(data: instanceOfSomeImage.photo)!

Answer 3

您可以使用非常优雅的解决方案，使用 KeyedDecodingContainer 和 KeyedEncodingContainer 类的扩展：

enum ImageEncodingQuality {
  case png
  case jpeg(quality: CGFloat)
}

extension KeyedEncodingContainer {
  mutating func encode(
    _ value: UIImage,
    forKey key: KeyedEncodingContainer.Key,
    quality: ImageEncodingQuality = .png
  ) throws {
    let imageData: Data?
    switch quality {
    case .png:
      imageData = value.pngData()
    case .jpeg(let quality):
      imageData = value.jpegData(compressionQuality: quality)
    }
    guard let data = imageData else {
      throw EncodingError.invalidValue(
        value,
        EncodingError.Context(codingPath: [key], debugDescription: "Failed convert UIImage to data")
      )
    }
    try encode(data, forKey: key)
  }
}

extension KeyedDecodingContainer {
  func decode(
    _ type: UIImage.Type,
    forKey key: KeyedDecodingContainer.Key
  ) throws -> UIImage {
    let imageData = try decode(Data.self, forKey: key)
    if let image = UIImage(data: imageData) {
      return image
    } else {
      throw DecodingError.dataCorrupted(
        DecodingError.Context(codingPath: [key], debugDescription: "Failed load UIImage from decoded data")
      )
    }
  }
}

PS：您可以使用这种方式将Codable 用于任何类类型

Answer 4

传递 UIImage 的一种方法是将其转换为符合 Codable 的内容，例如 String。

将 UIImage 转换为 func encode(to encoder: Encoder) throws 内的字符串：

let imageData: Data = UIImagePNGRepresentation(image)!
let strBase64 = imageData.base64EncodedString(options: .lineLength64Characters)
try container.encode(strBase64, forKey: .image)

将String转换回required init(from decoder: Decoder) throws内的UIImage：

let strBase64: String = try values.decode(String.self, forKey: .image)
let dataDecoded: Data = Data(base64Encoded: strBase64, options: .ignoreUnknownCharacters)!
image = UIImage(data: dataDecoded)

Answer 5

现有的答案似乎都是不正确的。如果您将反序列化的图像与原始图像进行比较，您会发现它们在任何意义上都可能不相等。这是因为答案都在扔掉 scale 信息。

您必须对图像scale 及其pngData() 进行编码。然后在解码 UIImage 时，通过调用init(data:scale:) 将数据与比例结合起来。

Answer 6

还有一个在图像上使用惰性变量的简单解决方案：

var mainImageData: Data {
    didSet { _ = mainImage }
}
lazy var mainImage: UIImage = {
    UIImage(data: mainImageData)!
}()

这样，在对象初始化和分配给mainImageData 期间，它的didSet 将启动，然后将启动UIImage 的初始化。

由于UIImage 初始化占用大量资源，我们将它们耦合在一起。 请注意，整个初始化将在后台线程上进行。