Create helper class to pass Codable pure Swift types through a remote call.

PiperOrigin-RevId: 371180976

Author: AlbertWang0116

Service/Sources/CodableVariable.swift

@@ -0,0 +1,118 @@
+import Foundation
+
+/// CodableVariable wraps a `Codable` instance to make it compatible with @objc methods.
+///
+/// `Codable` documentation: https://developer.apple.com/documentation/swift/codable
+///
+/// The Swift compiler doesn't allow developers to declare an @objc method for eDO as below:
+///
+///   ```
+///   @objc public FooClass : NSObject {
+///     @objc public func callBar(value: Int?) // Compile Error!
+///   }
+///   ```
+///
+/// The same issue also applies to other auto-synthesized Codable types, including classes, structs
+/// and enums (Swift 5.5+). This is because Optional<Int> is a pure Swift type that cannot be
+/// represented in Objective-C land. As a workaround, developers can declare a new method in the
+/// class extension as below:
+///
+///   ```
+///   extension FooClass {
+///     @objc public func callBar(codedValue: CodableVariable) throws {
+///       self.callBar(value: try codedValue.unwrap(Int?.self))
+///     }
+///   }
+///   ```
+///
+/// The new method is compatible with @objc and forwards the coded variables to the original method.
+/// So developers can use the new method in the remote call:
+///
+///   ```
+///   var value : Int?
+///   // Do something...
+///   try remoteFooInstance.callBar(codedValue: try CodableVariable.wrap(value))
+///   ```
+@objc(EDOCodableVariable)
+public class CodableVariable: NSObject, NSSecureCoding, Codable {
+
+  /// Error thrown by `CodableVariable` during the decoding.
+  public enum DecodingError: Error, LocalizedError {
+    /// The type of encoded data doesn't match the caller's expecting type.
+    /// - expectedType: The type expected by the decoding method caller.
+    /// - actualType: The type of the encoded data.
+    case typeUnmatched(expectedType: String, actualType: String)
+
+    public var errorDescription: String? {
+      switch self {
+      case let .typeUnmatched(expectedType, actualType):
+        return "Expecting to decode \(expectedType) but the codable variable is \(actualType)."
+      }
+    }
+  }
+
+  internal static let typeKey = "EDOTypeKey"
+  internal let data: Data
+  internal let type: String
+
+  /// Creates `CodableVariable` instance with a `Codable` instance.
+  ///
+  /// - Parameter parameter: The Codable instance to be wrapped.
+  /// - Returns: A `CodableVariable` instance.
+  /// - Throws: Errors propagated from JSONEncoder when encoding `parameter`.
+  public static func wrap<T: Encodable>(_ parameter: T) throws -> CodableVariable {
+    let encoder = JSONEncoder()
+    return CodableVariable(data: try encoder.encode(parameter), type: String(describing: T.self))
+  }
+
+  internal init(data: Data, type: String) {
+    self.data = data
+    self.type = type
+  }
+
+  /// Decodes the Codable instance.
+  ///
+  /// - Parameter type: The expected type of the decoded instance.
+  /// - Returns: The decoded instance of `type`.
+  /// - Throws: `CodableVariable.DecodingError` if decoding fails.
+  public func unwrap<T: Decodable>(_ type: T.Type) throws -> T {
+    guard self.type == String(describing: type) else {
+      throw DecodingError.typeUnmatched(
+        expectedType: self.type,
+        actualType: String(describing: type))
+    }
+    let decoder = JSONDecoder()
+    return try decoder.decode(T.self, from: data)
+  }
+
+  // MARK - NSSecureCoding
+
+  public required init?(coder: NSCoder) {
+    guard let data = coder.decodeData(),
+      let type = coder.decodeObject(forKey: CodableVariable.typeKey) as? String
+    else {
+      return nil
+    }
+    self.data = data
+    self.type = type
+  }
+
+  public func encode(with coder: NSCoder) {
+    coder.encode(data)
+    coder.encode(type, forKey: CodableVariable.typeKey)
+  }
+
+  @objc public var edo_isEDOValueType: Bool { return true }
+
+  @objc public static var supportsSecureCoding: Bool { return true }
+}
+
+/// Extends Encodable to easily produce `CodableVariable` from the instance.
+extension Encodable {
+  /// Produces a `CodableVariable` instance from `self`.
+  public var eDOCodableVariable: CodableVariable {
+    // try! is used here because`CodableVariable.wrap` only throws programmer errors when
+    // JSONEncoder fails to encode a `Encodable` type.
+    return try! CodableVariable.wrap(self)
+  }
+}

Service/Tests/FunctionalTests/EDOSwiftUITest.swift

@@ -44,7 +44,8 @@ class EDOSwiftUITest: XCTestCase {
     service.invalidate()
   }
 
