Espaçamento da coluna Reciderview GridLayoutManager do Android

251

Como você define o espaçamento das colunas com um RecyclerView usando um GridLayoutManager? Definir a margem / preenchimento dentro do meu layout não tem efeito.

hitch.united
fonte
Você já tentou subclassificar GridLayoutManagere substituir generateDefaultLayoutParams()e parentes?
CommonsWare
Eu não tinha, pensei que teria havido um método que eu não estava vendo para definir o espaçamento como a exibição em grade. Eu vou tentar isso
hitch.united 15/02

Respostas:

348

O RecyclerViews suporta o conceito de ItemDecoration : compensações especiais e desenhos em torno de cada elemento. Como visto nesta resposta , você pode usar

public class SpacesItemDecoration extends RecyclerView.ItemDecoration {
  private int space;

  public SpacesItemDecoration(int space) {
    this.space = space;
  }

  @Override
  public void getItemOffsets(Rect outRect, View view, 
      RecyclerView parent, RecyclerView.State state) {
    outRect.left = space;
    outRect.right = space;
    outRect.bottom = space;

    // Add top margin only for the first item to avoid double space between items
    if (parent.getChildLayoutPosition(view) == 0) {
        outRect.top = space;
    } else {
        outRect.top = 0;
    }
  }
}

Em seguida, adicione-o via

mRecyclerView = (RecyclerView) rootView.findViewById(R.id.my_recycler_view);
int spacingInPixels = getResources().getDimensionPixelSize(R.dimen.spacing);
mRecyclerView.addItemDecoration(new SpacesItemDecoration(spacingInPixels));
ianhanniballake
fonte
3
Use 'outRect.top = space' e remova 'outRect.bottom' se não quiser mexer com o 'if for the first position'. ; -]
Amio.io
2
@zatziky - sim, se você já usa o preenchimento superior e inferior como parte do seu RecyclerView(e usa clipToPadding="false"), pode reestruturar as coisas um pouco. Caso contrário, basta mover a verificação if para a última vez (pois você ainda deseja o preenchimento inferior no último item).
Ianhanniballake 20/04
18
@ianhanniballake, enquanto isso funciona ao usar um gerenciador de layout de extensão única, falha no gerenciador de layout de extensão múltipla.
precisa
4
Se você fizer dessa maneira com GridLayoutManager - todos os primeiros itens da 2ª, 3ª e nª coluna permanecerão no topo (porque não há espaço). Então eu acho que é melhor fazer .top = espaço / 2 e .bottom = espaço / 2.
Yaroslav
1
Esta resposta não responde à pergunta original. A ênfase da questão está em GridLayoutManager . A resposta não funcionará em layouts de várias colunas / linhas
hch
428

O código a seguir funciona bem e cada coluna tem a mesma largura:

public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {

    private int spanCount;
    private int spacing;
    private boolean includeEdge;

    public GridSpacingItemDecoration(int spanCount, int spacing, boolean includeEdge) {
        this.spanCount = spanCount;
        this.spacing = spacing;
        this.includeEdge = includeEdge;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        int position = parent.getChildAdapterPosition(view); // item position
        int column = position % spanCount; // item column

        if (includeEdge) {
            outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
            outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)

            if (position < spanCount) { // top edge
                outRect.top = spacing;
            }
            outRect.bottom = spacing; // item bottom
        } else {
            outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
            outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
            if (position >= spanCount) {
                outRect.top = spacing; // item top
            }
        }
    }
}

Uso

1. sem margem

insira a descrição da imagem aqui

int spanCount = 3; // 3 columns
int spacing = 50; // 50px
boolean includeEdge = false;
recyclerView.addItemDecoration(new GridSpacingItemDecoration(spanCount, spacing, includeEdge));

2. com borda

insira a descrição da imagem aqui

int spanCount = 3; // 3 columns
int spacing = 50; // 50px
boolean includeEdge = true;
recyclerView.addItemDecoration(new GridSpacingItemDecoration(spanCount, spacing, includeEdge));
edwardaa
fonte
12
Funciona a menos que você tenha itens com várias extensões, como cabeçalhos.
Matthew
8
Ótima resposta; uma dica: o espaçamento está em px (para que você possa converter dp em px usando Math.round (someDpValue * getResources (). getDisplayMetrics (). density))
Kevin Lee
1
Está funcionando bem, mas estou tendo um problema, estou usando GridLayoutManager com spanCount de 2 (padrão), mas o usuário pode alterar o spanCount; portanto, quando spanCount muda da posição padrão, há um preenchimento muito mais visível em algumas posições, como spanCount padding / margin em 2,3 8,9 12,13 etc.
Haris Qureshi
2
Funciona bem! Mas tenho alguns problemas com o StaggeredGridLayoutManager. Às vezes, as margens horizontais do imgur.com/XVutH5u diferem.
Ufkoku
2
Isso não funciona quando o layout é rtl (para 2 colunas ou mais). Atualmente, o espaço entre as colunas não está correto quando no modo RTL. você precisa substituir: outRect.left por outRect.right quando estiver em rtl.
Masoud Mohammadi
83

A seguir, é apresentada a solução simples passo a passo, se você deseja o espaçamento igual entre itens e tamanhos iguais.

ItemOffsetDecoration

