Feature/user activities screen

app/build.gradle

@@ -37,6 +37,8 @@ android {
             branchNames = ["master"]  // branch names from which you can deploy, master by default
             remoteRepoName = "origin" // alias repository, origin by default
         }
+
+        multiDexEnabled true
     }
     signingConfigs {
         debug {
@@ -105,12 +107,19 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$versions.kotlin"
     implementation 'com.google.code.gson:gson:2.8.6'
+    implementation "androidx.paging:paging-runtime-ktx:2.1.2"
+    implementation "com.google.android.material:material:1.2.1"
+    implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.1.0"
+    implementation 'com.android.support:multidex:1.0.3'
+    implementation "com.squareup.okhttp3:logging-interceptor:3.12.8"
 
     implementation androidLibs
     implementation apolloLibs
     implementation coroutinesLibs
     implementation kodeinLibs
     implementation roomLibs
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
     kapt compilerLibs
 
     testImplementation unitTestLibs

app/src/main/AndroidManifest.xml

@@ -14,6 +14,9 @@
         android:supportsRtl="true"
         android:theme="@style/AppTheme"
         tools:ignore="AllowBackup,GoogleAppIndexingWarning">
+        <activity 
+            android:name=".activities.UserActivitiesActivity"
+            android:theme="@style/AppTheme.WhitishBackground"/>
         <activity
             android:name=".profile.ProfileActivity"
             android:label="@string/app_name" />
@@ -31,4 +34,4 @@
         </activity>
     </application>
 
-</manifest>
+</manifest>

app/src/main/graphql/com/flatstack/android/graphql/query/GetActivities.graphql

@@ -0,0 +1,40 @@
+query GetActivities($after: String, $before: String, $events: [ActivityEvent!], $first: Int, $last: Int) {
+    activities(
+        after: $after,
+        before: $before,
+        events: $events,
+        first: $first,
+        last: $last
+    ) {
+        ...ActivityConnectionFragment
+    }
+}
+
+fragment ActivityConnectionFragment on ActivityConnection {
+    edges {
+        node {
+            ...ActivityFragment
+        }
+    }
+    pageInfo {
+        endCursor
+        hasNextPage
+        hasPreviousPage
+        startCursor
+    }
+}
+
+
+fragment ActivityFragment on Activity {
+    body,
+    createdAt,
+    event,
+    id,
+    title,
+    user {
+        firstName,
+        lastName,
+        email,
+        avatarUrl
+    }
+}

app/src/main/java/com/flatstack/android/Router.kt

@@ -2,6 +2,7 @@ package com.flatstack.android
 
 import android.content.Context
 import android.content.Intent
+import com.flatstack.android.activities.UserActivitiesActivity
 import com.flatstack.android.login.LoginActivity
 import com.flatstack.android.profile.ProfileActivity
 
@@ -23,4 +24,12 @@ class Router(
             }
         })
     }
+
+    fun activities(context: Context, clearStack: Boolean = false) {
+        context.startActivity(Intent(context, UserActivitiesActivity::class.java).apply {
+            if (clearStack) {
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
+            }
+        })
+    }
 }

app/src/main/java/com/flatstack/android/activities/ActivitiesAdapter.kt

