IssueTracker

since it is already marked as deprecated, we can probably do it by now.

Yes you misunderstood

Because the ViewHolder cannot be get in the GridLayoutManager.SpanSizeLookup.getSpanSize(position: Int) method, the solution you provided is not available

My code is as follows:

interface SpanSizeAdapter {
    fun getSpanSize(position: Int): Int
}

class MyGridLayoutManager(context: Context, spanCount: Int) : GridLayoutManager(context, spanCount) {
    init{
        super.setSpanSizeLookup(object : SpanSizeLookup() {
            override fun getSpanSize(position: Int): Int {
                return getSpanSizeImpl(position)
            }
        })
    }

    private var recyclerView: RecyclerView? = null

    override fun onAttachedToWindow(view: RecyclerView) {
        super.onAttachedToWindow(view)
        recyclerView = view
    }

    private fun getSpanSizeImpl(position: Int): Int {
        val adapter = recyclerView?.adapter
        if (adapter != null && position >= 0 && position < adapter.itemCount) {
            val itemSpan = getSpanSizeFromAdapter(adapter, position)
            return if (itemSpan == -1) spanCount else itemSpan.coerceAtLeast(1)
        }
        return 1
    }
    
    private fun getSpanSizeFromAdapter(adapter: RecyclerView.Adapter<*>, position: Int): Int {
        return when (adapter) {
            is SpanSizeAdapter -> {
                adapter.getSpanSize(position)
            }
            is ConcatAdapter -> {
                var startPosition = 0
                val wrapperAdapter = adapter.adapters.find { childAdapter ->
                    val childAdapterEndPosition = startPosition + childAdapter.itemCount - 1
                    if (position in startPosition..childAdapterEndPosition) {
                        true
                    } else {
                        startPosition = childAdapterEndPosition + 1
                        false
                    }
                } ?: throw IllegalArgumentException("Cannot find wrapper for $position")
                val localPosition = position - startPosition
                getSpanSizeFromAdapter(wrapperAdapter, localPosition)
            }
            else -> {
                1
            }
        }
    }
}```

As shown in the code above, when the instance of the adapter is ConcatAdapter, I need to get the adapter list by calling adapter.adapters, and then combine the position to get the wrapper adapter and localPosition.

Although I can achieve my goal now, by looking at the source code, I found that adapter.adapters will return a new ArrayList every time it is called, as follows:

```java
class ConcatAdapter {
    ....
    /**
     * Returns an unmodifiable copy of the list of adapters in this {@link ConcatAdapter}.
     * Note that this is a copy hence future changes in the ConcatAdapter are not reflected in
     * this list.
     *
     * @return A copy of the list of adapters in this ConcatAdapter.
     */
    @NonNull
    public List<? extends Adapter<? extends ViewHolder>> getAdapters() {
        return Collections.unmodifiableList(mController.getCopyOfAdapters());
    }
    ....
}

class ConcatAdapterController {
    ....
    @SuppressWarnings("MixedMutabilityReturnType")
    public List<Adapter<? extends ViewHolder>> getCopyOfAdapters() {
        if (mWrappers.isEmpty()) {
            return Collections.emptyList();
        }
        List<Adapter<? extends ViewHolder>> adapters = new ArrayList<>(mWrappers.size());
        for (NestedAdapterWrapper wrapper : mWrappers) {
            adapters.add(wrapper.adapter);
        }
        return adapters;
    }
    ....
}

This is a bit expensive in the getSpanSize() method, so I hope there is a more economical way to get the wrapper adapter and localPosition based on the position, like this:

class ConcatAdapter {
    @NonNull
    public WrapperAndLocalPosition findWrapperAndLocalPosition(int position, WrapperAndLocalPosition wrapperAndLocalPosition) {
       return mController.findWrapperAndLocalPosition(position, wrapperAndLocalPosition);
    }
}

Oh I see, you don't have access to the ViewHolder (and shouldn't because span size might be called w/o a view holder).

We cannot open up that API as is but we can create a similar public version that will allocate a new pair on each call (or C style API where you can pass the bundle but that is really ugly).

I looked around the code a bit but unfortunately i don't see an easy way to implement your use case, especially if you are adding/removing adapters to the concat adapter.

I understand your concerns, I can accept the scheme of returning a Pair<RecyclerView.Adapter, Int>, which is already much less expensive than a new ArrayList. But if there are other difficulties and the pair cannot be added, I also accept it.

Thanks again.