Merge pull request #345 from zapcannon87/developer

fix(IM): rcp event should not update last delivered & read date

Author: zapcannon87

LeanCloudTests/IMMessageTestCase.swift

@@ -1161,11 +1161,9 @@ class IMMessageTestCase: RTMBaseTestCase {
         wait(for: [getReadFlagExp], timeout: timeout)
 
         let sendNeedRCPMessageExp = expectation(description: "send need RCP message")
-        sendNeedRCPMessageExp.expectedFulfillmentCount = 4
+        sendNeedRCPMessageExp.expectedFulfillmentCount = 3
         sendingTuple?.delegator.conversationEvent = { client, conv, event in
             switch event {
-            case .lastDeliveredAtUpdated:
-                sendNeedRCPMessageExp.fulfill()
             case .message(event: let messageEvent):
                 switch messageEvent {
                 case .delivered(toClientID: _, messageID: _, deliveredTimestamp: _):

Sources/RTM/IMClient.swift

@@ -2229,10 +2229,6 @@ extension IMClient {
                 }
                 client.localRecord.update(
                     lastServerTimestamp: serverTimestamp)
-                conversation.process(
-                    rcpTimestamp: timestamp,
-                    isRead: isRead,
-                    client: client)
                 client.eventQueue.async {
                     client.delegate?.client(
                         client, conversation: conversation,

Sources/RTM/IMConversation.swift

@@ -1165,18 +1165,20 @@ extension IMConversation {
                 assert(client.specificAssertion)
                 let rcpResult: LCGenericResult<MessageReceiptFlag>
                 if let convMessage = (inCommand.hasConvMessage ? inCommand.convMessage : nil) {
-                    let readTimestamp = (convMessage.hasMaxReadTimestamp ? convMessage.maxReadTimestamp : nil)
-                    if let timestamp = readTimestamp {
-                        self.process(rcpTimestamp: timestamp, isRead: true, client: client)
-                    }
-                    let deliveredTimestamp = (convMessage.hasMaxAckTimestamp ? convMessage.maxAckTimestamp : nil)
-                    if let timestamp = deliveredTimestamp {
-                        self.process(rcpTimestamp: timestamp, isRead: false, client: client)
-                    }
+                    let maxReadTimestamp = (convMessage.hasMaxReadTimestamp
+                        ? convMessage.maxReadTimestamp
+                        : nil)
+                    let maxDeliveredTimestamp = (convMessage.hasMaxAckTimestamp
+                        ? convMessage.maxAckTimestamp
+                        : nil)
+                    self.process(
+                        maxReadTimestamp: maxReadTimestamp,
+                        maxDeliveredTimestamp: maxDeliveredTimestamp,
+                        client: client)
                     rcpResult = .success(
                         value: MessageReceiptFlag(
-                            readFlagTimestamp: readTimestamp,
-                            deliveredFlagTimestamp: deliveredTimestamp))
+                            readFlagTimestamp: maxReadTimestamp,
+                            deliveredFlagTimestamp: maxDeliveredTimestamp))
                 } else {
                     rcpResult = .failure(
                         error: LCError(
@@ -1197,25 +1199,28 @@ extension IMConversation {
         })
     }
 
-    func process(rcpTimestamp: Int64, isRead: Bool, client: IMClient) {
+    private func process(
+        maxReadTimestamp: Int64?,
+        maxDeliveredTimestamp: Int64?,
+        client: IMClient)
+    {
         assert(client.specificAssertion)
-        var event: IMConversationEvent?
-        if isRead {
-            if rcpTimestamp > (self.lastReadTimestamp ?? 0) {
-                self.lastReadTimestamp = rcpTimestamp
-                event = .lastReadAtUpdated
-            }
-        } else {
-            if rcpTimestamp > (self.lastDeliveredTimestamp ?? 0) {
-                self.lastDeliveredTimestamp = rcpTimestamp
-                event = .lastDeliveredAtUpdated
+        if let maxReadTimestamp = maxReadTimestamp,
+            maxReadTimestamp > (self.lastReadTimestamp ?? 0) {
+            self.lastReadTimestamp = maxReadTimestamp
+            client.eventQueue.async {
+                client.delegate?.client(
+                    client, conversation: self,
+                    event: .lastReadAtUpdated)
             }
         }
-        if let event = event {
+        if let maxDeliveredTimestamp = maxDeliveredTimestamp,
+            maxDeliveredTimestamp > (self.lastDeliveredTimestamp ?? 0) {
+            self.lastDeliveredTimestamp = maxDeliveredTimestamp
             client.eventQueue.async {
                 client.delegate?.client(
                     client, conversation: self,
-                    event: event)
+                    event: .lastDeliveredAtUpdated)
             }
         }
     }