public class ItemOffsetDecoration extends RecyclerView.ItemDecoration {

    private int mItemOffset;

    public ItemOffsetDecoration(int itemOffset) {
        mItemOffset = itemOffset;
    }

    public ItemOffsetDecoration(@NonNull Context context, @DimenRes int itemOffsetId) {
        this(context.getResources().getDimensionPixelSize(itemOffsetId));
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent,
            RecyclerView.State state) {
        super.getItemOffsets(outRect, view, parent, state);
        outRect.set(mItemOffset, mItemOffset, mItemOffset, mItemOffset);
    }
}

Implementação

No seu código-fonte, adicione ItemOffsetDecorationao seuRecyclerView. valor de deslocamento do item deve ter metade do tamanho do valor real que você deseja adicionar como espaço entre os itens.

mRecyclerView.setLayoutManager(new GridLayoutManager(context, NUM_COLUMNS);
ItemOffsetDecoration itemDecoration = new ItemOffsetDecoration(context, R.dimen.item_offset);
mRecyclerView.addItemDecoration(itemDecoration);

Além disso, defina o valor do deslocamento do item como preenchimento para ele RecyclerViewe especifique android:clipToPadding=false.

<android.support.v7.widget.RecyclerView
    android:id="@+id/recyclerview_grid"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clipToPadding="false"
    android:padding="@dimen/item_offset"/>
yqritc
fonte
Perfeito, é simples e eficaz.
B.shruti
28

Tente isso. Ele cuidará de espaçamento igual ao redor. Funciona com Lista, Grade e StaggeredGrid.

Editado

O código atualizado deve lidar com a maioria dos casos de canto com extensões, orientação etc. Observe que, se estiver usando setSpanSizeLookup () com GridLayoutManager, a configuração de setSpanIndexCacheEnabled () é recomendada por motivos de desempenho.

Observe que parece que, com o StaggeredGrid, parece haver um erro no qual o índice das crianças fica maluco e difícil de rastrear, portanto o código abaixo pode não funcionar muito bem com o StaggeredGridLayoutManager.

public class ListSpacingDecoration extends RecyclerView.ItemDecoration {

  private static final int VERTICAL = OrientationHelper.VERTICAL;

  private int orientation = -1;
  private int spanCount = -1;
  private int spacing;
  private int halfSpacing;


  public ListSpacingDecoration(Context context, @DimenRes int spacingDimen) {

    spacing = context.getResources().getDimensionPixelSize(spacingDimen);
    halfSpacing = spacing / 2;
  }

  public ListSpacingDecoration(int spacingPx) {

    spacing = spacingPx;
    halfSpacing = spacing / 2;
  }

  @Override
  public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {

    super.getItemOffsets(outRect, view, parent, state);

    if (orientation == -1) {
        orientation = getOrientation(parent);
    }

    if (spanCount == -1) {
        spanCount = getTotalSpan(parent);
    }

    int childCount = parent.getLayoutManager().getItemCount();
    int childIndex = parent.getChildAdapterPosition(view);

    int itemSpanSize = getItemSpanSize(parent, childIndex);
    int spanIndex = getItemSpanIndex(parent, childIndex);

    /* INVALID SPAN */
    if (spanCount < 1) return;

    setSpacings(outRect, parent, childCount, childIndex, itemSpanSize, spanIndex);
  }

  protected void setSpacings(Rect outRect, RecyclerView parent, int childCount, int childIndex, int itemSpanSize, int spanIndex) {

    outRect.top = halfSpacing;
    outRect.bottom = halfSpacing;
    outRect.left = halfSpacing;
    outRect.right = halfSpacing;

    if (isTopEdge(parent, childCount, childIndex, itemSpanSize, spanIndex)) {
        outRect.top = spacing;
    }

    if (isLeftEdge(parent, childCount, childIndex, itemSpanSize, spanIndex)) {
        outRect.left = spacing;
    }

    if (isRightEdge(parent, childCount, childIndex, itemSpanSize, spanIndex)) {
        outRect.right = spacing;
    }

    if (isBottomEdge(parent, childCount, childIndex, itemSpanSize, spanIndex)) {
        outRect.bottom = spacing;
    }
  }

  @SuppressWarnings("all")
  protected int getTotalSpan(RecyclerView parent) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getSpanCount();
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return ((StaggeredGridLayoutManager) mgr).getSpanCount();
    } else if (mgr instanceof LinearLayoutManager) {
        return 1;
    }

    return -1;
  }

  @SuppressWarnings("all")
  protected int getItemSpanSize(RecyclerView parent, int childIndex) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getSpanSizeLookup().getSpanSize(childIndex);
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return 1;
    } else if (mgr instanceof LinearLayoutManager) {
        return 1;
    }

    return -1;
  }

  @SuppressWarnings("all")
  protected int getItemSpanIndex(RecyclerView parent, int childIndex) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getSpanSizeLookup().getSpanIndex(childIndex, spanCount);
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return childIndex % spanCount;
    } else if (mgr instanceof LinearLayoutManager) {
        return 0;
    }

    return -1;
  }

  @SuppressWarnings("all")
  protected int getOrientation(RecyclerView parent) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof LinearLayoutManager) {
        return ((LinearLayoutManager) mgr).getOrientation();
    } else if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getOrientation();
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return ((StaggeredGridLayoutManager) mgr).getOrientation();
    }

    return VERTICAL;
  }

  protected boolean isLeftEdge(RecyclerView parent, int childCount, int childIndex, int itemSpanSize, int spanIndex) {

    if (orientation == VERTICAL) {

        return spanIndex == 0;

    } else {

        return (childIndex == 0) || isFirstItemEdgeValid((childIndex < spanCount), parent, childIndex);
    }
  }

  protected boolean isRightEdge(RecyclerView parent, int childCount, int childIndex, int itemSpanSize, int spanIndex) {

    if (orientation == VERTICAL) {

        return (spanIndex + itemSpanSize) == spanCount;

    } else {

        return isLastItemEdgeValid((childIndex >= childCount - spanCount), parent, childCount, childIndex, spanIndex);
    }
  }

  protected boolean isTopEdge(RecyclerView parent, int childCount, int childIndex, int itemSpanSize, int spanIndex) {

    if (orientation == VERTICAL) {

        return (childIndex == 0) || isFirstItemEdgeValid((childIndex < spanCount), parent, childIndex);

    } else {

        return spanIndex == 0;
    }
  }

  protected boolean isBottomEdge(RecyclerView parent, int childCount, int childIndex, int itemSpanSize, int spanIndex) {

    if (orientation == VERTICAL) {

        return isLastItemEdgeValid((childIndex >= childCount - spanCount), parent, childCount, childIndex, spanIndex);

    } else {

        return (spanIndex + itemSpanSize) == spanCount;
    }
  }

  protected boolean isFirstItemEdgeValid(boolean isOneOfFirstItems, RecyclerView parent, int childIndex) {

    int totalSpanArea = 0;
    if (isOneOfFirstItems) {
        for (int i = childIndex; i >= 0; i--) {
            totalSpanArea = totalSpanArea + getItemSpanSize(parent, i);
        }
    }

    return isOneOfFirstItems && totalSpanArea <= spanCount;
  }

  protected boolean isLastItemEdgeValid(boolean isOneOfLastItems, RecyclerView parent, int childCount, int childIndex, int spanIndex) {

    int totalSpanRemaining = 0;
    if (isOneOfLastItems) {
        for (int i = childIndex; i < childCount; i++) {
            totalSpanRemaining = totalSpanRemaining + getItemSpanSize(parent, i);
        }
    }

    return isOneOfLastItems && (totalSpanRemaining <= spanCount - spanIndex);
  }
}

