Follow hashtag button

core/analytics/src/main/java/org/mozilla/social/core/analytics/AnalyticsIdentifiers.kt

@@ -98,4 +98,6 @@ object AnalyticsIdentifiers {
     const val SEARCH_HASHTAG_CLICKED = "search.hashtag.clicked"
     const val SEARCH_ACCOUNT_FOLLOW = "search.account.follow"
     const val SEARCH_HASHTAG_FOLLOW = "search.hashtag.follow"
+
+    const val HASHTAG_FOLLOW = "hashtag.follow"
 }

core/database/src/main/java/org/mozilla/social/core/database/dao/HashTagsDao.kt

@@ -2,6 +2,7 @@ package org.mozilla.social.core.database.dao
 
 import androidx.room.Dao
 import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
 import org.mozilla.social.core.database.model.entities.DatabaseHashTagEntity
 
 @Dao
@@ -16,4 +17,10 @@ interface HashTagsDao : BaseDao<DatabaseHashTagEntity> {
         hashTag: String,
         isFollowing: Boolean,
     )
+
+    @Query(
+        "SELECT * FROM hashtags " +
+        "WHERE name = :name",
+    )
+    fun getHashTagFlow(name: String): Flow<DatabaseHashTagEntity>
 }

core/network/mastodon/src/main/java/org/mozilla/social/core/network/mastodon/TagsApi.kt

@@ -1,6 +1,7 @@
 package org.mozilla.social.core.network.mastodon
 
 import org.mozilla.social.core.network.mastodon.model.NetworkHashTag
+import retrofit2.http.GET
 import retrofit2.http.POST
 import retrofit2.http.Path
 
@@ -15,4 +16,9 @@ interface TagsApi {
     suspend fun unfollowHashTag(
         @Path("hashTag") hashTag: String,
     ): NetworkHashTag
+
+    @GET("api/v1/tags/{hashTag}")
+    suspend fun getHashTag(
+        @Path("hashTag") hashTag: String,
+    ): NetworkHashTag
 }

core/repository/mastodon/src/main/java/org/mozilla/social/core/repository/mastodon/HashtagRepository.kt

@@ -1,5 +1,7 @@
 package org.mozilla.social.core.repository.mastodon
 
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
 import org.mozilla.social.common.annotations.PreferUseCase
 import org.mozilla.social.core.database.dao.HashTagsDao
 import org.mozilla.social.core.model.HashTag
@@ -20,6 +22,12 @@ class HashtagRepository(
         hashTag: HashTag,
     ) = dao.upsert(hashTag.toDatabaseModel())
 
+    fun getHashTagFlow(
+        hashTag: String
+    ): Flow<HashTag> = dao.getHashTagFlow(hashTag).map {
+        it.toExternalModel()
+    }
+
     @PreferUseCase
     suspend fun updateFollowing(
         hashTag: String,
@@ -29,11 +37,18 @@ class HashtagRepository(
         isFollowing,
     )
 
+    @PreferUseCase
     suspend fun followHashTag(
         hashTag: String,
     ): HashTag = api.followHashTag(hashTag).toExternalModel()
 
+    @PreferUseCase
     suspend fun unfollowHashTag(
         hashTag: String,
     ): HashTag = api.unfollowHashTag(hashTag).toExternalModel()
+
+    @PreferUseCase
+    suspend fun getHashTag(
+        hashTag: String
+    ): HashTag = api.getHashTag(hashTag).toExternalModel()
 }

core/ui/common/src/main/java/org/mozilla/social/core/ui/common/following/FollowingButton.kt