-  func testRemoteInvocationWithParameter() {
+  /// Verifies eDO can make remote calls through Swift @objc methods.
+  func testRemoteInvocationWithParameter() throws {
     launchAppWithPort(port: 1234, value: 10)
     let service = EDOHostService(port: 2234, rootObject: self, queue: DispatchQueue.main)
     let hostPort = EDOHostPort(port: 1234, name: nil, deviceSerialNumber: nil)
@@ -53,6 +54,9 @@ class EDOSwiftUITest: XCTestCase {
     let data = ["a": 1, "b": 2] as NSDictionary
     XCTAssertEqual(swiftClass.returnWithDictionarySum(data: data.passByValue()), 3)
     XCTAssertEqual(swiftClass.returnWithDictionarySum(data: data), 3)
+    let testingStruct = EDOTestSwiftStruct(intValues: [1, 2, 3, 4, 5])
+    let codedResult = try swiftClass.sumFrom(codedStruct: testingStruct.eDOCodableVariable)
+    XCTAssertEqual(try codedResult.unwrap([Int].self).first, 15)
     service.invalidate()
   }
 

Service/Tests/TestsBundle/EDOTestSwiftClass.swift

@@ -15,6 +15,7 @@
 //
 
 import Foundation
+import SwiftUtil
 @objc
 public class EDOTestSwiftClass: NSObject, EDOTestSwiftProtocol {
   public func returnString() -> NSString {
@@ -36,6 +37,15 @@ public class EDOTestSwiftClass: NSObject, EDOTestSwiftProtocol {
   public func returnSwiftArray() -> [AnyObject] {
     return [NSObject.init(), NSObject.init()]
   }
+
+  public func sumFrom(structValue: EDOTestSwiftStruct) -> [Int] {
+    return [structValue.intValues.reduce(0) { $0 + $1 }]
+  }
+
+  public func sumFrom(codedStruct: CodableVariable) throws -> CodableVariable {
+    let structValue = try codedStruct.unwrap(EDOTestSwiftStruct.self)
+    return self.sumFrom(structValue: structValue).eDOCodableVariable
+  }
 }
 
 extension EDOTestDummy: EDOTestDummyExtension {

Service/Tests/TestsBundle/EDOTestSwiftProtocol.swift

@@ -15,13 +15,23 @@
 //
 
 import Foundation
+import SwiftUtil
+
+public struct EDOTestSwiftStruct: Codable {
+  public var intValues: [Int]
+
+  public init(intValues: [Int]) {
+    self.intValues = intValues
+  }
+}
 
 @objc
 public protocol EDOTestSwiftProtocol {
   func returnString() -> NSString
   func returnWithBlock(block: @escaping (NSString) -> EDOTestSwiftProtocol) -> NSString
   func returnWithDictionarySum(data: NSDictionary) -> Int
   func returnSwiftArray() -> [AnyObject]
+  func sumFrom(codedStruct: CodableVariable) throws -> CodableVariable
 }
 
 @objc

Service/Tests/UnitTests/CodableVariableTests.swift

@@ -0,0 +1,48 @@
+import XCTest
+import SwiftUtil
+
+struct EDOTestingStruct: Codable {
+  var intValue: Int
+  var stringValue: String
+  var floatValue: Float
+}
+
+final class CodableVariableTests: XCTestCase {
+
+  /// Verifies CodableVariable can wrap/unwrap structs that conforms Codable.
+  func testSerializeStruct() throws {
+    let structValue = EDOTestingStruct(intValue: 0, stringValue: "foo", floatValue: -1.0)
+    let serialized = structValue.eDOCodableVariable
+    let deserialized = try serialized.unwrap(EDOTestingStruct.self)
+    XCTAssertEqual(deserialized.intValue, structValue.intValue)
+    XCTAssertEqual(deserialized.stringValue, structValue.stringValue)
+    XCTAssertEqual(deserialized.floatValue, structValue.floatValue)
+  }
+
+  /// Verifies CodableVariable can wrap/unwrap optional primitive types.
+  func testSerializeOptionalPrimitive() throws {
+    guard #available(iOS 13.0, *) else {
+      throw XCTSkip("Optional is available for encoding after iOS 13")
+    }
+    let optionalValue: Int? = nil
+    let serialized = optionalValue.eDOCodableVariable
+    let deserialized = try serialized.unwrap(Int?.self)
+    XCTAssertNil(deserialized)
+  }
+
+  /// Verifies CodableVariable throws exceptions when decoding expects a wrong type.
+  func testThrowErrorWhenTypeMismatch() {
+    let structValue = EDOTestingStruct(intValue: 0, stringValue: "foo", floatValue: -1.0)
+    let serialized = structValue.eDOCodableVariable
+    var thrownError: Error?
+    XCTAssertThrowsError(try serialized.unwrap(Int?.self)) {
+      thrownError = $0
+    }
+    let expectedError =
+      CodableVariable.DecodingError.typeUnmatched(
+        expectedType: "EDOTestingStruct",
+        actualType: "Optional<Int>")
+    XCTAssertEqual(thrownError?.localizedDescription, expectedError.localizedDescription)
+  }
+
+}

eDistantObject.podspec

@@ -30,7 +30,7 @@ Pod::Spec.new do |s|
   # ${PODS_TARGET_SRCROOT} is needed for Pod lint which locates the local eDistantObject codebase.
   s.pod_target_xcconfig = { "HEADER_SEARCH_PATHS" => "${PODS_ROOT}/eDistantObject ${PODS_TARGET_SRCROOT}" }
   s.source_files = "Channel/Sources/*.{m,h}", "Device/Sources/*.{m,h}",
-                   "Measure/Sources/*.{m,h}", "Service/Sources/*.{m,h}"
+                   "Measure/Sources/*.{m,h}", "Service/Sources/*.{m,h,swift}"
 
   s.ios.deployment_target = "10.0"
   s.osx.deployment_target = "10.10"