Espero que ajude.

Pirdad Sakhizada
fonte
1
Tenho espaço duplo logo após a primeira linha de itens. Isso acontece porque parent.getChildCount () retorna 1 para o primeiro item, 2 para o segundo e assim por diante. Então, sugiro adicionar espaço aos itens da borda superior, como: outRect.top = childIndex <spanCount? spacingInPixels: 0; E adicione espaço inferior para cada item: outRect.bottom = spacingInPixels;
IvanP 24/05
No momento da rolagem do RecyclerView, o espaçamento foi alterado.
Yugesh
3
Eu acho que parent.getChildCount () deve ser alterado para "parent.getLayoutManager (). GetItemCount ()". Além disso, a função isBottomEdge precisa ser alterada para "return childIndex> = childCount - spanCount + spanIndex". Depois de alterá-las, obtive espaçamento igual. Mas observe que esta solução não fornece tamanhos iguais de itens se a contagem de span for maior que 2, pois o valor do deslocamento é diferente dependendo da posição.
yqritc 27/05
1
@yqritc obrigado por informar parent.getChildCount (). Atualizei minha resposta para usar o parent.getLayoutManager (). GetItemCount ()
Pirdad Sakhizada
2
Isso funcionou muito bem fora da caixa, mesmo com extensões variáveis, parabéns e obrigado!
Pierre-Luc Paour
21

O código a seguir manipulará StaggeredGridLayoutManager, GridLayoutManager e LinearLayoutManager.

public class SpacesItemDecoration extends RecyclerView.ItemDecoration {

    private int halfSpace;

    public SpacesItemDecoration(int space) {
        this.halfSpace = space / 2;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {

        if (parent.getPaddingLeft() != halfSpace) {
            parent.setPadding(halfSpace, halfSpace, halfSpace, halfSpace);
            parent.setClipToPadding(false);
        }

        outRect.top = halfSpace;
        outRect.bottom = halfSpace;
        outRect.left = halfSpace;
        outRect.right = halfSpace;
    }
}

Então use

mRecyclerView.addItemDecoration(new SpacesItemDecoration(mMargin));
Mark Hetherington
fonte
1
Este é o mais simples. Uma coisa importante é que você também deve adicionar o preenchimento ao pai no xml. No meu caso, funciona dessa maneira. Obrigado.
Samir
Na SpaceItemDecorationverdade, ele adiciona o preenchimento ao pai (a visualização do reciclador).
Mark Hetherington
única halfSpaceestofamento apareceu (para o lado direito) em que não tinha fixado o estofo para o pais em XML
Samir
Só faltava no lado direito? Pode ser que você tenha meio espaço definido como o leftPadding no lado esquerdo já no xml e esse código verifica apenas se o preenchimento esquerdo está definido no RecyclerView ou não.
Mark Hetherington
Bem, eu não tenho nenhum preenchimento definido no xml.
Samir
11

Aqui está uma solução que não requer "spanCount" (número de colunas) que eu a uso porque uso GridAutofitLayoutManager (calcula o número de colunas de acordo com o tamanho de célula necessário)

( lembre-se de que isso funcionará apenas no GridLayoutManager )

public class GridSpacesItemDecoration extends RecyclerView.ItemDecoration {
    private final boolean includeEdge;
    private int spacing;