@@ -14,9 +14,10 @@ import org.mozilla.social.core.ui.common.text.SmallTextLabel
 fun FollowingButton(
     onButtonClicked: () -> Unit,
     isFollowing: Boolean,
+    modifier: Modifier = Modifier,
 ) {
     MoSoToggleButton(
-        modifier = Modifier.height(32.dp),
+        modifier = modifier.height(32.dp),
         onClick = { onButtonClicked() },
         toggleState = if (isFollowing) {
             ToggleButtonState.Secondary

core/usecase/mastodon/src/main/java/org/mozilla/social/core/usecase/mastodon/MastodonUsecaseModule.kt

@@ -20,6 +20,7 @@ import org.mozilla.social.core.usecase.mastodon.auth.IsSignedInFlow
 import org.mozilla.social.core.usecase.mastodon.auth.Login
 import org.mozilla.social.core.usecase.mastodon.auth.Logout
 import org.mozilla.social.core.usecase.mastodon.hashtag.FollowHashTag
+import org.mozilla.social.core.usecase.mastodon.hashtag.GetHashTag
 import org.mozilla.social.core.usecase.mastodon.hashtag.UnfollowHashTag
 import org.mozilla.social.core.usecase.mastodon.report.Report
 import org.mozilla.social.core.usecase.mastodon.search.SearchAll
@@ -209,4 +210,10 @@ val mastodonUsecaseModule =
         singleOf(::GetDomain)
         singleOf(::SearchAll)
         singleOf(::GetInReplyToAccountNames)
+
+        single {
+            GetHashTag(
+                hashtagRepository = get(),
+            )
+        }
     }

core/usecase/mastodon/src/main/java/org/mozilla/social/core/usecase/mastodon/hashtag/GetHashTag.kt

@@ -0,0 +1,62 @@
+package org.mozilla.social.core.usecase.mastodon.hashtag
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import org.mozilla.social.common.Resource
+import org.mozilla.social.common.annotations.PreferUseCase
+import org.mozilla.social.core.model.HashTag
+import org.mozilla.social.core.repository.mastodon.HashtagRepository
+import timber.log.Timber
+
+class GetHashTag(
+    private val hashtagRepository: HashtagRepository,
+    private val dispatcherIo: CoroutineDispatcher = Dispatchers.IO,
+) {
+
+    @OptIn(PreferUseCase::class)
+    suspend operator fun invoke(
+        name: String,
+        coroutineScope: CoroutineScope,
+    ): Flow<Resource<HashTag>> =
+        flow {
+            emit(Resource.Loading())
+            val deferred = CompletableDeferred<Resource<Unit>>()
+            // the hashtag from the server might be lower case, so we need to assign this
+            // to whatever we get back from the server
+            var realName: String = name
+            coroutineScope.launch(dispatcherIo) {
+                try {
+                    val hashtag = hashtagRepository.getHashTag(realName)
+                    realName = hashtag.name
+                    hashtagRepository.insert(hashtag)
+                    deferred.complete(
+                        Resource.Loaded(
+                            Unit
+                        )
+                    )
+                } catch (e: Exception) {
+                    Timber.e(e)
+                    deferred.complete(Resource.Error(e))
+                }
+            }
+            when (val deferredResult = deferred.await()) {
+                is Resource.Error -> emit(Resource.Error(deferredResult.exception))
+                else -> {
+                    try {
+                        emitAll(hashtagRepository.getHashTagFlow(realName).map { Resource.Loaded(it) })
+                    } catch (e: Exception) {
+                        Timber.e(e)
+                        emit(Resource.Error(e))
+                    }
+                }
+            }
+        }
+}

feature/hashtag/build.gradle.kts

@@ -30,4 +30,6 @@ dependencies {
     implementation(libs.protobuf.kotlin.lite)
 
     implementation(libs.androidx.room)
+
+    implementation(libs.jakewharton.timber)
 }

feature/hashtag/src/main/java/org/mozilla/social/feature/hashtag/HashTagInteractions.kt

@@ -2,4 +2,6 @@ package org.mozilla.social.feature.hashtag
 
 interface HashTagInteractions {
     fun onScreenViewed() = Unit
+    fun onFollowClicked(name: String, isFollowing: Boolean) = Unit
+    fun onRetryClicked() = Unit
 }

feature/hashtag/src/main/java/org/mozilla/social/feature/hashtag/HashTagModule.kt

@@ -28,6 +28,9 @@ val hashTagModule =
                 analytics = get(),
                 userAccountId = get(),
                 timelineRepository = get(),
+                unfollowHashTag = get(),
+                followHashTag = get(),
+                getHashTag = get(),
             )
         }
     }

