Thumbs-up function 👍

corecomponent/androidcomponent/src/main/res/values/themes.xml

@@ -10,6 +10,7 @@
         <item name="textAppearanceBody1">@style/TextAppearance.DroidKaigi.Body1</item>
         <item name="textAppearanceBody2">@style/TextAppearance.DroidKaigi.Body2</item>
         <item name="textAppearanceCaption">@style/TextAppearance.DroidKaigi.Caption</item>
+        <item name="textAppearanceButton">@style/TextAppearance.DroidKaigi.Button</item>
 
         <!-- Widget styles -->
         <item name="filterChipStyle">@style/Widget.DroidKaigi.FilterChip</item>

corecomponent/androidcomponent/src/main/res/values/type.xml

@@ -50,4 +50,10 @@
         <item name="android:textColor">?colorOnBackground</item>
     </style>
 
+    <!-- Notosans Medium 14sp -->
+    <style name="TextAppearance.DroidKaigi.Button" parent="TextAppearance.MaterialComponents.Button">
+        <item name="android:fontFamily">@font/notosans_medium</item>
+        <item name="fontFamily">@font/notosans_medium</item>
+        <item name="android:textColor">?colorOnBackground</item>
+    </style>
 </resources>

data/firestore/build.gradle

@@ -52,6 +52,14 @@ kotlin {
             implementation Dep.Test.KotlinMultiPlatform.commonModuleTestAnnotations
             implementation Dep.MockK.common
         }