    public GridSpacesItemDecoration(int spacing, boolean includeEdge) {
        this.spacing = spacing;
        this.includeEdge = includeEdge;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        if (parent.getLayoutManager() instanceof GridLayoutManager) {
            GridLayoutManager layoutManager = (GridLayoutManager)parent.getLayoutManager();
            int spanCount = layoutManager.getSpanCount();
            int position = parent.getChildAdapterPosition(view); // item position
            int column = position % spanCount; // item column

            if (includeEdge) {
                outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
                outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)

                if (position < spanCount) { // top edge
                    outRect.top = spacing;
                }
                outRect.bottom = spacing; // item bottom
            } else {
                outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
                outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
                if (position >= spanCount) {
                    outRect.top = spacing; // item top
                }
            }

        }

    }
}

Aqui está o GridAutofitLayoutManager, se alguém estiver interessado:

public class GridAutofitLayoutManager extends GridLayoutManager {
    private int mColumnWidth;
    private boolean mColumnWidthChanged = true;

    public GridAutofitLayoutManager(Context context, int columnWidth)
    {
        /* Initially set spanCount to 1, will be changed automatically later. */
        super(context, 1);
        setColumnWidth(checkedColumnWidth(context, columnWidth));
    }

    public GridAutofitLayoutManager(Context context,int unit, int columnWidth)
    {
        /* Initially set spanCount to 1, will be changed automatically later. */
        super(context, 1);
        int pixColumnWidth = (int) TypedValue.applyDimension(unit, columnWidth, context.getResources().getDisplayMetrics());
        setColumnWidth(checkedColumnWidth(context, pixColumnWidth));
    }

    public GridAutofitLayoutManager(Context context, int columnWidth, int orientation, boolean reverseLayout)
    {
        /* Initially set spanCount to 1, will be changed automatically later. */
        super(context, 1, orientation, reverseLayout);
        setColumnWidth(checkedColumnWidth(context, columnWidth));
    }

    private int checkedColumnWidth(Context context, int columnWidth)
    {
        if (columnWidth <= 0)
        {
            /* Set default columnWidth value (48dp here). It is better to move this constant
            to static constant on top, but we need context to convert it to dp, so can't really
            do so. */
            columnWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 48,
                    context.getResources().getDisplayMetrics());
        }
        return columnWidth;
    }

    public void setColumnWidth(int newColumnWidth)
    {
        if (newColumnWidth > 0 && newColumnWidth != mColumnWidth)
        {
            mColumnWidth = newColumnWidth;
            mColumnWidthChanged = true;
        }
    }

    @Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state)
    {
        int width = getWidth();
        int height = getHeight();
        if (mColumnWidthChanged && mColumnWidth > 0 && width > 0 && height > 0)
        {
            int totalSpace;
            if (getOrientation() == VERTICAL)
            {
                totalSpace = width - getPaddingRight() - getPaddingLeft();
            }
            else
            {
                totalSpace = height - getPaddingTop() - getPaddingBottom();
            }
            int spanCount = Math.max(1, totalSpace / mColumnWidth);
            setSpanCount(spanCount);

            mColumnWidthChanged = false;
        }
        super.onLayoutChildren(recycler, state);
    }
}

Finalmente:

mDevicePhotosView.setLayoutManager(new GridAutofitLayoutManager(getContext(), getResources().getDimensionPixelSize(R.dimen.item_size)));
mDevicePhotosView.addItemDecoration(new GridSpacesItemDecoration(Util.dpToPx(getContext(), 2),true));
Gil SH
fonte
Oi. Isso funciona incrível, mas estou usando um cabeçalho com sua solução. Você pode sugerir como obter um cabeçalho de largura total?
Ajeet
gentilmente, você pode verificar a posição com o gerenciador de layout da seguinte forma, layoutManager.getPosition(view)depois dessa verificação, se a posição é zero e será o seu cabeçalho. Além disso, dessa forma, você poderá adicionar outro cabeçalho em qualquer posição que desejar :)
Mina Samir
9

Existe apenas uma solução fácil, que você pode lembrar e implementar sempre que necessário. Sem bugs, sem cálculos malucos. Coloque margem no layout do cartão / item e coloque o mesmo tamanho do preenchimento no RecyclerView:

item_layout.xml

<CardView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:margin="10dp">

activity_layout.xml

<RecyclerView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="10dp"/>

ATUALIZAR: insira a descrição da imagem aqui

Galya
fonte
Funciona bem! você poderia elaborar sobre o assunto, por favor?
Elyar abad 11/10/19
Muito obrigado! Eu estava procurando por alguma razão técnica pela qual é necessária uma cooperação entre o preenchimento do reciclador e a margem do item. De qualquer maneira que você fez tanto por mim. . .
Elyar abad 15/10/19
7

Se você deseja corrigir o tamanho do seu RecyclerViewitem em todos os dispositivos. Você pode fazer assim