feature/hashtag/src/main/java/org/mozilla/social/feature/hashtag/HashTagScreen.kt

@@ -1,16 +1,26 @@
 package org.mozilla.social.feature.hashtag
 
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.systemBarsPadding
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.paging.PagingData
 import kotlinx.coroutines.flow.Flow
 import org.koin.androidx.compose.koinViewModel
 import org.koin.core.parameter.parametersOf
+import org.mozilla.social.common.Resource
+import org.mozilla.social.core.model.HashTag
 import org.mozilla.social.core.ui.common.MoSoSurface
 import org.mozilla.social.core.ui.common.appbar.MoSoCloseableTopAppBar
+import org.mozilla.social.core.ui.common.error.GenericError
+import org.mozilla.social.core.ui.common.following.FollowingButton
+import org.mozilla.social.core.ui.common.loading.MaxSizeLoading
 import org.mozilla.social.core.ui.postcard.PostCardInteractions
 import org.mozilla.social.core.ui.postcard.PostCardList
 import org.mozilla.social.core.ui.postcard.PostCardUiState
@@ -20,10 +30,15 @@ internal fun HashTagScreen(
     hashTag: String,
     viewModel: HashTagViewModel = koinViewModel(parameters = { parametersOf(hashTag) }),
 ) {
+
+    val uiState: Resource<HashTag> by viewModel.uiState.collectAsStateWithLifecycle()
+
     HashTagScreen(
+        uiState = uiState,
         hashTag = hashTag,
         feed = viewModel.feed,
         postCardInteractions = viewModel.postCardDelegate,
+        hashTagInteractions = viewModel,
     )
 
     LaunchedEffect(Unit) {
@@ -33,24 +48,54 @@ internal fun HashTagScreen(
 
 @Composable
 private fun HashTagScreen(
+    uiState: Resource<HashTag>,
     hashTag: String,
     feed: Flow<PagingData<PostCardUiState>>,
     postCardInteractions: PostCardInteractions,
+    hashTagInteractions: HashTagInteractions,
 ) {
     MoSoSurface {
         Column(
             modifier = Modifier.systemBarsPadding(),
         ) {
             MoSoCloseableTopAppBar(
                 title = "#$hashTag",
+                actions = {
+                    if (uiState is Resource.Loaded) {
+                        FollowingButton(
+                            modifier = Modifier
+                                .padding(end = 8.dp),
+                            onButtonClicked = {
+                                hashTagInteractions.onFollowClicked(
+                                    hashTag,
+                                    uiState.data.following
+                                )
+                            },
+                            isFollowing = uiState.data.following
+                        )
+                    }
+                }
             )
 
-            PostCardList(
-                feed = feed,
-                postCardInteractions = postCardInteractions,
-                pullToRefreshEnabled = true,
-                isFullScreenLoading = true,
-            )
+            when (uiState) {
+                is Resource.Loading -> {
+                    MaxSizeLoading()
+                }
+                is Resource.Loaded -> {
+                    PostCardList(
+                        feed = feed,
+                        postCardInteractions = postCardInteractions,
+                        pullToRefreshEnabled = true,
+                        isFullScreenLoading = true,
+                    )
+                }
+                is Resource.Error -> {
+                    GenericError(
+                        modifier = Modifier.fillMaxSize(),
+                        onRetryClicked = { hashTagInteractions.onRetryClicked() }
+                    )
+                }
+            }
         }
     }
 }