Everything You Need to Know About RecyclerView

In this article, we’ll learn how to use savedStateHandle for Process Death and Orientation Change in RecyclerView.

Getting Started

Process Death

As the system runs low on memory, it kills processes in the cache beginning with the process least recently used. When the user navigates back to the app, the system will restart the app in a new process.

Since this only happens if the user has not interacted with the app for a while, it might be permissible to have them return to the app and find it in the initial state.

I recommend you to check these article and video to understand it better.

• Incorporate Lifecycle-Aware Components | Android Developers
• Learn Android Process Death in 6min — YouTube

Orientation Change

Some device configurations can change during runtime, such as screen orientation. When such a change occurs, Android restarts the running Activity The restart behavior is designed to help your application adapt to new configurations by automatically reloading your application with alternative resources that match the new device configuration.

To handle orientation change properly, we need to restore its previous state. For that, we’ll take advantage of onSaveInstanceState() and ViewModel.

First of all, we cannot save large sets of data into our system as the documentation states.

… it is not designed to carry large objects (such as bitmaps) and the data within it must be serialized then deserialized on the main thread, which can consume a lot of memory and make the configuration change slow.

So, what we’ll do is, we’ll take advantage of ViewModel. ViewModel objects are preserved across configuration changes, so they are the perfect place to keep UI data without having to query them again.

Minor Code Changes

We’ll work on our previous code base from Everything You Need to Know About RecyclerView. Before we do any implementation, we’ll need to make some changes.

sealed class NetworkResponse<out T> {
    data class Loading(
        val isPaginating: Boolean = false,
    ): NetworkResponse<Nothing>()

    data class Success<out T>(
        val data: T,
        val isPaginationData: Boolean = false,
        val isPaginationExhausted: Boolean = false,
    ): NetworkResponse<T>()

    data class Failure(
        val errorMessage: String,
    ): NetworkResponse<Nothing>()
}

In NetworkResponse, we’ll move handling PaginationExhaust task to Success because previously, in case of orientation change on PaginationExhaust, ViewModel was keeping the state value as Failure which causes empty list after the orientation change.

We’ll also need to make small adjustments in other classes.

class MainRepository {
    //...

    fun fetchData(page: Int): Flow<NetworkResponse<ArrayList<RecyclerViewModel>>> = flow {
        emit(NetworkResponse.Loading(page != 1))

        kotlinx.coroutines.delay(2000L)

        try {
            if (page == 1)
                emit(NetworkResponse.Success(tempList.toList() as ArrayList<RecyclerViewModel>))
            else {
                val tempPaginationList = arrayListOf<RecyclerViewModel>().apply {
                    for (i in 0..PAGE_SIZE) {
                        add(RecyclerViewModel(UUID.randomUUID().toString(), "Content ${i * 2}"),)
                    }
                }

                if (page < 4) {
                    emit(NetworkResponse.Success(
                        tempPaginationList,
                        isPaginationData = true,
                    ))
                } else {
                    // CHANGE
                    emit(NetworkResponse.Success(
                        arrayListOf(),
                        isPaginationData = true,
                        isPaginationExhausted = true
                    ))
                }
            }
        } catch (e: Exception) {
            // CHANGE
            if (page != 1) {
                emit(NetworkResponse.Success(
                    arrayListOf(),
                    isPaginationData = true,
                    isPaginationExhausted = true
                ))
            } else {
                emit(NetworkResponse.Failure(
                    e.message ?: e.toString(),
                ))
            }
        }
    }.flowOn(Dispatchers.IO)
}

We’ve changed NetworkResponse.Failure to NetworkResponse.Success with empty list and isPaginationExhausted = true. We are sending empty list since we have no data left to paginate. It can be changed depending on your endpoint’s behavior.

abstract class BaseAdapter<T>(open val interaction: Interaction<T>): RecyclerView.Adapter<RecyclerView.ViewHolder>() {
    //...

    fun setErrorView(errorMessage: String) {
        setState(RecyclerViewEnum.Error)
        this.errorMessage = errorMessage
        notifyDataSetChanged()
    }

    fun setData(
        newList: ArrayList<T>,
        isPaginationData: Boolean = false,
        isPaginationExhausted: Boolean = false
    ) {
        setState(if (isPaginationExhausted) RecyclerViewEnum.PaginationExhaust else RecyclerViewEnum.View)

        if (!isPaginationData) {
            if (arrayList.isNotEmpty())
                arrayList.clear()
            arrayList.addAll(newList)
            notifyDataSetChanged()
        } else {
            notifyItemRemoved(itemCount)

            newList.addAll(0, arrayList)
            handleDiffUtil(newList)
        }
    }
}

Finally, in BaseAdapter we’ll change setErrorView and setData functions. setErrorView isn’t going to be responsible from PaginationExhaust. It’ll only update if there is an error.

In setData, we add isPaginationExhausted parameter and use it for setState function. And that’s it.

Process Death & Orientation Change

Now, we are ready to implement Process Death and Orientation Change.

// Key Values
const val PAGE_KEY = "rv.page"
const val SCROLL_POSITION_KEY = "rv.scroll_position"

class MainViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    // Other Variables
    // ...

    /** Process Death Restore
     * isRestoringData is necessary to handle recyclerview.scrollToPosition
     * scrollPosition is middle item's position on recyclerview
     */
    var isRestoringData = false
    private var page: Int = savedStateHandle[PAGE_KEY] ?: 1
    var scrollPosition: Int = savedStateHandle[SCROLL_POSITION_KEY] ?: 0
        private set

    // Variable for detecting orientation change
    var didOrientationChange = false

    init {
        if (page != 1) {
            restoreData()
        } else {
            fetchData()
        }
    }

    private fun restoreData() {
        isRestoringData = true

        var isPaginationExhausted = false
        val tempList = arrayListOf<RecyclerViewModel>()
        viewModelScope.launch(Dispatchers.IO) {
            for (p in 1..page) {
                val job = launch(Dispatchers.IO) {
                    repository.fetchData(p).collect { state ->
                        if (state is NetworkResponse.Success) {
                            tempList.addAll(state.data)
                            isPaginationExhausted = state.isPaginationExhausted
                        }
                    }
                }
                job.join()
            }
            withContext(Dispatchers.Main) {
                _rvList.value = NetworkResponse.Success(tempList, isPaginationData = true, isPaginationExhausted = isPaginationExhausted)
            }
        }
    }

    private fun setPagePosition(newPage: Int) {
        page = newPage
        savedStateHandle[PAGE_KEY] = newPage
    }

    fun setScrollPosition(newPosition: Int) {
        if (!isRestoringData && !didOrientationChange) {
            scrollPosition = newPosition
            savedStateHandle[SCROLL_POSITION_KEY] = newPosition
        }
    }
    
    // Other Functions
    // ...
}

Simulating Process Death — SavedStateHandle