public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {

    private int mSpanCount;
    private float mItemSize;

    public GridSpacingItemDecoration(int spanCount, int itemSize) {
        this.mSpanCount = spanCount;
        mItemSize = itemSize;
    }

    @Override
    public void getItemOffsets(final Rect outRect, final View view, RecyclerView parent,
            RecyclerView.State state) {
        final int position = parent.getChildLayoutPosition(view);
        final int column = position % mSpanCount;
        final int parentWidth = parent.getWidth();
        int spacing = (int) (parentWidth - (mItemSize * mSpanCount)) / (mSpanCount + 1);
        outRect.left = spacing - column * spacing / mSpanCount;
        outRect.right = (column + 1) * spacing / mSpanCount;

        if (position < mSpanCount) {
            outRect.top = spacing;
        }
        outRect.bottom = spacing;
    }
}

recyclerview_item.xml

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="@dimen/recycler_view_item_width" 
    ...
    >
    ...
</LinearLayout>

dimens.xml

 <dimen name="recycler_view_item_width">60dp</dimen>

Atividade

int numberOfColumns = 3;
mRecyclerView.setLayoutManager(new GridLayoutManager(this, numberOfColumns));
mRecyclerView.setAdapter(...);
mRecyclerView.addItemDecoration(new GridSpacingItemDecoration(3,
        getResources().getDimensionPixelSize(R.dimen.recycler_view_item_width)));

insira a descrição da imagem aqui insira a descrição da imagem aqui

Phan Van Linh
fonte
funcionará de acordo com o tamanho da tela? Como está sendo exibido na tela de 5 polegadas? Eles também têm a mesma aparência em outros tamanhos de tela?
Sunil
o tamanho do item será fixo, mas o espaço entre item pode diferente, você pode ver também 2 imagens acima para entender
Phan Van Linh
Elas parecem diferentes na maneira diferente sizes.any tela, mas trabalho muito obrigado
Sunil
6

A resposta selecionada é quase perfeita, mas, dependendo do espaço, a largura dos itens não pode ser igual. (No meu caso, foi crítico). Acabei com este código que aumenta um pouco o espaço, para que os itens tenham a mesma largura.

   class GridSpacingItemDecoration(private val columnCount: Int, @Px preferredSpace: Int, private val includeEdge: Boolean): RecyclerView.ItemDecoration() {

    /**
     * In this algorithm space should divide by 3 without remnant or width of items can have a difference
     * and we want them to be exactly the same
     */
    private val space = if (preferredSpace % 3 == 0) preferredSpace else (preferredSpace + (3 - preferredSpace % 3))

    override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView, state: RecyclerView.State?) {
        val position = parent.getChildAdapterPosition(view)

        if (includeEdge) {

            when {
                position % columnCount == 0 -> {
                    outRect.left = space
                    outRect.right = space / 3
                }
                position % columnCount == columnCount - 1 -> {
                    outRect.right = space
                    outRect.left = space / 3
                }
                else -> {
                    outRect.left = space * 2 / 3
                    outRect.right = space * 2 / 3
                }
            }

            if (position < columnCount) {
                outRect.top = space
            }

            outRect.bottom = space

        } else {

            when {
                position % columnCount == 0 -> outRect.right = space * 2 / 3
                position % columnCount == columnCount - 1 -> outRect.left = space * 2 / 3
                else -> {
                    outRect.left = space / 3
                    outRect.right = space / 3
                }
            }

            if (position >= columnCount) {
                outRect.top = space
            }
        }
    }

}
Kuva
fonte
Gostaria de adicionar as seguintes linhas, se alguém como eu usando GridLayoutManager com spanCount = 1 columnCount == 1 -> { outRect.left = space outRect.right = space }
hugemadness
5

O @edwardaa copiou o código fornecido e eu o aperfeiçoo para suportar RTL:

public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {
    private int spanCount;
    private int spacing;
    private boolean includeEdge;
    private int headerNum;
    private boolean isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL;

    public GridSpacingItemDecoration(int spanCount, int spacing, boolean includeEdge, int headerNum) {
        this.spanCount = spanCount;
        this.spacing = spacing;
        this.includeEdge = includeEdge;
        this.headerNum = headerNum;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        int position = parent.getChildAdapterPosition(view) - headerNum; // item position
        if (position >= 0) {
            int column = position % spanCount; // item column
            if(isRtl) {
                column = spanCount - 1 - column;
            }
            if (includeEdge) {
                outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
                outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)

                if (position < spanCount) { // top edge
                    outRect.top = spacing;
                }
                outRect.bottom = spacing; // item bottom
            } else {
                outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
                outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
                if (position >= spanCount) {
                    outRect.top = spacing; // item top
                }
            }
        } else {
            outRect.left = 0;
            outRect.right = 0;
            outRect.top = 0;
            outRect.bottom = 0;
        }
    }
}
Xingxing
fonte
cada um poderia copiar o código de gist.github.com/xingstarx/f2525ef32b04a5e67fecc5c0b5c4b939
Xingxing
4

As respostas acima esclareceram maneiras de definir o tratamento de margens GridLayoutManager e LinearLayoutManager.

Mas para StaggeredGridLayoutManager, a resposta de Pirdad Sakhizada diz: "Pode não funcionar muito bem com StaggeredGridLayoutManager". Esse deve ser o problema sobre o IndexOfSpan.