@@ -0,0 +1,18 @@
+package com.flatstack.android.activities
+
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.paging.PagedListAdapter
+import com.flatstack.android.R
+
+class ActivitiesAdapter :
+    PagedListAdapter<ActivitiesViewHolderModel, ActivitiesViewHolder>(ActivitiesDiffUtilCallback()) {
+
+    override fun onBindViewHolder(holder: ActivitiesViewHolder, position: Int) {
+        getItem(position)?.let { holder.bind(it) }
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ActivitiesViewHolder(
+        LayoutInflater.from(parent.context).inflate(R.layout.item_activity, parent, false)
+    )
+}

app/src/main/java/com/flatstack/android/activities/ActivitiesDiffUtilCallback.kt

@@ -0,0 +1,15 @@
+package com.flatstack.android.activities
+
+import androidx.recyclerview.widget.DiffUtil
+
+class ActivitiesDiffUtilCallback : DiffUtil.ItemCallback<ActivitiesViewHolderModel>() {
+    override fun areItemsTheSame(
+        oldItem: ActivitiesViewHolderModel,
+        newItem: ActivitiesViewHolderModel
+    ): Boolean = oldItem.id == newItem.id
+
+    override fun areContentsTheSame(
+        oldItem: ActivitiesViewHolderModel,
+        newItem: ActivitiesViewHolderModel
+    ): Boolean = oldItem == newItem
+}

app/src/main/java/com/flatstack/android/activities/ActivitiesRepository.kt

@@ -0,0 +1,125 @@
+package com.flatstack.android.activities
+
+import androidx.lifecycle.asFlow
+import androidx.paging.DataSource
+import androidx.paging.LivePagedListBuilder
+import androidx.paging.PageKeyedDataSource
+import androidx.paging.PagedList
+import com.apollographql.apollo.ApolloClient
+import com.apollographql.apollo.api.Input
+import com.apollographql.apollo.coroutines.toDeferred
+import com.flatstack.android.fragment.ActivityConnectionFragment.Edge
+import com.flatstack.android.fragment.ActivityConnectionFragment.PageInfo
+import com.flatstack.android.graphql.query.GetActivitiesQuery
+import com.flatstack.android.profile.entities.Profile
+import com.flatstack.android.type.ActivityEvent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class ActivitiesRepository(
+    private val apolloClient: ApolloClient
+) {
+    @Suppress("LongMethod")
+    fun getPagedUserActivities(coroutineScope: CoroutineScope, events: List<ActivityEvent>) =
+        LivePagedListBuilder(
+            object : DataSource.Factory<PageInfo, Edge>() {
+                override fun create(): DataSource<PageInfo, Edge> =
+                    object : PageKeyedDataSource<PageInfo, Edge>() {
+                        override fun loadInitial(
+                            params: LoadInitialParams<PageInfo>,
+                            callback: LoadInitialCallback<PageInfo, Edge>
+                        ) {
+                            coroutineScope.launch(Dispatchers.IO) {
+                                apolloClient.query(
+                                    GetActivitiesQuery(
+                                        events = Input.optional(events),
+                                        first = Input.optional(PAGE_SIZE)
+                                    )
+                                ).toDeferred()
+                                    .await().data?.activities?.fragments?.activityConnectionFragment?.let {
+                                        it.edges?.let { edges ->
+                                            callback.onResult(
+                                                edges,
+                                                null,
+                                                it.pageInfo
+                                            )
+                                        }
+                                    }
+                            }
+                        }
+
+                        override fun loadAfter(
+                            params: LoadParams<PageInfo>,
+                            callback: LoadCallback<PageInfo, Edge>
+                        ) {
+                            coroutineScope.launch(Dispatchers.IO) {
+                                apolloClient.query(
+                                    GetActivitiesQuery(
+                                        after = Input.optional(params.key.endCursor),
+                                        events = Input.optional(events),
+                                        first = Input.optional(PAGE_SIZE)
+                                    )
+                                ).toDeferred()
+                                    .await().data?.activities?.fragments?.activityConnectionFragment?.let {
+                                        it.edges?.let { edges ->
+                                            callback.onResult(
+                                                edges,
+                                                it.pageInfo
+                                            )
+                                        }
+                                    }
+                            }
+                        }
+
+                        override fun loadBefore(
+                            params: LoadParams<PageInfo>,
+                            callback: LoadCallback<PageInfo, Edge>
+                        ) {
+                            coroutineScope.launch(Dispatchers.IO) {
+                                apolloClient.query(
+                                    GetActivitiesQuery(
+                                        before = Input.optional(params.key.startCursor),
+                                        events = Input.optional(events),
+                                        first = Input.optional(PAGE_SIZE)
+                                    )
+                                ).toDeferred()
+                                    .await().data?.activities?.fragments?.activityConnectionFragment?.let {
+                                        it.edges?.let { edges ->
+                                            callback.onResult(
+                                                edges,
+                                                it.pageInfo
+                                            )
+                                        }
+                                    }
+                            }
+                        }
+                    }
+            }
+                .mapByPage { edges ->
+                    edges.map { edge ->
+                        edge.node?.fragments?.activityFragment?.let { fragment ->
+                            ActivitiesViewHolderModel(
+                                body = fragment.body,
+                                createdAt = fragment.createdAt.toString(),
+                                event = fragment.event,
+                                id = fragment.id,
+                                title = fragment.title,
+                                user = Profile(
+                                    firstName = fragment.user.firstName ?: "",
+                                    lastName = fragment.user.lastName ?: ""
+                                )
+                            )
+                        }
+                    }
+                },
+            PagedList.Config.Builder()
+                .setEnablePlaceholders(false)
+                .setPageSize(PAGE_SIZE)
+                .build()
+        ).build().asFlow()
+
+    companion object {
+        private const val PAGE_SIZE = 15
+    }
+}

app/src/main/java/com/flatstack/android/activities/ActivitiesViewHolder.kt

@@ -0,0 +1,27 @@
+package com.flatstack.android.activities
+
+import android.view.View
+import com.flatstack.android.R
+import com.flatstack.android.util.recyclerview.BaseHolder
+import kotlinx.android.synthetic.main.item_activity.view.*
+import java.text.SimpleDateFormat
+import java.util.*
+
+class ActivitiesViewHolder(itemView: View) : BaseHolder<ActivitiesViewHolderModel>(itemView) {
+
+    override fun bind(item: ActivitiesViewHolderModel) {
+        with(containerView) {
+            tv_event.text = item.title
+            tv_body.text = item.body
+            tv_created_at.text = SimpleDateFormat("HH:mm, dd MMM yyyy", Locale.ENGLISH).format(
+                SimpleDateFormat("yyyy-mm-dd'T'HH:MM:ss'Z'", Locale.ENGLISH).parse(item.createdAt)
+            )
+            tv_username.text = itemView.context.getString(
+                R.string.username_mask,
+                item.user.firstName,
+                item.user.lastName
+            )
+            tv_id.text = itemView.context.getString(R.string.id_mask, item.id)
+        }
+    }
+}

app/src/main/java/com/flatstack/android/activities/ActivitiesViewHolderModel.kt

@@ -0,0 +1,13 @@
+package com.flatstack.android.activities
+
+import com.flatstack.android.profile.entities.Profile
+import com.flatstack.android.type.ActivityEvent
+
+data class ActivitiesViewHolderModel(
+    val id: String,
+    val body: String,
+    val createdAt: String,
+    val event: ActivityEvent,
+    val title: String,
+    val user: Profile
+)

app/src/main/java/com/flatstack/android/activities/ActivitiesViewModel.kt

@@ -0,0 +1,45 @@
+package com.flatstack.android.activities
+
+import androidx.lifecycle.*
+import androidx.paging.PagedList
+import com.flatstack.android.model.entities.Resource
+import com.flatstack.android.type.ActivityEvent
+import com.flatstack.android.type.ActivityEvent.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
+
+class ActivitiesViewModel(
+    private val activitiesRepository: ActivitiesRepository
+) : ViewModel() {
+
+    private val events = MutableLiveData<List<ActivityEvent>>()
+
+    init {
+        events.postValue(
+            listOf(
+                RESET_PASSWORD_REQUESTED,
+                USER_LOGGED_IN,
+                USER_REGISTERED,
+                USER_RESET_PASSWORD,
+                USER_UPDATED
+            )
+        )
+    }
+
+    val activities: LiveData<Resource<PagedList<ActivitiesViewHolderModel?>>> =
+        events.switchMap { events ->
+            activitiesRepository.getPagedUserActivities(viewModelScope, events)
+                .flowOn(Dispatchers.IO)
+                .map { Resource.success(it) }
+                .onStart { emit(Resource.loading()) }
+                .catch { error ->
+                    error.message?.let {
+                        emit(Resource.error(it))
+                    }
+                }
+                .asLiveData(viewModelScope.coroutineContext)
+        }
+}