Migrate Activity to consuming and firing state update events (#91)

* Migrate Activity to consuming state update events

* Let Activity fire state update events instead of updating the state directly

Author: gpunto

stream-feeds-android-client/src/main/kotlin/io/getstream/feeds/android/client/internal/client/FeedsClientImpl.kt

@@ -224,7 +224,6 @@ internal class FeedsClientImpl(
             commentsRepository = commentsRepository,
             pollsRepository = pollsRepository,
             subscriptionManager = stateEventsSubscriptionManager,
-            socketSubscriptionManager = feedsEventsSubscriptionManager,
             commentList =
                 ActivityCommentListImpl(
                     query =

stream-feeds-android-client/src/main/kotlin/io/getstream/feeds/android/client/internal/state/ActivityImpl.kt

@@ -25,15 +25,17 @@ import io.getstream.feeds.android.client.api.model.PollData
 import io.getstream.feeds.android.client.api.model.PollOptionData
 import io.getstream.feeds.android.client.api.model.PollVoteData
 import io.getstream.feeds.android.client.api.model.ThreadedCommentData
+import io.getstream.feeds.android.client.api.model.addOption
+import io.getstream.feeds.android.client.api.model.removeOption
 import io.getstream.feeds.android.client.api.model.request.ActivityAddCommentRequest
+import io.getstream.feeds.android.client.api.model.updateOption
 import io.getstream.feeds.android.client.api.state.Activity
 import io.getstream.feeds.android.client.api.state.ActivityState
 import io.getstream.feeds.android.client.internal.repository.ActivitiesRepository
 import io.getstream.feeds.android.client.internal.repository.CommentsRepository
 import io.getstream.feeds.android.client.internal.repository.PollsRepository
 import io.getstream.feeds.android.client.internal.state.event.StateUpdateEvent
 import io.getstream.feeds.android.client.internal.state.event.handler.ActivityEventHandler
-import io.getstream.feeds.android.client.internal.subscribe.FeedsEventListener
 import io.getstream.feeds.android.client.internal.subscribe.StateUpdateEventListener
 import io.getstream.feeds.android.client.internal.subscribe.onEvent
 import io.getstream.feeds.android.client.internal.utils.flatMap
@@ -62,8 +64,6 @@ import io.getstream.feeds.android.network.models.UpdatePollRequest
  * @property pollsRepository The repository used to fetch and manage polls.
  * @property commentList The list of comments associated with this activity.
  * @property subscriptionManager The manager for state update subscriptions.
- * @property socketSubscriptionManager The manager for WebSocket subscriptions to receive real-time
- *   updates.
  */
 internal class ActivityImpl(
     override val activityId: String,
@@ -74,7 +74,6 @@ internal class ActivityImpl(
     private val pollsRepository: PollsRepository,
     private val commentList: ActivityCommentListImpl,
     private val subscriptionManager: StreamSubscriptionManager<StateUpdateEventListener>,
-    socketSubscriptionManager: StreamSubscriptionManager<FeedsEventListener>,
 ) : Activity {
 
     private val _state: ActivityStateImpl = ActivityStateImpl(currentUserId, commentList.state)
@@ -83,15 +82,17 @@ internal class ActivityImpl(
         ActivityEventHandler(fid = fid, activityId = activityId, state = _state)
 
     init {
-        socketSubscriptionManager.subscribe(eventHandler)
+        subscriptionManager.subscribe(eventHandler)
     }
 
     override val state: ActivityState
         get() = _state
 
     override suspend fun get(): Result<ActivityData> {
         val activity =
-            activitiesRepository.getActivity(activityId).onSuccess { _state.onActivityUpdated(it) }
+            activitiesRepository.getActivity(activityId).onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.ActivityUpdated(fid.rawValue, it))
+            }
         // Query the comments as well (state will be updated automatically)
         queryComments()
         return activity
@@ -135,7 +136,9 @@ internal class ActivityImpl(
             .deleteComment(commentId, hardDelete)
             .onSuccess { (comment, activity) ->
                 subscriptionManager.onEvent(StateUpdateEvent.CommentDeleted(comment))
-                _state.onActivityUpdated(activity)
+                subscriptionManager.onEvent(
+                    StateUpdateEvent.ActivityUpdated(fid.rawValue, activity)
+                )
             }
             .map {}
     }
@@ -180,105 +183,133 @@ internal class ActivityImpl(
     override suspend fun pin(): Result<Unit> {
         return activitiesRepository
             .pin(activityId, fid)
-            .onSuccess { _state.onActivityUpdated(it) }
+            .onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.ActivityUpdated(fid.rawValue, it))
+            }
             .map { Unit }
     }
 
     override suspend fun unpin(): Result<Unit> {
         return activitiesRepository
             .unpin(activityId, fid)
-            .onSuccess { _state.onActivityUpdated(it) }
+            .onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.ActivityUpdated(fid.rawValue, it))
+            }
             .map { Unit }
     }
 
     override suspend fun closePoll(): Result<PollData> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.closePoll(pollId = pollId).onSuccess { _state.onPollUpdated(it) }
+        return poll().flatMap { poll ->
+            pollsRepository.closePoll(pollId = poll.id).onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, it))
+            }
         }
     }
 
     override suspend fun deletePoll(userId: String?): Result<Unit> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.deletePoll(pollId = pollId, userId = userId).onSuccess {
-                _state.onPollDeleted(pollId)
+        return poll().flatMap { poll ->
+            pollsRepository.deletePoll(pollId = poll.id, userId = userId).onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.PollDeleted(fid.rawValue, poll.id))
             }
         }
     }
 
     override suspend fun getPoll(userId: String?): Result<PollData> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.getPoll(pollId = pollId, userId = userId).onSuccess {
-                _state.onPollUpdated(it)
+        return poll().flatMap { poll ->
+            pollsRepository.getPoll(pollId = poll.id, userId = userId).onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, it))
             }
         }
     }
 
     override suspend fun updatePollPartial(request: UpdatePollPartialRequest): Result<PollData> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.updatePollPartial(pollId, request).onSuccess {
-                _state.onPollUpdated(it)
+        return poll().flatMap { poll ->
+            pollsRepository.updatePollPartial(poll.id, request).onSuccess {
+                subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, it))
             }
         }
     }
 
     override suspend fun updatePoll(request: UpdatePollRequest): Result<PollData> {
-        return pollsRepository.updatePoll(request).onSuccess { _state.onPollUpdated(it) }
+        return pollsRepository.updatePoll(request).onSuccess {
+            subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, it))
+        }
     }
 
     override suspend fun createPollOption(
         request: CreatePollOptionRequest
     ): Result<PollOptionData> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.createPollOption(pollId, request).onSuccess {
-                _state.onOptionCreated(it)
+        return poll().flatMap { poll ->
+            pollsRepository.createPollOption(poll.id, request).onSuccess {
+                val newPoll = poll.addOption(it)
+                subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, newPoll))
             }
         }
     }
 
     override suspend fun deletePollOption(optionId: String, userId: String?): Result<Unit> {
-        return pollId().flatMap { pollId ->
+        return poll().flatMap { poll ->
             pollsRepository
-                .deletePollOption(pollId = pollId, optionId = optionId, userId = userId)
-                .onSuccess { _state.onOptionDeleted(optionId) }
+                .deletePollOption(pollId = poll.id, optionId = optionId, userId = userId)
+                .onSuccess {
+                    val newPoll = poll.removeOption(optionId)
+                    subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, newPoll))
+                }
         }
     }
 
     override suspend fun getPollOption(optionId: String, userId: String?): Result<PollOptionData> {
-        return pollId().flatMap { pollId ->
+        return poll().flatMap { poll ->
             pollsRepository
-                .getPollOption(pollId = pollId, optionId = optionId, userId = userId)
-                .onSuccess { _state.onOptionUpdated(it) }
+                .getPollOption(pollId = poll.id, optionId = optionId, userId = userId)
+                .onSuccess {
+                    val newPoll = poll.updateOption(it)
+                    subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, newPoll))
+                }
         }
     }
 
     override suspend fun updatePollOption(
         request: UpdatePollOptionRequest
     ): Result<PollOptionData> {
-        return pollId().flatMap { pollId ->
-            pollsRepository.updatePollOption(pollId, request).onSuccess {
-                _state.onOptionUpdated(it)
+        return poll().flatMap { poll ->
+            pollsRepository.updatePollOption(poll.id, request).onSuccess {
+                val newPoll = poll.updateOption(it)
+                subscriptionManager.onEvent(StateUpdateEvent.PollUpdated(fid.rawValue, newPoll))
             }
         }
     }
 
     override suspend fun castPollVote(request: CastPollVoteRequest): Result<PollVoteData?> {
-        return pollId().flatMap { pollId ->
+        return poll().flatMap { poll ->
             pollsRepository
-                .castPollVote(activityId = activityId, pollId = pollId, request = request)
-                .onSuccess { it?.let { vote -> _state.onPollVoteCasted(vote, pollId) } }
+                .castPollVote(activityId = activityId, pollId = poll.id, request = request)
+                .onSuccess {
+                    it?.let { vote ->
+                        subscriptionManager.onEvent(
+                            StateUpdateEvent.PollVoteCasted(fid.rawValue, poll.id, vote)
+                        )
+                    }
+                }
         }
     }
 
     override suspend fun deletePollVote(voteId: String, userId: String?): Result<PollVoteData?> {
-        return pollId().flatMap { pollId ->
+        return poll().flatMap { poll ->
             pollsRepository
                 .deletePollVote(
                     activityId = activityId,
-                    pollId = pollId,
+                    pollId = poll.id,
                     voteId = voteId,
                     userId = userId,
                 )
-                .onSuccess { it?.let { vote -> _state.onPollVoteRemoved(vote, pollId) } }
+                .onSuccess {
+                    it?.let { vote ->
+                        subscriptionManager.onEvent(
+                            StateUpdateEvent.PollVoteRemoved(fid.rawValue, poll.id, vote)
+                        )
+                    }
+                }
         }
     }
 
@@ -291,11 +322,11 @@ internal class ActivityImpl(
         }
     }
 
-    private suspend fun pollId(): Result<String> {
+    private suspend fun poll(): Result<PollData> {
         return ensureActivityLoaded().flatMap {
             val poll = it.poll
             if (poll != null) {
-                Result.success(poll.id)
+                Result.success(poll)
             } else {
                 Result.failure(IllegalStateException("Activity does not have a poll"))
             }

stream-feeds-android-client/src/main/kotlin/io/getstream/feeds/android/client/internal/state/ActivityStateImpl.kt

@@ -19,20 +19,16 @@ import io.getstream.feeds.android.client.api.model.ActivityData
 import io.getstream.feeds.android.client.api.model.BookmarkData
 import io.getstream.feeds.android.client.api.model.FeedsReactionData
 import io.getstream.feeds.android.client.api.model.PollData
-import io.getstream.feeds.android.client.api.model.PollOptionData
 import io.getstream.feeds.android.client.api.model.PollVoteData
 import io.getstream.feeds.android.client.api.model.ThreadedCommentData
 import io.getstream.feeds.android.client.api.model.addBookmark
-import io.getstream.feeds.android.client.api.model.addOption
 import io.getstream.feeds.android.client.api.model.addReaction
 import io.getstream.feeds.android.client.api.model.castVote
 import io.getstream.feeds.android.client.api.model.deleteBookmark
-import io.getstream.feeds.android.client.api.model.removeOption
 import io.getstream.feeds.android.client.api.model.removeReaction
 import io.getstream.feeds.android.client.api.model.removeVote
 import io.getstream.feeds.android.client.api.model.setClosed
 import io.getstream.feeds.android.client.api.model.update
-import io.getstream.feeds.android.client.api.model.updateOption
 import io.getstream.feeds.android.client.api.state.ActivityCommentListState
 import io.getstream.feeds.android.client.api.state.ActivityState
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -95,48 +91,32 @@ internal class ActivityStateImpl(
     }
 
     override fun onPollClosed(poll: PollData) {
-        if (_poll.value?.id != poll.id) return
-        updatePoll(PollData::setClosed)
+        updatePoll(poll.id, PollData::setClosed)
     }
 
     override fun onPollDeleted(pollId: String) {
-        if (_poll.value?.id != pollId) return
-        updatePoll { null }
+        updatePoll(pollId) { null }
     }
 
     override fun onPollUpdated(poll: PollData) {
-        if (_poll.value?.id != poll.id) return
-        updatePoll { update(poll) }
-    }
-
-    override fun onOptionCreated(option: PollOptionData) {
-        updatePoll { addOption(option) }
-    }
-
-    override fun onOptionDeleted(optionId: String) {
-        updatePoll { removeOption(optionId) }
-    }
-
-    override fun onOptionUpdated(option: PollOptionData) {
-        updatePoll { updateOption(option) }
+        updatePoll(poll.id) { update(poll) }
     }
 
     override fun onPollVoteCasted(vote: PollVoteData, pollId: String) {
-        if (_poll.value?.id != pollId) return
-        updatePoll { castVote(vote, currentUserId) }
+        updatePoll(pollId) { castVote(vote, currentUserId) }
     }
 
     override fun onPollVoteChanged(vote: PollVoteData, pollId: String) {
-        if (_poll.value?.id != pollId) return
-        updatePoll { castVote(vote, currentUserId) }
+        updatePoll(pollId) { castVote(vote, currentUserId) }
     }
 
     override fun onPollVoteRemoved(vote: PollVoteData, pollId: String) {
-        if (_poll.value?.id != pollId) return
-        updatePoll { removeVote(vote, currentUserId) }
+        updatePoll(pollId) { removeVote(vote, currentUserId) }
     }
 
-    private fun updatePoll(update: PollData.() -> PollData?) {
+    private fun updatePoll(pollId: String, update: PollData.() -> PollData?) {
+        if (_poll.value?.id != pollId) return
+
         var updated: PollData? = null
         _poll.update { current -> current?.let(update).also { updated = it } }
         _activity.update { current -> current?.copy(poll = updated) }
@@ -216,27 +196,6 @@ internal interface ActivityStateUpdates {
      */
     fun onPollUpdated(poll: PollData)
 
-    /**
-     * Called when a new poll option is created.
-     *
-     * @param option The newly created poll option data.
-     */
-    fun onOptionCreated(option: PollOptionData)
-
-    /**
-     * Called when a poll option is deleted.
-     *
-     * @param optionId The poll option ID that was deleted.
-     */
-    fun onOptionDeleted(optionId: String)
-
-    /**
-     * Called when a poll option is updated.
-     *
-     * @param option The updated poll option data.
-     */
-    fun onOptionUpdated(option: PollOptionData)
-
     /**
      * Called when a vote is casted on the poll.
      *