Você pode obtê-lo desta maneira:

private static class MyItemDecoration extends RecyclerView.ItemDecoration {
    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        super.getItemOffsets(outRect, view, parent, state);
        int index = ((StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams()).getSpanIndex();
    }
}
wklbeta
fonte
4
public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {

    private int spanCount;
    private int spacing;
    private boolean includeEdge;

    public GridSpacingItemDecoration(int spanCount, int spacing, boolean includeEdge) {
        this.spanCount = spanCount;
        this.spacing = spacing;
        this.includeEdge = includeEdge;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        StaggeredGridLayoutManager.LayoutParams params = (StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams();
        int column = params.getSpanIndex();

        if (includeEdge) {
            outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
            outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)

            if (position < spanCount) { // top edge
                outRect.top = spacing;
            }
            outRect.bottom = spacing; // item bottom
        } else {
            outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
            outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
            if (position >= spanCount) {
                outRect.top = spacing; // item top
            }
        }
    }
}

Um pouco diferente da resposta de edwardaa, a diferença é como a coluna é determinada, porque em casos como itens com várias alturas, a coluna não pode ser determinada simplesmente% spanCount

Jonathan Lee
fonte
4
class VerticalGridSpacingDecoration(private val spacing: Int) : RecyclerView.ItemDecoration() {

  override fun getItemOffsets(
    outRect: Rect,
    view: View,
    parent: RecyclerView,
    state: State
  ) {
    val layoutManager = parent.layoutManager as? GridLayoutManager
    if (layoutManager == null || layoutManager.orientation != VERTICAL) {
      return super.getItemOffsets(outRect, view, parent, state)
    }

    val spanCount = layoutManager.spanCount
    val position = parent.getChildAdapterPosition(view)
    val column = position % spanCount
    with(outRect) {
      left = if (column == 0) 0 else spacing / 2
      right = if (column == spanCount.dec()) 0 else spacing / 2
      top = if (position < spanCount) 0 else spacing
    }
  }
}
fraggjkee
fonte
3

Aqui está minha modificação, SpacesItemDecorationque pode ocupar numOfColums e espaço igualmente na parte superior, inferior, esquerda e direita .

public class SpacesItemDecoration extends RecyclerView.ItemDecoration {
    private int space;
    private int mNumCol;

    public SpacesItemDecoration(int space, int numCol) {
        this.space = space;
        this.mNumCol=numCol;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view,
                               RecyclerView parent, RecyclerView.State state) {

        //outRect.right = space;
        outRect.bottom = space;
        //outRect.left = space;

        //Log.d("ttt", "item position" + parent.getChildLayoutPosition(view));
        int position=parent.getChildLayoutPosition(view);

        if(mNumCol<=2) {
            if (position == 0) {
                outRect.left = space;
                outRect.right = space / 2;
            } else {
                if ((position % mNumCol) != 0) {
                    outRect.left = space / 2;
                    outRect.right = space;
                } else {
                    outRect.left = space;
                    outRect.right = space / 2;
                }
            }
        }else{
            if (position == 0) {
                outRect.left = space;
                outRect.right = space / 2;
            } else {
                if ((position % mNumCol) == 0) {
                    outRect.left = space;
                    outRect.right = space/2;
                } else if((position % mNumCol) == (mNumCol-1)){
                    outRect.left = space/2;
                    outRect.right = space;
                }else{
                    outRect.left=space/2;
                    outRect.right=space/2;
                }
            }

        }

        if(position<mNumCol){
            outRect.top=space;
        }else{
            outRect.top=0;
        }
        // Add top margin only for the first item to avoid double space between items
        /*
        if (parent.getChildLayoutPosition(view) == 0 ) {

        } else {
            outRect.top = 0;
        }*/
    }
}

e use o código abaixo em sua lógica.

recyclerView.addItemDecoration(new SpacesItemDecoration(spacingInPixels, numCol));
andy anexinet
fonte
2

Existe uma solução muito simples e flexível para esse problema usando apenas XML que funciona em todos os LayoutManager.

Suponha que você queira um espaçamento igual de X (8dp por exemplo).

  1. Enrole o item do CardView em outro layout

  2. Dê ao Layout externo um preenchimento de X / 2 (4dp)

  3. Tornar transparente o plano de fundo do layout externo

...

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="200dp"
    android:layout_height="200dp"
    android:background="@android:color/transparent"
    android:padding="4dip">

    <android.support.v7.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    </android.support.v7.widget.CardView>

</LinearLayout>
  1. Dê ao seu RecyclerView um preenchimento de X / 2 (4dp)

...

<android.support.v7.widget.RecyclerView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="4dp" />

e é isso. Você tem um espaçamento perfeito de X (8dp).

kaveh gh
fonte
2

Para aqueles que têm problemas com o staggeredLayoutManager (como https://imgur.com/XVutH5u )

métodos do recyclerView:

getChildAdapterPosition(view)
getChildLayoutPosition(view)

às vezes, retorna -1 como índice, para que possamos enfrentar problemas ao definir itemDecor. Minha solução é substituir o método de ItemDecoration descontinuado:

public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent)

em vez do novato:

