Implement typing indicator serialization

SessionMessagingKit/Messages/Control Message/ControlMessage.swift

@@ -1,13 +1,4 @@
 import SessionProtocolKit
 
 @objc(SNControlMessage)
-public class ControlMessage : Message {
+public class ControlMessage : Message { }
-
-    public enum Kind {
-        case readReceipt
-        case sessionRequest(preKeyBundle: PreKeyBundle)
-        case typingIndicator
-        case closedGroupUpdate
-        case expirationUpdate
-    }
-}

SessionMessagingKit/Messages/Control Message/TypingIndicator.swift

@@ -4,7 +4,8 @@ import SessionUtilities
 public final class TypingIndicator : ControlMessage {
     public var kind: Kind?
 
-    public enum Kind {
+    // MARK: Kind
+    public enum Kind : String {
         case started, stopped
 
         static func fromProto(_ proto: SNProtoTypingMessage.SNProtoTypingMessageAction) -> Kind {
@@ -22,37 +23,46 @@ public final class TypingIndicator : ControlMessage {
         }
     }
 
-    convenience init(sentTimestamp: UInt64, receivedTimestamp: UInt64, kind: Kind) {
+    // MARK: Initialization
-        self.init()
+    init(sentTimestamp: UInt64, receivedTimestamp: UInt64, kind: Kind) {
+        super.init()
         self.sentTimestamp = sentTimestamp
         self.receivedTimestamp = receivedTimestamp
         self.kind = kind
     }
 
-    public override class func fromSerializedProto(_ serializedProto: Data) -> TypingIndicator? {
+    // MARK: Coding
-        do {
+    public required init?(coder: NSCoder) {
-            let contentProto = try SNProtoContent.parseData(serializedProto)
+        super.init(coder: coder)
-            guard let typingIndicatorProto = contentProto.typingMessage else {
+        if let rawKind = coder.decodeObject(forKey: "kind") as! String? {
-                SNLog("Couldn't parse typing indicator from: \(contentProto).")
+            kind = Kind(rawValue: rawKind)
-                return nil
+        }
-            }
+    }
-            let timestamp = typingIndicatorProto.timestamp
+
-            let now = NSDate.millisecondTimestamp()
+    public override func encode(with coder: NSCoder) {
-            let kind = Kind.fromProto(typingIndicatorProto.action)
+        super.encode(with: coder)
-            return TypingIndicator(sentTimestamp: timestamp, receivedTimestamp: now, kind: kind)
+        coder.encode(kind?.rawValue, forKey: "kind")
-        } catch {
+    }
-            SNLog("Couldn't deserialize typing indicator.")
+
+    // MARK: Proto Conversion
+    public override class func fromProto(_ proto: SNProtoContent) -> TypingIndicator? {
+        guard let typingIndicatorProto = proto.typingMessage else {
+            SNLog("Couldn't parse typing indicator from: \(proto).")
             return nil
         }
+        let timestamp = typingIndicatorProto.timestamp
+        let now = NSDate.millisecondTimestamp()
+        let kind = Kind.fromProto(typingIndicatorProto.action)
+        return TypingIndicator(sentTimestamp: timestamp, receivedTimestamp: now, kind: kind)
     }
 
-    public override func toSerializedProto() -> Data? {
+    public override func toProto() -> SNProtoContent? {
         guard let timestamp = sentTimestamp, let kind = kind else { return nil }
         let typingIndicatorProto = SNProtoTypingMessage.builder(timestamp: timestamp, action: kind.toProto())
         let contentProto = SNProtoContent.builder()
         do {
             contentProto.setTypingMessage(try typingIndicatorProto.build())
-            return try contentProto.buildSerializedData()
+            return try contentProto.build()
         } catch {
             SNLog("Couldn't construct typing indicator proto from: \(self).")
             return nil

SessionMessagingKit/Messages/Message.swift

@@ -9,19 +9,24 @@ public class Message : NSObject, NSCoding { // Not a protocol for YapDatabase co
 
     public override init() { }
 
+    // MARK: Coding
     public required init?(coder: NSCoder) {
         preconditionFailure("init?(coder:) is abstract and must be overridden.")
     }
 
     public func encode(with coder: NSCoder) {
-        preconditionFailure("encode(with:) is abstract and must be overridden.")
+        coder.encode(id, forKey: "id")
+        coder.encode(threadID, forKey: "threadID")
+        coder.encode(sentTimestamp, forKey: "sentTimestamp")
+        coder.encode(receivedTimestamp, forKey: "receivedTimestamp")
     }
 
-    public class func fromSerializedProto(_ serializedProto: Data) -> Self? {
+    // MARK: Proto Conversion
-        preconditionFailure("fromSerializedProto(_:) is abstract and must be overridden.")
+    public class func fromProto(_ proto: SNProtoContent) -> Self? {
+        preconditionFailure("fromProto(_:) is abstract and must be overridden.")
     }
 
-    public func toSerializedProto() -> Data? {
+    public func toProto() -> SNProtoContent? {
-        preconditionFailure("toSerializedProto() is abstract and must be overridden.")
+        preconditionFailure("toProto() is abstract and must be overridden.")
     }
 }

SessionMessagingKit/Messages/Visible Message/VisibleMessage.swift

@@ -8,7 +8,7 @@ public final class VisibleMessage : Message {
     public var contact: Contact?
     public var profile: Profile?
 
-    public override class func fromSerializedProto(_ serializedProto: Data) -> VisibleMessage? {
+    public override class func fromProto(_ proto: SNProtoContent) -> VisibleMessage? {
         return nil
 //        guard let data = proto.dataMessage,
 //            let text = data.body else { return nil }