Reusing of item presenters

Chatto/Source/Chat Items/BaseChatItemPresenter.swift

@@ -35,6 +35,15 @@ open class BaseChatItemPresenter<CellT: UICollectionViewCell>: ChatItemPresenter
 
     public init() {}
 
+    open var isItemUpdateSupported: Bool {
+        assertionFailure("Implement in subclass")
+        return false
+    }
+
+    open func update(with chatItem: ChatItemProtocol) {
+        assertionFailure("Implement in subclass")
+    }
+
     open class func registerCells(_ collectionView: UICollectionView) {
         assert(false, "Implement in subclass")
     }

Chatto/Source/Chat Items/ChatItemProtocolDefinitions.swift

@@ -28,6 +28,7 @@ public typealias ChatItemType = String
 
 public protocol ChatItemProtocol: AnyObject, UniqueIdentificable {
     var type: ChatItemType { get }
+    func hasSameContent(as anotherItem: ChatItemProtocol) -> Bool
 }
 
 public protocol ChatItemDecorationAttributesProtocol {
@@ -42,6 +43,10 @@ public protocol ChatItemMenuPresenterProtocol {
 
 public protocol ChatItemPresenterProtocol: AnyObject, ChatItemMenuPresenterProtocol {
     static func registerCells(_ collectionView: UICollectionView)
+
+    var isItemUpdateSupported: Bool { get }
+    func update(with chatItem: ChatItemProtocol)
+
     var canCalculateHeightInBackground: Bool { get } // Default is false
     func heightForCell(maximumWidth width: CGFloat, decorationAttributes: ChatItemDecorationAttributesProtocol?) -> CGFloat
     func dequeueCell(collectionView: UICollectionView, indexPath: IndexPath) -> UICollectionViewCell

Chatto/Source/Chat Items/DummyChatItemPresenter.swift

@@ -24,13 +24,21 @@
 
 import Foundation
 
-// Handles messages that aren't supported so they appear as invisible
+// Handles messages which aren't supported. So, they appear as invisible.
 class DummyChatItemPresenter: ChatItemPresenterProtocol {
 
     class func registerCells(_ collectionView: UICollectionView) {
         collectionView.register(DummyCollectionViewCell.self, forCellWithReuseIdentifier: "cell-id-unhandled-message")
     }
 
+    var isItemUpdateSupported: Bool {
+        return true
+    }
+
+    func update(with chatItem: ChatItemProtocol) {
+        // Does nothing
+    }
+
     var canCalculateHeightInBackground: Bool {
         return true
     }

Chatto/Source/ChatController/BaseChatViewController+Changes.swift

@@ -301,18 +301,30 @@ extension BaseChatViewController {
 
     private func createCompanionCollection(fromChatItems newItems: [DecoratedChatItem], previousCompanionCollection oldItems: ChatItemCompanionCollection) -> ChatItemCompanionCollection {
         return ChatItemCompanionCollection(items: newItems.map { (decoratedChatItem) -> ChatItemCompanion in
-            let chatItem = decoratedChatItem.chatItem
-            var presenter: ChatItemPresenterProtocol!
-            // We assume that a same messageId can't mutate from one cell class to a different one.
-            // If we ever need to support that then generation of changes needs to suppport reloading items.
-            // Oherwise updateVisibleCells may try to update existing cell with a new presenter which is working with a different type of cell
-
-            // Optimization: reuse presenter if it's the same instance.
-            if let oldChatItemCompanion = oldItems[decoratedChatItem.uid], oldChatItemCompanion.chatItem === chatItem {
-                presenter = oldChatItemCompanion.presenter
-            } else {
-                presenter = self.createPresenterForChatItem(decoratedChatItem.chatItem)
-            }
+
+            /*
+             We use an assumption, that message having a specific messageId never changes its type.
+             If such changes has to be supported, then generation of changes has to suppport reloading items.
+             Otherwise, updateVisibleCells may try to update the existing cells with new presenters which aren't able to work with another types.
+             */
+
+            let presenter: ChatItemPresenterProtocol = {
+                guard let oldChatItemCompanion = oldItems[decoratedChatItem.uid] ?? oldItems[decoratedChatItem.chatItem.uid] else {
+                    return self.createPresenterForChatItem(decoratedChatItem.chatItem)
+                }
+
+                guard oldChatItemCompanion.chatItem.type == decoratedChatItem.chatItem.type else {
+                    return self.createPresenterForChatItem(decoratedChatItem.chatItem)
+                }
+
+                guard oldChatItemCompanion.presenter.isItemUpdateSupported else {
+                    return self.createPresenterForChatItem(decoratedChatItem.chatItem)
+                }
+
+                oldChatItemCompanion.presenter.update(with: decoratedChatItem.chatItem)
+                return oldChatItemCompanion.presenter
+            }()
+
             return ChatItemCompanion(uid: decoratedChatItem.uid, chatItem: decoratedChatItem.chatItem, presenter: presenter, decorationAttributes: decoratedChatItem.decorationAttributes)
         })
     }

Chatto/Source/ChatController/Collaborators/ChatDataSourceProtocol.swift

@@ -24,7 +24,7 @@
 
 import Foundation
 
-public enum UpdateType {
+public enum UpdateType: CaseIterable {
     case normal
     case firstLoad
     case pagination

Chatto/Tests/ChatController/BaseChatViewControllerTestHelpers.swift

@@ -83,14 +83,16 @@ class FakeDataSource: ChatDataSourceProtocol {
 class FakeCell: UICollectionViewCell {}
 
 class FakePresenterBuilder: ChatItemPresenterBuilderProtocol {
-    var presentersCreatedCount: Int = 0
+    private(set) var createdPresenters: [ChatItemPresenterProtocol] = []
+
     func canHandleChatItem(_ chatItem: ChatItemProtocol) -> Bool {
         return chatItem.type == "fake-type"
     }
 
     func createPresenterWithChatItem(_ chatItem: ChatItemProtocol) -> ChatItemPresenterProtocol {
-        self.presentersCreatedCount += 1
-        return FakePresenter()
+        let presenter = FakePresenter()
+        self.createdPresenters.append(presenter)
+        return presenter
     }
 
     var presenterType: ChatItemPresenterProtocol.Type {
@@ -99,6 +101,20 @@ class FakePresenterBuilder: ChatItemPresenterBuilderProtocol {
 }
 
 class FakePresenter: BaseChatItemPresenter<FakeCell> {
+
+    var _isItemUpdateSupportedReturnValue: Bool = false
+    override var isItemUpdateSupported: Bool {
+        return self._isItemUpdateSupportedReturnValue
+    }
+
+    private var _updateWithChatItemCalls: [(ChatItemProtocol)] = []
+    var _updateWithChatItemIsCalled: Bool { return self._updateWithChatItemCallsCount > 0 }
+    var _updateWithChatItemCallsCount: Int { return self._updateWithChatItemCalls.count }
+    var _updateWithChatItemLastCallParams: ChatItemProtocol? { return self._updateWithChatItemCalls.last }
+    override func update(with chatItem: ChatItemProtocol) {
+        self._updateWithChatItemCalls.append((chatItem))
+    }
+
     override class func registerCells(_ collectionView: UICollectionView) {
         collectionView.register(FakeCell.self, forCellWithReuseIdentifier: "fake-cell")
     }
@@ -124,10 +140,15 @@ final class FakeChatItem: ChatItemProtocol {
         self.uid = uid
         self.type = type
     }
+    func hasSameContent(as anotherItem: ChatItemProtocol) -> Bool {
+        return self.type == anotherItem.type
+    }
 }
 
 final class FakeChatItemPresenter: ChatItemPresenterProtocol {
     init() {}
+    var isItemUpdateSupported: Bool { return false }
+    func update(with chatItem: ChatItemProtocol) {}
     static func registerCells(_ collectionView: UICollectionView) {}
     func heightForCell(maximumWidth width: CGFloat, decorationAttributes: ChatItemDecorationAttributesProtocol?) -> CGFloat { return 0 }
     func dequeueCell(collectionView: UICollectionView, indexPath: IndexPath) -> UICollectionViewCell { return UICollectionViewCell() }

Chatto/Tests/ChatController/BaseChatViewControllerTests.swift

@@ -67,7 +67,7 @@ class ChatViewControllerTests: XCTestCase {
         fakeDataSource.chatItems = createFakeChatItems(count: 2)
         controller.chatDataSource = fakeDataSource
         self.fakeDidAppearAndLayout(controller: controller)
-        XCTAssertEqual(2, presenterBuilder.presentersCreatedCount)
+        XCTAssertEqual(2, presenterBuilder.createdPresenters.count)
     }
 
     func testThat_WhenDataSourceChanges_ThenCollectionViewUpdatesAsynchronously() {
@@ -268,10 +268,84 @@ class ChatViewControllerTests: XCTestCase {
 
     // MARK: helpers
 
-    private func fakeDidAppearAndLayout(controller: TesteableChatViewController) {
+    fileprivate func fakeDidAppearAndLayout(controller: TesteableChatViewController) {
         controller.view.frame = CGRect(x: 0, y: 0, width: 400, height: 900)
         controller.viewWillAppear(true)
         controller.viewDidAppear(true)
         controller.view.layoutIfNeeded()
     }
 }
+
+extension ChatViewControllerTests {
+
+    func testThat_WhenDataSourceIsUpdatedWithOneNewItem_ThenOneNewItemPresenterIsCreated() {
+        let presenterBuilder = FakePresenterBuilder()
+        let controller = TesteableChatViewController(presenterBuilders: ["fake-type": [presenterBuilder]])
+        let fakeDataSource = FakeDataSource()
+        fakeDataSource.chatItems = createFakeChatItems(count: 2)
+        controller.chatDataSource = fakeDataSource
+        self.fakeDidAppearAndLayout(controller: controller)
+        presenterBuilder.createdPresenters.forEach { ($0 as! FakePresenter)._isItemUpdateSupportedReturnValue = true }
+        let numberOfPresentersBeforeUpdate = presenterBuilder.createdPresenters.count
+
+        fakeDataSource.chatItems = createFakeChatItems(count: 3)
+        let asyncExpectation = expectation(description: "update")
+        controller.enqueueModelUpdate(updateType: .normal) {
+            asyncExpectation.fulfill()
+        }
+
+        self.waitForExpectations(timeout: 1) { _ in
+            let numberOfPresenterAfterUpdate = presenterBuilder.createdPresenters.count
+            XCTAssertEqual(numberOfPresenterAfterUpdate - numberOfPresentersBeforeUpdate, 1)
+        }
+    }
+
+    func testThat_GivenPresenterSupportsUpdates_WhenDataSourceIsUpdatedWithTheSameItem_ThendNewPresenterIsNotCreated_AndPresenterIsUpdatedOnce() {
+        let presenterBuilder = FakePresenterBuilder()
+        let controller = TesteableChatViewController(presenterBuilders: ["fake-type": [presenterBuilder]])
+        let fakeDataSource = FakeDataSource()
+        fakeDataSource.chatItems = createFakeChatItems(count: 1)
+        controller.chatDataSource = fakeDataSource
+        self.fakeDidAppearAndLayout(controller: controller)
+        let presenter = presenterBuilder.createdPresenters.last! as! FakePresenter
+        presenter._isItemUpdateSupportedReturnValue = true
+        XCTAssertEqual(presenter._updateWithChatItemCallsCount, 0)
+        XCTAssertEqual(presenterBuilder.createdPresenters.count, 1)
+
+        fakeDataSource.chatItems = createFakeChatItems(count: 1)
+        let asyncExpectation = expectation(description: "update")
+        controller.enqueueModelUpdate(updateType: .normal) {
+            asyncExpectation.fulfill()
+        }
+
+        self.waitForExpectations(timeout: 1) { _ in
+            XCTAssertEqual(presenterBuilder.createdPresenters.count, 1)
+            XCTAssertEqual(presenter._updateWithChatItemCallsCount, 1)
+            XCTAssert(presenter._updateWithChatItemLastCallParams! === fakeDataSource.chatItems.first!)
+        }
+    }
+
+    func testThat_GivenPresenterDoesntSupportUpdates_WhenDataSourceIsUpdatedWithTheSameItem_ThenPresenterIsNotUpdated_AndNewPresenterIsCreated() {
+            let presenterBuilder = FakePresenterBuilder()
+            let controller = TesteableChatViewController(presenterBuilders: ["fake-type": [presenterBuilder]])
+            let fakeDataSource = FakeDataSource()
+            fakeDataSource.chatItems = createFakeChatItems(count: 1)
+            controller.chatDataSource = fakeDataSource
+            self.fakeDidAppearAndLayout(controller: controller)
+            let presenter = presenterBuilder.createdPresenters.last! as! FakePresenter
+            presenter._isItemUpdateSupportedReturnValue = false
+            XCTAssertEqual(presenter._updateWithChatItemCallsCount, 0)
+            XCTAssertEqual(presenterBuilder.createdPresenters.count, 1)
+
+            fakeDataSource.chatItems = createFakeChatItems(count: 1)
+            let asyncExpectation = expectation(description: "update")
+            controller.enqueueModelUpdate(updateType: .normal) {
+                asyncExpectation.fulfill()
+            }
+
+            self.waitForExpectations(timeout: 1) { _ in
+                XCTAssertFalse(presenter._updateWithChatItemIsCalled)
+                XCTAssertEqual(presenterBuilder.createdPresenters.count, 2)
+            }
+        }
+}

ChattoAdditions/Source/Chat Items/BaseMessage/BaseMessageModel.swift

@@ -84,4 +84,9 @@ open class MessageModel: MessageModelProtocol {
         self.date = date
         self.status = status
     }
+
+    public func hasSameContent(as anotherItem: ChatItemProtocol) -> Bool {
+        assertionFailure("Should be implemented in a subclass.")
+        return false
+    }
 }

ChattoAdditions/Source/Chat Items/BaseMessage/BaseMessagePresenter.swift

@@ -68,15 +68,15 @@ open class BaseMessagePresenter<BubbleViewT, ViewModelBuilderT, InteractionHandl
             self.interactionHandler = interactionHandler
     }
 
-    public let messageModel: ModelT
+    public internal(set) var messageModel: ModelT {
+        didSet { self.messageViewModel = self.createViewModel() }
+    }
     public let sizingCell: BaseMessageCollectionViewCell<BubbleViewT>
     public let viewModelBuilder: ViewModelBuilderT
     public let interactionHandler: InteractionHandlerT?
     public let cellStyle: BaseMessageCollectionViewCellStyleProtocol
 
-    public private(set) final lazy var messageViewModel: ViewModelT = {
-        return self.createViewModel()
-    }()
+    public private(set) final lazy var messageViewModel: ViewModelT = self.createViewModel()
 
     open func createViewModel() -> ViewModelT {
         let viewModel = self.viewModelBuilder.createViewModel(self.messageModel)

ChattoAdditions/Source/Chat Items/CompoundMessage/CompoundMessagePresenter.swift

@@ -35,14 +35,15 @@ open class CompoundMessagePresenter<ViewModelBuilderT, InteractionHandlerT>
     public typealias ViewModelT = ViewModelBuilderT.ViewModelT
 
     public let compoundCellStyle: CompoundBubbleViewStyleProtocol
-    private let contentFactories: [AnyMessageContentFactory<ModelT>]
-    private let compoundCellDimensions: CompoundBubbleLayoutProvider.Dimensions
 
+    private let compoundCellDimensions: CompoundBubbleLayoutProvider.Dimensions
     private let cache: Cache<CompoundBubbleLayoutProvider.Configuration, CompoundBubbleLayoutProvider>
     private let accessibilityIdentifier: String?
-    private let menuPresenter: ChatItemMenuPresenterProtocol?
 
-    private var contentPresenters: [MessageContentPresenterProtocol] = []
+    private let initialContentFactories: [AnyMessageContentFactory<ModelT>]
+    private var contentFactories: [AnyMessageContentFactory<ModelT>]!
+    private var contentPresenters: [MessageContentPresenterProtocol]!
+    private var menuPresenter: ChatItemMenuPresenterProtocol?
 
     public init(
         messageModel: ModelT,
@@ -58,22 +59,17 @@ open class CompoundMessagePresenter<ViewModelBuilderT, InteractionHandlerT>
     ) {
         self.compoundCellStyle = compoundCellStyle
         self.compoundCellDimensions = compoundCellDimensions
-        self.contentFactories = contentFactories.filter { $0.canCreateMessageContent(forModel: messageModel) }
+        self.initialContentFactories = contentFactories
         self.cache = cache
         self.accessibilityIdentifier = accessibilityIdentifier
-        self.menuPresenter = self.contentFactories.lazy.compactMap { $0.createMenuPresenter(forModel: messageModel) }.first
         super.init(
             messageModel: messageModel,
             viewModelBuilder: viewModelBuilder,
             interactionHandler: interactionHandler,
             sizingCell: sizingCell,
             cellStyle: baseCellStyle
         )
-        self.contentPresenters = self.contentFactories.map { factory in
-            var presenter = factory.createContentPresenter(forModel: self.messageModel)
-            presenter.delegate = self
-            return presenter
-        }
+        self.updateContent()
     }
 
     open override var canCalculateHeightInBackground: Bool {
@@ -84,6 +80,29 @@ open class CompoundMessagePresenter<ViewModelBuilderT, InteractionHandlerT>
         // Cell registration is happening lazily, right before the moment when a cell is dequeued.
     }
 
+    open override var isItemUpdateSupported: Bool {
+        return true
+    }
+
+    open override func update(with chatItem: ChatItemProtocol) {
+        guard let newMessageModel = chatItem as? ModelT else { assertionFailure("Unexpected type of the message: \(type(of: chatItem))."); return }
+        let isUpdateNeeded = !self.messageModel.hasSameContent(as: newMessageModel)
+        self.messageModel = newMessageModel
+        if isUpdateNeeded { self.updateContent() }
+    }
+
+    private func updateContent() {
+        self.contentFactories = self.initialContentFactories.filter { $0.canCreateMessageContent(forModel: self.messageModel) }
+
+        self.contentPresenters = self.contentFactories.compactMap {
+            var presenter = $0.createContentPresenter(forModel: self.messageModel)
+            presenter.delegate = self
+            return presenter
+        }
+
+        self.menuPresenter = self.contentFactories.lazy.compactMap { $0.createMenuPresenter(forModel: self.messageModel) }.first
+    }
+
     open override func dequeueCell(collectionView: UICollectionView, indexPath: IndexPath) -> UICollectionViewCell {
         let cellReuseIdentifier = self.compoundCellReuseId
         collectionView.register(CompoundMessageCollectionViewCell.self, forCellWithReuseIdentifier: cellReuseIdentifier)

ChattoAdditions/Source/Chat Items/PhotoMessages/PhotoMessageModel.swift

@@ -23,6 +23,7 @@
 */
 
 import UIKit
+import Chatto
 
 public protocol PhotoMessageModelProtocol: DecoratedMessageModelProtocol {
     var image: UIImage { get }
@@ -33,12 +34,17 @@ open class PhotoMessageModel<MessageModelT: MessageModelProtocol>: PhotoMessageM
     public var messageModel: MessageModelProtocol {
         return self._messageModel
     }
-    public let _messageModel: MessageModelT // Can't make messasgeModel: MessageModelT: https://gist.github.com/diegosanchezr/5a66c7af862e1117b556
+    public let _messageModel: MessageModelT // Can't make messageModel: MessageModelT: https://gist.github.com/diegosanchezr/5a66c7af862e1117b556
     public let image: UIImage
     public let imageSize: CGSize
     public init(messageModel: MessageModelT, imageSize: CGSize, image: UIImage) {
         self._messageModel = messageModel
         self.imageSize = imageSize
         self.image = image
     }
+    public func hasSameContent(as anotherItem: ChatItemProtocol) -> Bool {
+        guard let anotherMessageModel = anotherItem as? PhotoMessageModel else { return false }
+        return self.image == anotherMessageModel.image
+            && self.imageSize == anotherMessageModel.imageSize
+    }
 }