public void getItemOffsets(Rect outRect, View view, RecyclerView parent, State state)

como isso:

recyclerView.addItemDecoration(new RecyclerView.ItemDecoration() {
            @Override
            public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
                TheAdapter.VH vh = (TheAdapter.VH) recyclerView.findViewHolderForAdapterPosition(itemPosition);
                View itemView = vh.itemView;    //itemView is the base view of viewHolder
                //or instead of the 2 lines above maybe it's possible to use  View itemView = layoutManager.findViewByPosition(itemPosition)  ... NOT TESTED

                StaggeredGridLayoutManager.LayoutParams itemLayoutParams = (StaggeredGridLayoutManager.LayoutParams) itemView.getLayoutParams();

                int spanIndex = itemLayoutParams.getSpanIndex();

                if (spanIndex == 0)
                    ...
                else
                    ...
            }
        });

Parece funcionar para mim até agora :)

navid
fonte
Ótima resposta, cara! Funciona para todos os casos, incluindo GridLayoutManager "simétrico" não simétrico, no qual você tem um item de cabeçalho entre os itens. Obrigado!
Shirane85
2

As respostas para esta pergunta parecem mais complexas do que deveriam ser. Aqui está a minha opinião sobre isso.

Digamos que você queira um espaçamento de 1dp entre os itens da grade. Faça o seguinte:

  1. Adicione um preenchimento de 0,5dp a cada item
  2. Adicione um preenchimento de -0,5dp ao RecycleView
  3. É isso aí! :)
Sabaat Ahmad
fonte
1

Isso funcionará também RecyclerViewcom o cabeçalho.

public class GridSpacingItemDecoration extends RecyclerView.ItemDecoration {

    private int spanCount;
    private int spacing;
    private boolean includeEdge;
    private int headerNum;

    public GridSpacingItemDecoration(int spanCount, int spacing, boolean includeEdge, int headerNum) {
        this.spanCount = spanCount;
        this.spacing = spacing;
        this.includeEdge = includeEdge;
        this.headerNum = headerNum;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        int position = parent.getChildAdapterPosition(view) - headerNum; // item position

        if (position >= 0) {
            int column = position % spanCount; // item column

            if (includeEdge) {
                outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
                outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)

                if (position < spanCount) { // top edge
                    outRect.top = spacing;
                }
                outRect.bottom = spacing; // item bottom
            } else {
                outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
                outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
                if (position >= spanCount) {
                    outRect.top = spacing; // item top
                }
            }
        } else {
            outRect.left = 0;
            outRect.right = 0;
            outRect.top = 0;
            outRect.bottom = 0;
        }
    }
    }
}
DeepakPanwar
fonte
O que é headerNum?
Tim Kranen
1

A resposta de yqritc funcionou perfeitamente para mim. Eu estava usando o Kotlin no entanto, então aqui é o equivalente a isso.

class ItemOffsetDecoration : RecyclerView.ItemDecoration  {

    // amount to add to padding
    private val _itemOffset: Int

    constructor(itemOffset: Int) {
        _itemOffset = itemOffset
    }

    constructor(@NonNull context: Context, @DimenRes itemOffsetId: Int){
       _itemOffset = context.resources.getDimensionPixelSize(itemOffsetId)
    }

    /**
     * Applies padding to all sides of the [Rect], which is the container for the view
     */
    override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView,state: RecyclerView.State) {
        super.getItemOffsets(outRect, view, parent, state)
        outRect.set(_itemOffset, _itemOffset, _itemOffset, _itemOffset)
    }
}

tudo o resto é o mesmo.

stegnerd
fonte
1

Para usuários do StaggeredGridLayoutManager , tenha cuidado, muitas respostas aqui, incluindo a mais votada, calculam a coluna do item com o código abaixo:

int column = position % spanCount

que pressupõe que os itens 1/3/5 / .. estão sempre localizados no lado esquerdo e 2/4/6 / /. sempre estão localizados no lado direito. Essa suposição é sempre verdadeira? Não.

Digamos que o seu primeiro item tenha 100dp de altura e o segundo apenas 50dp, adivinhe onde está o seu terceiro item, à esquerda ou à direita?

ZhouX
fonte
0

Acabei fazendo isso assim no meu RecyclerView com GridLayoutManager e HeaderView .

No código abaixo, defino um espaço de 4dp entre cada item (2dp em torno de cada item e 2dp preenchimento em toda a reciclagem).

layout.xml

<android.support.v7.widget.RecyclerView
    android:id="@+id/recycleview"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="2dp" />

fragmento / atividade

GridLayoutManager manager = new GridLayoutManager(getContext(), 3);
recyclerView.setLayoutManager(manager);
int spacingInPixels = Utils.dpToPx(2);
recyclerView.addItemDecoration(new SpacesItemDecoration(spacingInPixels));

SpaceItemDecoration.java

public class SpacesItemDecoration extends RecyclerView.ItemDecoration {

    private int mSpacing;

    public SpacesItemDecoration(int spacing) {
        mSpacing = spacing;
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView recyclerView, RecyclerView.State state) {
        outRect.left = mSpacing;
        outRect.top = mSpacing;
        outRect.right = mSpacing;
        outRect.bottom = mSpacing;
    }
}

Utils.java

public static int dpToPx(final float dp) {
    return Math.round(dp * (Resources.getSystem().getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));
}
Simon Schubert
fonte
0

