[Explore Feed] Preference Selection

app/src/main/java/org/wikipedia/compose/components/HtmlText.kt

@@ -1,5 +1,6 @@
 package org.wikipedia.compose.components
 
+import androidx.compose.foundation.text.TextAutoSize
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
@@ -44,7 +45,8 @@ fun HtmlText(
     overflow: TextOverflow = TextOverflow.Ellipsis,
     lineHeight: TextUnit = 1.6.em,
     linkInteractionListener: LinkInteractionListener = defaultLinkInteractionListener(),
-    textAlign: TextAlign = TextAlign.Start
+    textAlign: TextAlign = TextAlign.Start,
+    autoSize: TextAutoSize? = null
 ) {
     Text(
         modifier = modifier,
@@ -58,7 +60,8 @@ fun HtmlText(
         color = color,
         maxLines = maxLines,
         overflow = overflow,
-        textAlign = textAlign
+        textAlign = textAlign,
+        autoSize = autoSize
     )
 }
 

app/src/main/java/org/wikipedia/feed/HomeViewModel.kt

@@ -13,7 +13,9 @@ import org.wikipedia.dataclient.page.PageSummary
 import org.wikipedia.feed.image.FeaturedImage
 import org.wikipedia.feed.news.NewsItem
 import org.wikipedia.feed.onthisday.OnThisDay
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceType
 import org.wikipedia.feed.topread.TopRead
+import org.wikipedia.settings.Prefs
 import java.time.LocalDate
 
 enum class HomeTab { COMMUNITY, FOR_YOU }
@@ -56,7 +58,9 @@ class HomeViewModel : ViewModel() {
 
     val wikiSite get() = WikipediaApp.instance.wikiSite
 
-    private val _selectedTab = MutableStateFlow(HomeTab.COMMUNITY)
+    private val _selectedTab = MutableStateFlow(
+        if (Prefs.exploreFeedPreferenceSelection == FeedPreferenceType.PERSONALIZED) HomeTab.FOR_YOU else HomeTab.COMMUNITY
+    )
     val selectedTab = _selectedTab.asStateFlow()
 
     private val _communityState = MutableStateFlow(CommunityContentState())
@@ -88,7 +92,11 @@ class HomeViewModel : ViewModel() {
     }
 
     init {
-        loadCommunityContent()
+        if (_selectedTab.value == HomeTab.COMMUNITY) {
+            loadCommunityContent()
+        } else {
+            loadForYouContent()
+        }
     }
 
     fun refreshCommunityContent() {

app/src/main/java/org/wikipedia/feed/news/NewsItem.kt

@@ -14,7 +14,7 @@ import org.wikipedia.util.ImageUrlUtil
 @Serializable
 class NewsItem(
     val story: String = "",
-    val links: List<PageSummary> = emptyList(),
+    val links: List<PageSummary> = emptyList()
 ) : Parcelable {
 
     fun linkCards(wiki: WikiSite): List<NewsLinkCard> {

app/src/main/java/org/wikipedia/feed/personalization/PersonalizationScreen.kt

@@ -32,6 +32,7 @@ import kotlinx.coroutines.launch
 import org.wikipedia.R
 import org.wikipedia.compose.components.PageIndicator
 import org.wikipedia.compose.theme.WikipediaTheme
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceScreen
 import org.wikipedia.feed.personalization.interest.InterestOnboardingScreen
 
 // TODO: probably renaming the screen name
@@ -46,6 +47,7 @@ fun PersonalizationScreen(
 ) {
     val coroutineScope = rememberCoroutineScope()
     val interestUiState = viewModel.interestUiState.collectAsState()
+    val feedPreferenceUiState = viewModel.feedPreferenceUiState.collectAsState()
     val pagerState = rememberPagerState(pageCount = { screens.size })
 
     LaunchedEffect(pagerState.currentPage) {
@@ -101,13 +103,23 @@ fun PersonalizationScreen(
                                 viewModel.deselectAllArticles()
                             },
                             retryLoading = {
-                                viewModel.retryLoading()
+                                viewModel.retryInterestsLoading()
                             },
                             showError = showError
                         )
                     }
                     PersonalizationPage.FEED_PREFERENCE -> {
-                        // TODO: implement feed preference screen
+                        FeedPreferenceScreen(
+                            modifier = Modifier
+                                .fillMaxSize()
+                                .background(WikipediaTheme.colors.paperColor)
+                                .padding(top = 40.dp),
+                            selectedType = feedPreferenceUiState.value.selectedType,
+                            communityContentState = feedPreferenceUiState.value.communityState,
+                            personalizedContentState = feedPreferenceUiState.value.personalizedState,
+                            onTypeSelected = { viewModel.onFeedPreferenceTypeSelected(it) },
+                            onRetryClick = { viewModel.retryFeedPreferenceLoading(it) }
+                        )
                     }
                 }
             }

app/src/main/java/org/wikipedia/feed/personalization/PersonalizationViewModel.kt

@@ -14,6 +14,11 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import org.wikipedia.WikipediaApp
 import org.wikipedia.database.AppDatabase
+import org.wikipedia.feed.personalization.feedpreference.FeedContentState
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceContent
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceRepository
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceType
+import org.wikipedia.feed.personalization.feedpreference.FeedPreferenceUiState
 import org.wikipedia.feed.personalization.interest.ArticlesState
 import org.wikipedia.feed.personalization.interest.InterestSelectionRepository
 import org.wikipedia.feed.personalization.interest.InterestUiState
@@ -36,8 +41,15 @@ private data class PersonalizedViewModelState(
     val articlesLoading: Boolean = false,
     val articlesError: Throwable? = null,
     val selectedArticles: Set<PageTitle> = emptySet(),
-    val selectedTopics: List<OnboardingTopic> = emptyList()
+    val selectedTopics: List<OnboardingTopic> = emptyList(),
     // Feed preference screen properties
+    val feedPreferenceType: FeedPreferenceType = FeedPreferenceType.COMMUNITY,
+    val communityContent: List<FeedPreferenceContent> = emptyList(),
+    val communityLoading: Boolean = false,
+    val communityError: Throwable? = null,
+    val personalizedContent: List<FeedPreferenceContent> = emptyList(),
+    val personalizedLoading: Boolean = false,
+    val personalizedError: Throwable? = null
 ) {
     fun toInterestUiState(): InterestUiState {
         return InterestUiState(
@@ -64,12 +76,27 @@ private data class PersonalizedViewModelState(
         )
     }
 
-    // Each screen in the personalization flow would have its own function
-    // fun toFeedPreferenceUiState(): FeedPreferenceUiState { ... }
+    fun toFeedPreferenceUiState(): FeedPreferenceUiState {
+        return FeedPreferenceUiState(
+            selectedType = feedPreferenceType,
+            communityState = when {
+                communityLoading -> FeedContentState.Loading
+                communityError != null -> FeedContentState.Error(communityError)
+                else -> FeedContentState.Success(communityContent)
+            },
+            personalizedState = when {
+                personalizedLoading -> FeedContentState.Loading
+                personalizedError != null -> FeedContentState.Error(personalizedError)
+                personalizedContent.isEmpty() -> FeedContentState.Empty
+                else -> FeedContentState.Success(personalizedContent)
+            }
+        )
+    }
 }
 
 class PersonalizationViewModel(
-    private val interestSelectionRepository: InterestSelectionRepository
+    private val interestSelectionRepository: InterestSelectionRepository,
+    private val feedPreferenceRepository: FeedPreferenceRepository
 ) : ViewModel() {
     // Single source of truth for all personalization state, can be easily extended to include feed preference and language selection states as well
     private val state = MutableStateFlow(PersonalizedViewModelState())
@@ -85,9 +112,18 @@ class PersonalizationViewModel(
             initialValue = state.value.toInterestUiState()
         )
 
+    val feedPreferenceUiState = state
+        .map { it.toFeedPreferenceUiState() }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.Eagerly,
+            initialValue = state.value.toFeedPreferenceUiState()
+        )
+
     fun onPageChanged(screen: PersonalizationPage) {
         when (screen) {
             PersonalizationPage.INTERESTS -> loadInterestSelectionScreen()
+            PersonalizationPage.FEED_PREFERENCE -> loadFeedPreferenceScreen()
             else -> {}
         }
     }
@@ -101,6 +137,38 @@ class PersonalizationViewModel(
         }
     }
 
+    private fun loadFeedPreferenceScreen() {
+        if (state.value.communityContent.isEmpty()) {
+            loadCommunityPreviewContent()
+        }
+        loadPersonalizedPreviewContent()
+    }
+
+    private fun loadCommunityPreviewContent() {
+        viewModelScope.launch(CoroutineExceptionHandler { _, throwable ->
+            state.update { it.copy(communityLoading = false, communityError = throwable) }
+            L.e(throwable)
+        }) {
+            state.update { it.copy(communityLoading = true, communityError = null) }
+            val communityContent = feedPreferenceRepository.getCommunityContent()
+            state.update { it.copy(communityContent = communityContent, communityLoading = false) }
+        }
+    }
+
+    private fun loadPersonalizedPreviewContent() {
+        viewModelScope.launch(CoroutineExceptionHandler { _, throwable ->
+            state.update { it.copy(personalizedLoading = false, personalizedError = throwable) }
+            L.e(throwable)
+        }) {
+            state.update { it.copy(personalizedLoading = true, personalizedError = null) }
+            val personalizedContent = feedPreferenceRepository.getInterests(
+                selectedTopics = state.value.selectedTopics,
+                selectedArticles = state.value.selectedArticles
+            )
+            state.update { it.copy(personalizedContent = personalizedContent, personalizedLoading = false) }
+        }
+    }
+
     private suspend fun loadTopics() {
         if (state.value.topics.isNotEmpty()) return
 
@@ -281,7 +349,7 @@ class PersonalizationViewModel(
         }
     }
 
-    fun retryLoading() {
+    fun retryInterestsLoading() {
         val last = state.value.selectedTopics.lastOrNull()
         if (last != null) {
             loadArticlesByTopic(topic = last)
@@ -290,6 +358,18 @@ class PersonalizationViewModel(
         }
     }
 
+    fun onFeedPreferenceTypeSelected(type: FeedPreferenceType) {
+        feedPreferenceRepository.saveFeedPreferenceSelection(type)
+        state.update { it.copy(feedPreferenceType = type) }
+    }
+
+    fun retryFeedPreferenceLoading(type: FeedPreferenceType) {
+        when (type) {
+            FeedPreferenceType.COMMUNITY -> loadCommunityPreviewContent()
+            FeedPreferenceType.PERSONALIZED -> loadPersonalizedPreviewContent()
+        }
+    }
+
     companion object {
         val Factory = viewModelFactory {
             initializer {
@@ -300,6 +380,10 @@ class PersonalizationViewModel(
                         historyEntryWithImageDao = AppDatabase.instance.historyEntryWithImageDao(),
                         readingListPageDao = AppDatabase.instance.readingListPageDao(),
                         wikiSite = WikipediaApp.instance.wikiSite
+                    ),
+                    feedPreferenceRepository = FeedPreferenceRepository(
+                        historyEntryWithImageDao = AppDatabase.instance.historyEntryWithImageDao(),
+                        wikiSite = WikipediaApp.instance.wikiSite
                     )
                 )
             }

app/src/main/java/org/wikipedia/feed/personalization/feedpreference/FeedPreferenceRepository.kt

@@ -0,0 +1,120 @@
+package org.wikipedia.feed.personalization.feedpreference
+
+import org.wikipedia.dataclient.ServiceFactory
+import org.wikipedia.dataclient.WikiSite
+import org.wikipedia.feed.personalization.interest.OnboardingTopic
+import org.wikipedia.history.db.HistoryEntryWithImageDao
+import org.wikipedia.page.PageTitle
+import org.wikipedia.settings.Prefs
+import org.wikipedia.util.StringUtil
+import java.time.LocalDate
+
+class FeedPreferenceRepository(
+    private val historyEntryWithImageDao: HistoryEntryWithImageDao,
+    private val wikiSite: WikiSite
+) {
+    suspend fun getCommunityContent(): List<FeedPreferenceContent> {
+        val currentDate = LocalDate.now()
+
+        val response = ServiceFactory.getRest(wikiSite).getFeedFeatured(
+            year = currentDate.year.toString(),
+            month = "%02d".format(currentDate.monthValue),
+            day = "%02d".format(currentDate.dayOfMonth),
+            lang = wikiSite.languageCode
+        )
+
+        val featuredArticle = response.tfa?.let { article ->
+            FeedPreferenceContent(
+                title = article.displayTitle,
+                description = article.description,
+                imageUrl = article.thumbnailUrl,
+                tag = "Featured Article" // TODO: use localized string resource
+            )
+        }
+
+        val pictureOfTheDay = response.potd?.let { potd ->
+            FeedPreferenceContent(
+                title = null,
+                description = potd.description.text,
+                imageUrl = potd.thumbnailUrl,
+                tag = "Picture of the Day" // TODO: use localized string resource
+            )
+        }
+
+        val inTheNewsArticle = response.news?.first().let { newsItem ->
+            FeedPreferenceContent(
+                title = null,
+                description = StringUtil.removeHTMLTags(newsItem?.story),
+                imageUrl = newsItem?.thumbUrl(),
+                tag = "In the News" // TODO: use localized string resource
+            )
+        }
+
+        return listOfNotNull(
+            featuredArticle,
+            pictureOfTheDay,
+            inTheNewsArticle
+        )
+    }
+
+    suspend fun getInterests(
+        selectedTopics: List<OnboardingTopic>,
+        selectedArticles: Set<PageTitle>
+    ): List<FeedPreferenceContent> {
+        if (selectedTopics.isNotEmpty()) {
+            val contentSize = 3
+            val topicsToUse = selectedTopics.takeLast(contentSize)
+            val baseLimit = contentSize / topicsToUse.size
+            val remainder = contentSize % topicsToUse.size
+
+            val content = topicsToUse.flatMapIndexed { index, topic ->
+                val limit = if (index < remainder) baseLimit + 1 else baseLimit
+                val response = ServiceFactory.get(wikiSite).getArticlesByTopic(articleTopics = topic.queryTopicId, limit = limit)
+                response.query?.pages?.map { page ->
+                    FeedPreferenceContent(
+                        title = page.title,
+                        description = page.description,
+                        imageUrl = page.thumbUrl(),
+                        tag = topic.displayTitle
+                    )
+                } ?: emptyList()
+            }
+            return content
+        }
+
+        if (selectedArticles.isNotEmpty()) {
+            val moreLikeSearchTerm = "morelike:${selectedArticles.take(3).joinToString("|") { it.prefixedText }}"
+            val response = ServiceFactory.get(wikiSite).searchMoreLike(searchTerm = moreLikeSearchTerm, gsrLimit = 3, piLimit = 3)
+            val content = response.query?.pages?.map { page ->
+                FeedPreferenceContent(
+                    title = page.title,
+                    description = page.description,
+                    imageUrl = page.thumbUrl(),
+                    tag = null
+                )
+            } ?: emptyList()
+            return content
+        }
+
+        val readingHistory = historyEntryWithImageDao.getMostRecentEntriesWithImage(3)
+        if (readingHistory.size >= 3) {
+            val moreLikeSearchTerm = "morelike:${readingHistory.take(3).joinToString("|") { it.apiTitle }}"
+            val response = ServiceFactory.get(wikiSite).searchMoreLike(searchTerm = moreLikeSearchTerm, gsrLimit = 3, piLimit = 3)
+            val content = response.query?.pages?.map { page ->
+                FeedPreferenceContent(
+                    title = page.title,
+                    description = page.description,
+                    imageUrl = page.thumbUrl(),
+                    tag = null
+                )
+            } ?: emptyList()
+            return content
+        }
+
+        return listOf()
+    }
+
+    fun saveFeedPreferenceSelection(preferenceType: FeedPreferenceType) {
+        Prefs.exploreFeedPreferenceSelection = preferenceType
+    }
+}