+        test {
+            dependsOn commonMain
+            dependencies {
+                implementation Dep.Test.KotlinMultiPlatform.jvmModuleTest
+                implementation Dep.Test.KotlinMultiPlatform.jvmModuleTestJunit
+                implementation Dep.MockK.jvm
+            }
+        }
         androidTest {
             dependsOn commonMain
             dependencies {

data/firestore/src/commonMain/kotlin/io/github/droidkaigi/confsched2020/data/firestore/Firestore.kt

@@ -6,4 +6,6 @@ import kotlinx.coroutines.flow.Flow
 interface Firestore {
     fun getFavoriteSessionIds(): Flow<List<String>>
     suspend fun toggleFavorite(sessionId: SessionId)
+    fun getThumbsUpCount(sessionId: SessionId): Flow<Int>
+    suspend fun incrementThumbsUpCount(sessionId: SessionId)
 }

data/firestore/src/main/java/io/github/droidkaigi/confsched2020/data/firestore/internal/FirestoreImpl.kt

@@ -1,27 +1,42 @@
 package io.github.droidkaigi.confsched2020.data.firestore.internal
 
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.tasks.Tasks
 import com.google.firebase.auth.FirebaseAuth
 import com.google.firebase.firestore.CollectionReference
 import com.google.firebase.firestore.DocumentReference
 import com.google.firebase.firestore.DocumentSnapshot
+import com.google.firebase.firestore.FieldValue
 import com.google.firebase.firestore.FirebaseFirestore
 import com.google.firebase.firestore.Query
 import com.google.firebase.firestore.QuerySnapshot
 import com.google.firebase.firestore.Source
 import io.github.droidkaigi.confsched2020.data.firestore.Firestore
 import io.github.droidkaigi.confsched2020.model.SessionId
-import javax.inject.Inject
+import kotlinx.coroutines.channels.BroadcastChannel
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.scan
+import kotlinx.coroutines.flow.withIndex
 import kotlinx.coroutines.tasks.await
 import timber.log.Timber
 import timber.log.debug
+import javax.inject.Inject
+import kotlin.math.floor
 
 internal class FirestoreImpl @Inject constructor() : Firestore {
+    private val thumbsUpEventChannel = BroadcastChannel<SessionId>(10000)
 
     override fun getFavoriteSessionIds(): Flow<List<String>> {
         val setupFavorites = flow {
@@ -35,7 +50,7 @@ internal class FirestoreImpl @Inject constructor() : Firestore {
             emit(favoritesRef)
         }
         val favoritesSnapshotFlow = setupFavorites.flatMapLatest {
-            it.whereEqualTo("favorite", true).toFlow()
+            it.whereEqualTo(FAVORITE_VALUE_KEY, true).toFlow()
         }
         return favoritesSnapshotFlow.mapLatest { favorites ->
             Timber.debug { "favoritesSnapshotFlow onNext" }
@@ -57,12 +72,94 @@ internal class FirestoreImpl @Inject constructor() : Firestore {
         } else {
             Timber.debug { "toggleFavorite: $sessionId document not exits" }
             document.reference
-                .set(mapOf("favorite" to newFavorite))
+                .set(mapOf(FAVORITE_VALUE_KEY to newFavorite))
                 .await()
         }
         Timber.debug { "toggleFavorite: end" }
     }
 
+    @Suppress("EXPERIMENTAL_API_USAGE")
+    override fun getThumbsUpCount(sessionId: SessionId): Flow<Int> {
+        val setupThumbsUp = flow {
+            signInIfNeeded()
+            val counterRef = getThumbsUpCounterRef(sessionId)
+            createShardsIfNeeded(counterRef)
+            emit(counterRef)
+        }
+
+        var appliedCount = -1
+        val unappliedCountChannel = BroadcastChannel<Int>(10000)
+        val incrementFlow = thumbsUpEventChannel.asFlow()
+            .filter { it == sessionId }
+            .withIndex()
+            .onEach {
+                unappliedCountChannel.send(
+                    minOf(
+                        it.index - appliedCount,
+                        MAX_APPLY_COUNT
+                    )
+                )
+            }
+            // For firebase pricing
+            .debounce(INCREMENT_DEBOUNCE_MILLIS)
+            .map {
+                val result = minOf(it.index - appliedCount, MAX_APPLY_COUNT)
+                appliedCount = it.index
+                unappliedCountChannel.send(0)
+                it.value to result
+            }
+            .map { (sessionId, count) ->
+                Timber.debug { "thumb up increment:$count" }
+                incrementThumbsUpCountImpl(sessionId, count)
+                count
+            }
+            .onStart {
+                emit(0)
+                unappliedCountChannel.send(0)
+            }
+        val thumbsUpSnapshot = setupThumbsUp
+            .flatMapLatest {
+                it.toFlow()
+            }
+            .combine(incrementFlow) { thumbsCount, _ -> thumbsCount }
+
+        return thumbsUpSnapshot.map { shards ->
+            var count = 0
+            shards.forEach { snap ->
+                count += snap.get(SHARDS_COUNT_KEY, Int::class.java) ?: 0
+            }
+            count
+        }
+            .combine(unappliedCountChannel.asFlow()) { firestoreCount, unappliedCount ->
+                firestoreCount + unappliedCount
+            }.scan(0) { prev, value ->
+                // Prevent counts from dropping due to calculations
+                if (prev < value) {
+                    value
+                } else {
+                    prev
+                }
+            }
+    }
+
+    override suspend fun incrementThumbsUpCount(sessionId: SessionId) {
+        thumbsUpEventChannel.send(sessionId)
+    }
+
+    private suspend fun incrementThumbsUpCountImpl(
+        sessionId: SessionId,
+        count: Int
+    ) {
+        signInIfNeeded()
+        val counterRef = getThumbsUpCounterRef(sessionId)
+        createShardsIfNeeded(counterRef)
+        val shardId = floor(Math.random() * NUM_SHARDS).toInt()
+        counterRef
+            .document(shardId.toString())
+            .update(SHARDS_COUNT_KEY, FieldValue.increment(count.toLong()))
+            .await()
+    }
+
     private fun getFavoritesRef(): CollectionReference {
         val firebaseAuth = FirebaseAuth.getInstance()
         val firebaseUserId = firebaseAuth.currentUser?.uid ?: throw RuntimeException(
@@ -83,6 +180,44 @@ internal class FirestoreImpl @Inject constructor() : Firestore {
         firebaseAuth.signInAnonymously().await()
         Timber.debug { "signInIfNeeded end" }
     }
+
+    private fun getThumbsUpCounterRef(sessionId: SessionId): CollectionReference {
+        return FirebaseFirestore
+            .getInstance()
+            .collection("confsched/2020/sessions/${sessionId.id}/thumbsup_counters")
+    }
+
+    private suspend fun createShardsIfNeeded(counterRef: CollectionReference) {
+        val lastShardId = NUM_SHARDS - 1
+        val lastShard = counterRef
+            .document(lastShardId.toString())
+            .get(Source.SERVER)
+            .await()
+
+        if (lastShard.exists()) {
+            Timber.debug { "createShardsIfNeeded shards already exist" }
+            return
+        }
+
+        val tasks = arrayListOf<Task<Void>>()
+        (0 until NUM_SHARDS).forEach {
+            val makeShard = counterRef
+                .document(it.toString())
+                .set(mapOf(SHARDS_COUNT_KEY to 0))
+            tasks.add(makeShard)
+        }
+
+        Tasks.whenAll(tasks).await()
+        Timber.debug { "createShardsIfNeeded creating shards completed" }
+    }
+
+    companion object {
+        const val NUM_SHARDS = 5
+        const val MAX_APPLY_COUNT = 50
+        const val INCREMENT_DEBOUNCE_MILLIS = 500L
+        const val SHARDS_COUNT_KEY = "shards"
+        const val FAVORITE_VALUE_KEY = "favorite"
+    }
 }
 
 private suspend fun DocumentReference.fastGet(): DocumentSnapshot {

data/firestore/src/test/java/io/github/droidkaigi/confsched2020/data/firestore/internal/FirestoreImplTest.kt

@@ -0,0 +1,59 @@
+package io.github.droidkaigi.confsched2020.data.firestore.internal
+
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.withIndex
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.junit.Ignore
+import org.junit.Test
+
+class FirestoreImplTest {
+    @Ignore
+    @Test
+    fun thumbsUpIncrement() {
+        val channel = BroadcastChannel<Unit>(10000)
+        GlobalScope.launch {
+            delay(100)
+            println("send")
+            channel.send(Unit)
+            println("send")
+            channel.send(Unit)
+            println("send")
+            channel.send(Unit)
+            delay(600)
+            println("send")
+            channel.send(Unit)
+            delay(200)
+            println("send")
+            channel.send(Unit)
+            delay(200)
+            println("send")
+            channel.send(Unit)
+            delay(200)
+            println("send")
+            channel.send(Unit)
+            delay(600)
+            channel.cancel()
+        }
+        runBlocking {
+            var lastIndex = -1
+            channel.asFlow()
+                .withIndex()
+                .debounce(300)
+                .map {
+                    val result = minOf(it.index - lastIndex, 50)
+                    lastIndex = it.index
+                    result
+                }
+                .collect {
+                    println(it)
+                }
+        }
+    }
+}

data/repository/src/main/java/io/github/droidkaigi/confsched2020/data/repository/internal/DataSessionRepository.kt

@@ -18,14 +18,14 @@ import io.github.droidkaigi.confsched2020.model.SessionId
 import io.github.droidkaigi.confsched2020.model.SessionList
 import io.github.droidkaigi.confsched2020.model.SpeechSession
 import io.github.droidkaigi.confsched2020.model.repository.SessionRepository
-import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import timber.log.Timber
 import timber.log.debug
+import javax.inject.Inject
 
 internal class DataSessionRepository @Inject constructor(
     private val droidKaigiApi: DroidKaigiApi,
@@ -129,4 +129,12 @@ internal class DataSessionRepository @Inject constructor(
         val response = droidKaigiApi.getSessions()
         sessionDatabase.save(response)
     }
+
+    override fun thumbsUpCounts(sessionId: SessionId): Flow<Int> {
+        return firestore.getThumbsUpCount(sessionId)
+    }
+
+    override suspend fun incrementThumbsUpCount(sessionId: SessionId) {
+        firestore.incrementThumbsUpCount(sessionId)
+    }
 }

feature/session/src/main/java/io/github/droidkaigi/confsched2020/session/ui/SessionDetailFragment.kt

@@ -123,7 +123,8 @@ class SessionDetailFragment : Fragment(R.layout.fragment_session_detail), Inject
                             adapter,
                             session,
                             uiModel.showEllipsis,
-                            uiModel.searchQuery
+                            uiModel.searchQuery,
+                            uiModel.thumbsUpCount
                         )
                     }
             }
@@ -183,13 +184,20 @@ class SessionDetailFragment : Fragment(R.layout.fragment_session_detail), Inject
         adapter: GroupAdapter<GroupieViewHolder<*>>,
         session: Session,
         showEllipsis: Boolean,
-        searchQuery: String?
+        searchQuery: String?,
+        thumbsUpCount: Int
     ) {
         binding.sessionDetailRecycler.transitionName =
             "${session.id}-${navArgs.transitionNameSuffix}"
 
         val items = mutableListOf<Group>()
-        items += sessionDetailTitleItemFactory.create(session, searchQuery)
+        items += sessionDetailTitleItemFactory.create(
+            session,
+            searchQuery,
+            thumbsUpCount
+        ) {
+            sessionDetailViewModel.thumbsUp(session)
+        }
         items += sessionDetailDescriptionItemFactory.create(
             session,
             showEllipsis,

feature/session/src/main/java/io/github/droidkaigi/confsched2020/session/ui/item/SessionDetailTitleItem.kt

@@ -21,7 +21,9 @@ import java.util.regex.Pattern
 
 class SessionDetailTitleItem @AssistedInject constructor(
     @Assisted private val session: Session,
-    @Assisted private val searchQuery: String?
+    @Assisted private val searchQuery: String?,
+    @Assisted private val thumbsUpCount: Int,
+    @Assisted private val thumbsUpListener: () -> Unit
 ) : BindableItem<ItemSessionDetailTitleBinding>(session.id.hashCode().toLong()) {
     override fun getLayout() = R.layout.item_session_detail_title
 
@@ -72,6 +74,11 @@ class SessionDetailTitleItem @AssistedInject constructor(
 //            Test Code
 //            binding.sessionMessage.text = "セッション部屋がRoom1からRoom3に変更になりました（サンプル）"
 //            binding.sessionMessage.isVisible = true
+
+            binding.thumbsUpCount = thumbsUpCount
+            binding.thumbsUp.setOnClickListener {
+                thumbsUpListener.invoke()
+            }
         }
     }
 
@@ -98,7 +105,9 @@ class SessionDetailTitleItem @AssistedInject constructor(
     interface Factory {
         fun create(
             session: Session,
-            searchQuery: String? = null
+            searchQuery: String? = null,
+            thumbsUpCount: Int,
+            thumbsUpListener: () -> Unit
         ): SessionDetailTitleItem
     }
 }