Para que a solução https://stackoverflow.com/a/29905000/1649371 (acima) funcionasse, eu tive que modificar os seguintes métodos (e todas as chamadas subseqüentes)

@SuppressWarnings("all")
protected int getItemSpanSize(RecyclerView parent, View view, int childIndex) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getSpanSizeLookup().getSpanSize(childIndex);
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return ((StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams()).isFullSpan() ? spanCount : 1;
    } else if (mgr instanceof LinearLayoutManager) {
        return 1;
    }

    return -1;
}

@SuppressWarnings("all")
protected int getItemSpanIndex(RecyclerView parent, View view, int childIndex) {

    RecyclerView.LayoutManager mgr = parent.getLayoutManager();
    if (mgr instanceof GridLayoutManager) {
        return ((GridLayoutManager) mgr).getSpanSizeLookup().getSpanIndex(childIndex, spanCount);
    } else if (mgr instanceof StaggeredGridLayoutManager) {
        return ((StaggeredGridLayoutManager.LayoutParams) view.getLayoutParams()).getSpanIndex();
    } else if (mgr instanceof LinearLayoutManager) {
        return 0;
    }

    return -1;
}
Damián Arrillaga
fonte
0

Este link funcionou para mim em todas as situações em que você pode tentar isso.

Vivek Barai
fonte
0

Se você tiver uma chave de alternância que alterna entre lista e grade, não se esqueça de ligar recyclerView.removeItemDecoration()antes de definir qualquer nova decoração de item. Caso contrário, os novos cálculos para o espaçamento seriam incorretos.


Algo assim.

        recyclerView.removeItemDecoration(gridItemDecorator)
        recyclerView.removeItemDecoration(listItemDecorator)
        if (showAsList){
            recyclerView.layoutManager = LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
            recyclerView.addItemDecoration(listItemDecorator)
        }
        else{
            recyclerView.layoutManager = GridLayoutManager(this, spanCount)
            recyclerView.addItemDecoration(gridItemDecorator)
        }
Sahil Patel
fonte
0

Se você estiver usando o Cabeçalho com GridLayoutManager, use este código escrito no kotlin para espaçar as grades:

inner class SpacesItemDecoration(itemSpace: Int) : RecyclerView.ItemDecoration() {
    var space: Int = itemSpace

    override fun getItemOffsets(outRect: Rect?, view: View?, parent: RecyclerView?, state: RecyclerView.State?) {
        super.getItemOffsets(outRect, view, parent, state)
        val position = parent!!.getChildAdapterPosition(view)
        val viewType = parent.adapter.getItemViewType(position)
       //check to not to set any margin to header item 
        if (viewType == GridViewAdapter.TYPE_HEADER) {
            outRect!!.top = 0
            outRect.left = 0
            outRect.right = 0
            outRect.bottom = 0
        } else {
            outRect!!.left = space
            outRect.right = space
            outRect.bottom = space

            if (parent.getChildLayoutPosition(view) == 0) {
                outRect.top = space
            } else {
                outRect.top = 0
            }
        }
    }
    }

E passar ItemDecorationpara recyclerviewcomo

mIssueGridView.addItemDecoration(SpacesItemDecoration(10))
Kapil Rajput
fonte
0

Ao usar o CardView for child, o problema com espaços entre os itens pode ser resolvido configurando app: cardUseCompatPadding como true.

Para margens maiores, aumente a elevação do item. CardElevation é opcional (use o valor padrão).

<androidx.cardview.widget.CardView
    xmlns:app="http://schemas.android.com/apk/res-auto"
    app:cardUseCompatPadding="true"
    app:cardElevation="2dp">
David Vareka
fonte
-1

obrigado resposta de edwardaa https://stackoverflow.com/a/30701422/2227031

Outro ponto a ser observado é que:

se o espaçamento total e o itemWidth total não forem iguais à largura da tela, você também precisará ajustar o itemWidth, por exemplo, no método onBindViewHolder do adaptador

Utils.init(_mActivity);
int width = 0;
if (includeEdge) {
    width = ScreenUtils.getScreenWidth() - spacing * (spanCount + 1);
} else {
    width = ScreenUtils.getScreenWidth() - spacing * (spanCount - 1);
}
int itemWidth = width / spanCount;

ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) holder.imageViewAvatar.getLayoutParams();
// suppose the width and height are the same
layoutParams.width = itemWidth;
layoutParams.height = itemWidth;
holder.imageViewAvatar.setLayoutParams(layoutParams);
jk2K
fonte
-1

Uma versão do Kotlin que fiz com base na grande resposta de edwardaa

class RecyclerItemDecoration(private val spanCount: Int, private val spacing: Int) : RecyclerView.ItemDecoration() {

  override fun getItemOffsets(outRect: Rect, view: View, parent: RecyclerView, state: RecyclerView.State) {

    val spacing = Math.round(spacing * parent.context.resources.displayMetrics.density)
    val position = parent.getChildAdapterPosition(view)
    val column = position % spanCount

    outRect.left = spacing - column * spacing / spanCount
    outRect.right = (column + 1) * spacing / spanCount

    outRect.top = if (position < spanCount) spacing else 0
    outRect.bottom = spacing
  }

}
Leon
fonte