Merges with 'github/develop' and applies spotless

Change-Id: I734022b261df56d546749c2c87051c97096a6970

Author: JoseAlcerreca

JetNews/app/build.gradle

@@ -74,6 +74,7 @@ dependencies {
     implementation "androidx.compose.runtime:runtime-livedata:$compose_version"
 
     implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:2.3.0-alpha06"
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.3.0-alpha06"
 
     androidTestImplementation 'junit:junit:4.13'
     androidTestImplementation 'androidx.test:rules:1.2.0'

JetNews/app/src/androidTest/java/com/example/jetnews/TestHelper.kt

@@ -21,26 +21,16 @@ import androidx.compose.runtime.remember
 import androidx.lifecycle.SavedStateHandle
 import androidx.ui.test.ComposeTestRule
 import com.example.jetnews.ui.JetnewsApp
-import com.example.jetnews.ui.JetnewsStatus
 import com.example.jetnews.ui.NavigationViewModel
 
 /**
  * Launches the app from a test context
  */
 fun ComposeTestRule.launchJetNewsApp(context: Context) {
     setContent {
-        JetnewsStatus.resetState()
         JetnewsApp(
             TestAppContainer(context),
             remember { NavigationViewModel(SavedStateHandle()) }
         )
     }
 }
-
-/**
- * Resets the state of the app. Needs to be executed in Compose code (within a frame)
- */
-fun JetnewsStatus.resetState() {
-    favorites.clear()
-    selectedTopics.clear()
-}

JetNews/app/src/main/java/com/example/jetnews/data/AppContainerImpl.kt

@@ -17,14 +17,10 @@
 package com.example.jetnews.data
 
 import android.content.Context
-import android.os.Handler
-import android.os.Looper
 import com.example.jetnews.data.interests.InterestsRepository
 import com.example.jetnews.data.interests.impl.FakeInterestsRepository
 import com.example.jetnews.data.posts.PostsRepository
 import com.example.jetnews.data.posts.impl.FakePostsRepository
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Executors
 
 /**
  * Dependency Injection container at the application level.
@@ -41,18 +37,8 @@ interface AppContainer {
  */
 class AppContainerImpl(private val applicationContext: Context) : AppContainer {
 
-    private val executorService: ExecutorService by lazy {
-        Executors.newFixedThreadPool(4)
-    }
-
-    private val mainThreadHandler: Handler by lazy {
-        Handler(Looper.getMainLooper())
-    }
-
     override val postsRepository: PostsRepository by lazy {
         FakePostsRepository(
-            executorService = executorService,
-            resultThreadHandler = mainThreadHandler,
             resources = applicationContext.resources
         )
     }

JetNews/app/src/main/java/com/example/jetnews/data/interests/InterestsRepository.kt

@@ -17,6 +17,9 @@
 package com.example.jetnews.data.interests
 
 import com.example.jetnews.data.Result
+import kotlinx.coroutines.flow.Flow
+
+typealias TopicsMap = Map<String, List<String>>
 
 /**
  * Interface to the Interests data layer.
@@ -26,15 +29,47 @@ interface InterestsRepository {
     /**
      * Get relevant topics to the user.
      */
-    fun getTopics(callback: (Result<Map<String, List<String>>>) -> Unit)
+    suspend fun getTopics(): Result<TopicsMap>
 
     /**
      * Get list of people.
      */
-    fun getPeople(callback: (Result<List<String>>) -> Unit)
+    suspend fun getPeople(): Result<List<String>>
 
     /**
      * Get list of publications.
      */
-    fun getPublications(callback: (Result<List<String>>) -> Unit)
+    suspend fun getPublications(): Result<List<String>>
+
+    /**
+     * Toggle between selected and unselected
+     */
+    suspend fun toggleTopicSelection(topic: TopicSelection)
+
+    /**
+     * Toggle between selected and unselected
+     */
+    suspend fun togglePersonSelected(person: String)
+
+    /**
+     * Toggle between selected and unselected
+     */
+    suspend fun togglePublicationSelected(publication: String)
+
+    /**
+     * Currently selected topics
+     */
+    fun observeTopicsSelected(): Flow<Set<TopicSelection>>
+
+    /**
+     * Currently selected people
+     */
+    fun observePeopleSelected(): Flow<Set<String>>
+
+    /**
+     * Currently selected publications
+     */
+    fun observePublicationSelected(): Flow<Set<String>>
 }
+
+data class TopicSelection(val section: String, val topic: String)

JetNews/app/src/main/java/com/example/jetnews/data/interests/impl/FakeInterestsRepository.kt

@@ -18,11 +18,20 @@ package com.example.jetnews.data.interests.impl
 
 import com.example.jetnews.data.Result
 import com.example.jetnews.data.interests.InterestsRepository
+import com.example.jetnews.data.interests.TopicSelection
+import com.example.jetnews.data.interests.TopicsMap
+import com.example.jetnews.utils.addOrRemove
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 /**
  * Implementation of InterestRepository that returns a hardcoded list of
  * topics, people and publications synchronously.
  */
+@OptIn(ExperimentalCoroutinesApi::class)
 class FakeInterestsRepository : InterestsRepository {
 
     private val topics by lazy {
@@ -61,15 +70,53 @@ class FakeInterestsRepository : InterestsRepository {
         )
     }
 
-    override fun getTopics(callback: (Result<Map<String, List<String>>>) -> Unit) {
-        callback(Result.Success(topics))
+    // for now, keep the selections in memory
+    private val selectedTopics = MutableStateFlow(setOf<TopicSelection>())
+    private val selectedPeople = MutableStateFlow(setOf<String>())
+    private val selectedPublications = MutableStateFlow(setOf<String>())
+
+    // Used to make suspend functions that read and update state safe to call from any thread
+    private val mutex = Mutex()
+
+    override suspend fun getTopics(): Result<TopicsMap> {
+        return Result.Success(topics)
+    }
+
+    override suspend fun getPeople(): Result<List<String>> {
+        return Result.Success(people)
+    }
+
+    override suspend fun getPublications(): Result<List<String>> {
+        return Result.Success(publications)
     }
 
-    override fun getPeople(callback: (Result<List<String>>) -> Unit) {
-        callback(Result.Success(people))
+    override suspend fun toggleTopicSelection(topic: TopicSelection) {
+        mutex.withLock {
+            val set = selectedTopics.value.toMutableSet()
+            set.addOrRemove(topic)
+            selectedTopics.value = set
+        }
     }
 
-    override fun getPublications(callback: (Result<List<String>>) -> Unit) {
-        callback(Result.Success(publications))
+    override suspend fun togglePersonSelected(person: String) {
+        mutex.withLock {
+            val set = selectedPeople.value.toMutableSet()
+            set.addOrRemove(person)
+            selectedPeople.value = set
+        }
     }
+
+    override suspend fun togglePublicationSelected(publication: String) {
+        mutex.withLock {
+            val set = selectedPublications.value.toMutableSet()
+            set.addOrRemove(publication)
+            selectedPublications.value = set
+        }
+    }
+
+    override fun observeTopicsSelected(): Flow<Set<TopicSelection>> = selectedTopics
+
+    override fun observePeopleSelected(): Flow<Set<String>> = selectedPeople
+
+    override fun observePublicationSelected(): Flow<Set<String>> = selectedPublications
 }

JetNews/app/src/main/java/com/example/jetnews/data/posts/PostsRepository.kt

@@ -18,6 +18,7 @@ package com.example.jetnews.data.posts
 
 import com.example.jetnews.data.Result
 import com.example.jetnews.model.Post
+import kotlinx.coroutines.flow.Flow
 
 /**
  * Interface to the Posts data layer.
@@ -27,10 +28,20 @@ interface PostsRepository {
     /**
      * Get a specific JetNews post.
      */
-    fun getPost(postId: String, callback: (Result<Post?>) -> Unit)
+    suspend fun getPost(postId: String): Result<Post>
 
     /**
      * Get JetNews posts.
      */
-    fun getPosts(callback: (Result<List<Post>>) -> Unit)
+    suspend fun getPosts(): Result<List<Post>>
+
+    /**
+     * Observe the current favorites
+     */
+    fun observeFavorites(): Flow<Set<String>>
+
+    /**
+     * Toggle a postId to be a favorite or not.
+     */
+    suspend fun toggleFavorite(postId: String)
 }

JetNews/app/src/main/java/com/example/jetnews/data/posts/impl/BlockingFakePostsRepository.kt

@@ -21,11 +21,18 @@ import androidx.compose.ui.graphics.imageFromResource
 import com.example.jetnews.data.Result
 import com.example.jetnews.data.posts.PostsRepository
 import com.example.jetnews.model.Post
+import com.example.jetnews.utils.addOrRemove
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.withContext
 
 /**
  * Implementation of PostsRepository that returns a hardcoded list of
  * posts with resources synchronously.
  */
+@OptIn(ExperimentalCoroutinesApi::class)
 class BlockingFakePostsRepository(private val context: Context) : PostsRepository {
 
     private val postsWithResources: List<Post> by lazy {
@@ -37,11 +44,29 @@ class BlockingFakePostsRepository(private val context: Context) : PostsRepositor
         }
     }
 
-    override fun getPost(postId: String, callback: (Result<Post?>) -> Unit) {
-        callback(Result.Success(postsWithResources.find { it.id == postId }))
+    // for now, keep the favorites in memory
+    private val favorites = MutableStateFlow<Set<String>>(setOf())
+
+    override suspend fun getPost(postId: String): Result<Post> {
+        return withContext(Dispatchers.IO) {
+            val post = postsWithResources.find { it.id == postId }
+            if (post == null) {
+                Result.Error(IllegalArgumentException("Unable to find post"))
+            } else {
+                Result.Success(post)
+            }
+        }
     }
 
-    override fun getPosts(callback: (Result<List<Post>>) -> Unit) {
-        callback(Result.Success(postsWithResources))
+    override suspend fun getPosts(): Result<List<Post>> {
+        return Result.Success(postsWithResources)
+    }
+
+    override fun observeFavorites(): Flow<Set<String>> = favorites
+
+    override suspend fun toggleFavorite(postId: String) {
+        val set = favorites.value.toMutableSet()
+        set.addOrRemove(postId)
+        favorites.value = set
     }
 }