Gridrecyclerview with height 0.5 of the screen height - alignment problem (last row cut off) about dpadrecyclerview HOT 14 CLOSED

private fun setupRecyclerView() = with(binding) {
        recycler.adapter = adapter

        recycler.setSpanCount(SPAN_COUNT)

        recycler.setSpanSizeLookup(object : DpadSpanSizeLookup() {
            override fun getSpanSize(position: Int): Int {
                return if (position < adapter.itemCount
                    && adapter.isSectionHeader(position)
                ) SPAN_COUNT else 1
            }
        })

        recycler.attachListController(viewModel.listController)
    }

    companion object {
        const val SPAN_COUNT = 4
    }

open fun isSectionHeader(position: Int): Boolean {
        return differ.currentList[position] is DataHolder.Section<*>
    }

fun DpadRecyclerView.attachListController(
    controller: StreamingListController
) {
    val listener = object : RecyclerView.OnScrollListener() {
        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
            super.onScrolled(recyclerView, dx, dy)

            val layoutManager = recyclerView.layoutManager as? PivotLayoutManager
                ?: return

            val firstVisibleIndex = layoutManager.findFirstVisibleItemPosition()
            val lastVisibleIndex = max(firstVisibleIndex, layoutManager.findLastVisibleItemPosition())

            controller.setIndexRange(range = StreamingListController.IndexRange(
                start = firstVisibleIndex,
                endInclusive = lastVisibleIndex
            ))
        }
    }

    addOnScrollListener(listener)
}

<com.rubensousa.dpadrecyclerview.DpadRecyclerView
        android:id="@+id/recycler"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_marginHorizontal="10dp"
        android:clipToPadding="false"
        android:paddingTop="10dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toStartOf="@id/guideline"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

import android.content.Context
import android.util.AttributeSet
import android.view.View
import androidx.recyclerview.widget.RecyclerView
import com.rubensousa.dpadrecyclerview.DpadRecyclerView

class SectionableRecyclerView : DpadRecyclerView {
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context, attrs: AttributeSet?, defStyle: Int) : super(context, attrs, defStyle)

    init {
        installGlobalLayoutListener {
            // Here we prevent the focus from being lost when the user focuses the empty recyclerview
            if (hasFocus() && childCount > 1) {
                val focused = findFocus()
                if (focused == null || focused is RecyclerView) {
                    getChildAt(1)?.requestFocus()
                }
            }
        }
    }

    override fun setAdapter(adapter: Adapter<*>?) {
        if (adapter != null && adapter !is SectionedListAdapter<*, *, *, *>) {
            throw IllegalArgumentException("Must be a SectionedListAdapter")
        }

        super.setAdapter(adapter)
    }

    override fun focusSearch(focused: View, direction: Int): View? {
        try {
            val adapter = adapter as SectionedListAdapter<*, *, *, *>

            // Get the current position of the focused view
            val currentPosition = getChildAdapterPosition(focused)
            if (currentPosition == NO_POSITION) {
                return super.focusSearch(focused, direction)
            }

            // Find the next position based on the focus direction
            val nextPosition = when (direction) {
                View.FOCUS_UP,
                View.FOCUS_DOWN -> findNextPosition(adapter, currentPosition, direction)

                else -> return super.focusSearch(focused, direction)
            }

            // Ensure the next position is valid
            if (nextPosition == NO_POSITION || !isPositionValid(adapter, nextPosition)) {
                return when (direction) {
                    View.FOCUS_UP -> parent.focusSearch(focused, direction)
                    else -> super.focusSearch(focused, direction)
                }
            }

            // This is to prevent the recycler from reverting to previously focused item
            // in some situations
            layoutManager?.scrollToPosition(nextPosition)

            return findViewAtPosition(nextPosition) ?: return super.focusSearch(focused, direction)

        } catch (e: Exception) {
            return super.focusSearch(focused, direction)
        }
    }

    /**
     * Finds the next valid position to focus on when navigating in the specified direction.
     *
     * @param adapter The adapter of the RecyclerView, which must be a SectionedListAdapter.
     * @param currentPosition The current position of the focused item.
     * @param direction The direction of the focus movement, either View.FOCUS_DOWN or View.FOCUS_UP.
     * @return The next valid position to focus on, or NO_POSITION if no valid position is found.
     */
    private fun findNextPosition(adapter: SectionedListAdapter<*, *, *, *>, currentPosition: Int, direction: Int): Int {
        val spanCount = getSpanCount()
        val currentSpanIndex = getSpanIndex(currentPosition, spanCount)

        return when (direction) {
            View.FOCUS_DOWN -> {
                var nextPosition = currentPosition + 1

                while (
                    isPositionValid(adapter, nextPosition) &&
                    (currentSpanIndex != getSpanIndex(nextPosition, spanCount) || adapter.isSectionHeader(nextPosition))
                ) {
                    nextPosition++
                }

                // Prevent unusual focus movement if the destination cell is empty
                if (nextPosition - currentPosition > (spanCount + 1))
                    findNextPosition(adapter, currentPosition - 1, direction)
                else nextPosition
            }

            View.FOCUS_UP -> {
                var previousPosition = currentPosition - 1

                while (
                    isPositionValid(adapter, previousPosition) &&
                    (currentSpanIndex != getSpanIndex(previousPosition, spanCount) || adapter.isSectionHeader(previousPosition))
                ) {
                    previousPosition--
                }

                // Prevent unusual focus movement if the destination cell is empty
                if (currentPosition - previousPosition > (spanCount + 1))
                    findNextPosition(adapter, currentPosition - 1, direction)
                else previousPosition
            }

            else -> NO_POSITION
        }
    }

    /**
     * Checks if the given position is valid within the adapter's item count.
     *
     * @param adapter The adapter of the RecyclerView, which must be a SectionedListAdapter.
     * @param position The position to check.
     * @return True if the position is within the bounds of the adapter's item count, false otherwise.
     */
    private fun isPositionValid(adapter: SectionedListAdapter<*, *, *, *>, position: Int): Boolean {
        return position in 0 until adapter.itemCount
    }

    /**
     * Retrieves the span index for the given position in the grid.
     *
     * @param position The position of the item.
     * @param spanCount The number of spans in the grid.
     */
    private fun getSpanIndex(position: Int, spanCount: Int): Int {
        return getSpanSizeLookup().getSpanIndex(position, spanCount)
    }

    /**
     * Finds the view at the specified adapter position.
     *
     * @param position The adapter position of the item.
     * @return The view at the specified position, or null if no view is found.
     */
    private fun findViewAtPosition(position: Int): View? {
        val layoutManager = layoutManager ?: return null
        return (0 until layoutManager.childCount)
            .mapNotNull { layoutManager.getChildAt(it) }
            .firstOrNull { getChildAdapterPosition(it) == position }
    }

}