2016-08-02 22:54:03 +00:00
|
|
|
package org.schabi.newpipe.info_list;
|
2016-08-01 22:58:52 +00:00
|
|
|
|
2019-08-14 09:42:39 +00:00
|
|
|
import android.content.Context;
|
2020-03-31 17:20:15 +00:00
|
|
|
import android.util.Log;
|
2022-01-16 16:08:13 +00:00
|
|
|
import android.view.LayoutInflater;
|
2020-03-31 17:20:15 +00:00
|
|
|
import android.view.View;
|
|
|
|
import android.view.ViewGroup;
|
|
|
|
|
2019-10-04 12:59:08 +00:00
|
|
|
import androidx.annotation.NonNull;
|
|
|
|
import androidx.annotation.Nullable;
|
|
|
|
import androidx.recyclerview.widget.GridLayoutManager;
|
|
|
|
import androidx.recyclerview.widget.RecyclerView;
|
2016-08-01 22:58:52 +00:00
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
import org.schabi.newpipe.databinding.PignateFooterBinding;
|
2017-02-12 12:33:03 +00:00
|
|
|
import org.schabi.newpipe.extractor.InfoItem;
|
2017-08-07 13:02:30 +00:00
|
|
|
import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
|
2018-09-02 23:22:59 +00:00
|
|
|
import org.schabi.newpipe.extractor.comments.CommentsInfoItem;
|
2017-09-03 06:04:18 +00:00
|
|
|
import org.schabi.newpipe.extractor.playlist.PlaylistInfoItem;
|
|
|
|
import org.schabi.newpipe.extractor.stream.StreamInfoItem;
|
2023-01-29 12:14:46 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.ChannelCardInfoItemHolder;
|
2019-04-15 18:19:59 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.ChannelGridInfoItemHolder;
|
2017-09-03 06:04:18 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.ChannelInfoItemHolder;
|
|
|
|
import org.schabi.newpipe.info_list.holder.ChannelMiniInfoItemHolder;
|
2023-04-11 08:47:40 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.CommentInfoItemHolder;
|
2017-09-03 06:04:18 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.InfoItemHolder;
|
2022-11-02 18:56:10 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.PlaylistCardInfoItemHolder;
|
2018-08-22 07:14:01 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.PlaylistGridInfoItemHolder;
|
2017-09-03 06:04:18 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.PlaylistInfoItemHolder;
|
2018-01-16 19:48:52 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.PlaylistMiniInfoItemHolder;
|
2022-11-02 18:56:10 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.StreamCardInfoItemHolder;
|
2018-08-22 07:14:01 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.StreamGridInfoItemHolder;
|
2017-09-03 06:04:18 +00:00
|
|
|
import org.schabi.newpipe.info_list.holder.StreamInfoItemHolder;
|
|
|
|
import org.schabi.newpipe.info_list.holder.StreamMiniInfoItemHolder;
|
2019-08-14 09:42:39 +00:00
|
|
|
import org.schabi.newpipe.local.history.HistoryRecordManager;
|
2018-05-06 08:14:24 +00:00
|
|
|
import org.schabi.newpipe.util.FallbackViewHolder;
|
2018-01-31 00:21:50 +00:00
|
|
|
import org.schabi.newpipe.util.OnClickGesture;
|
2016-08-01 22:58:52 +00:00
|
|
|
|
2017-04-26 19:32:04 +00:00
|
|
|
import java.util.ArrayList;
|
2016-08-01 22:58:52 +00:00
|
|
|
import java.util.List;
|
2022-01-16 16:08:13 +00:00
|
|
|
import java.util.function.Supplier;
|
2019-04-15 18:19:59 +00:00
|
|
|
|
2017-09-03 06:04:18 +00:00
|
|
|
/*
|
2016-09-11 22:33:11 +00:00
|
|
|
* Created by Christian Schabesberger on 01.08.16.
|
|
|
|
*
|
|
|
|
* Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
|
|
|
|
* InfoListAdapter.java is part of NewPipe.
|
|
|
|
*
|
|
|
|
* NewPipe is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* NewPipe is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with NewPipe. If not, see <http://www.gnu.org/licenses/>.
|
2016-08-01 22:58:52 +00:00
|
|
|
*/
|
2016-09-11 22:33:11 +00:00
|
|
|
|
2019-08-14 09:42:39 +00:00
|
|
|
public class InfoListAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
|
2017-09-03 06:04:18 +00:00
|
|
|
private static final String TAG = InfoListAdapter.class.getSimpleName();
|
|
|
|
private static final boolean DEBUG = false;
|
|
|
|
|
|
|
|
private static final int HEADER_TYPE = 0;
|
|
|
|
private static final int FOOTER_TYPE = 1;
|
|
|
|
|
|
|
|
private static final int MINI_STREAM_HOLDER_TYPE = 0x100;
|
|
|
|
private static final int STREAM_HOLDER_TYPE = 0x101;
|
2018-08-22 07:14:01 +00:00
|
|
|
private static final int GRID_STREAM_HOLDER_TYPE = 0x102;
|
2022-11-02 18:56:10 +00:00
|
|
|
private static final int CARD_STREAM_HOLDER_TYPE = 0x103;
|
2017-09-03 06:04:18 +00:00
|
|
|
private static final int MINI_CHANNEL_HOLDER_TYPE = 0x200;
|
|
|
|
private static final int CHANNEL_HOLDER_TYPE = 0x201;
|
2018-08-22 07:14:01 +00:00
|
|
|
private static final int GRID_CHANNEL_HOLDER_TYPE = 0x202;
|
2023-01-29 12:14:46 +00:00
|
|
|
private static final int CARD_CHANNEL_HOLDER_TYPE = 0x203;
|
2018-01-16 19:48:52 +00:00
|
|
|
private static final int MINI_PLAYLIST_HOLDER_TYPE = 0x300;
|
2017-09-03 06:04:18 +00:00
|
|
|
private static final int PLAYLIST_HOLDER_TYPE = 0x301;
|
2018-08-22 07:14:01 +00:00
|
|
|
private static final int GRID_PLAYLIST_HOLDER_TYPE = 0x302;
|
2022-11-02 18:56:10 +00:00
|
|
|
private static final int CARD_PLAYLIST_HOLDER_TYPE = 0x303;
|
2023-04-11 08:47:40 +00:00
|
|
|
private static final int COMMENT_HOLDER_TYPE = 0x400;
|
2016-08-01 22:58:52 +00:00
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
private final LayoutInflater layoutInflater;
|
2017-01-11 10:06:24 +00:00
|
|
|
private final InfoItemBuilder infoItemBuilder;
|
2022-01-24 19:57:23 +00:00
|
|
|
private final List<InfoItem> infoItemList;
|
2019-08-14 09:42:39 +00:00
|
|
|
private final HistoryRecordManager recordManager;
|
2019-08-14 11:11:16 +00:00
|
|
|
|
2017-09-03 06:04:18 +00:00
|
|
|
private boolean useMiniVariant = false;
|
2017-02-28 11:13:29 +00:00
|
|
|
private boolean showFooter = false;
|
2022-01-16 16:08:13 +00:00
|
|
|
|
2022-11-02 18:56:10 +00:00
|
|
|
private ItemViewMode itemMode = ItemViewMode.LIST;
|
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
private Supplier<View> headerSupplier = null;
|
2017-02-27 14:58:09 +00:00
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public InfoListAdapter(final Context context) {
|
2022-01-16 16:08:13 +00:00
|
|
|
layoutInflater = LayoutInflater.from(context);
|
|
|
|
recordManager = new HistoryRecordManager(context);
|
2019-08-14 09:42:39 +00:00
|
|
|
infoItemBuilder = new InfoItemBuilder(context);
|
2017-06-18 13:43:11 +00:00
|
|
|
infoItemList = new ArrayList<>();
|
2016-08-01 22:58:52 +00:00
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void setOnStreamSelectedListener(final OnClickGesture<StreamInfoItem> listener) {
|
2017-09-03 06:04:18 +00:00
|
|
|
infoItemBuilder.setOnStreamSelectedListener(listener);
|
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void setOnChannelSelectedListener(final OnClickGesture<ChannelInfoItem> listener) {
|
2017-09-03 06:04:18 +00:00
|
|
|
infoItemBuilder.setOnChannelSelectedListener(listener);
|
2017-02-15 11:59:36 +00:00
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void setOnPlaylistSelectedListener(final OnClickGesture<PlaylistInfoItem> listener) {
|
2017-09-03 06:04:18 +00:00
|
|
|
infoItemBuilder.setOnPlaylistSelectedListener(listener);
|
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void setOnCommentsSelectedListener(final OnClickGesture<CommentsInfoItem> listener) {
|
2018-09-02 23:22:59 +00:00
|
|
|
infoItemBuilder.setOnCommentsSelectedListener(listener);
|
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void setUseMiniVariant(final boolean useMiniVariant) {
|
2017-09-03 06:04:18 +00:00
|
|
|
this.useMiniVariant = useMiniVariant;
|
2016-08-02 18:59:53 +00:00
|
|
|
}
|
|
|
|
|
2022-11-02 18:56:10 +00:00
|
|
|
public void setItemViewMode(final ItemViewMode itemViewMode) {
|
|
|
|
this.itemMode = itemViewMode;
|
2018-08-22 07:14:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-28 20:43:54 +00:00
|
|
|
public void addInfoItemList(@Nullable final List<? extends InfoItem> data) {
|
2019-08-14 11:11:16 +00:00
|
|
|
if (data == null) {
|
|
|
|
return;
|
2019-04-27 18:23:52 +00:00
|
|
|
}
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "addInfoItemList() before > infoItemList.size() = "
|
|
|
|
+ infoItemList.size() + ", data.size() = " + data.size());
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
|
2020-08-16 08:24:58 +00:00
|
|
|
final int offsetStart = sizeConsideringHeaderOffset();
|
2019-04-27 18:23:52 +00:00
|
|
|
infoItemList.addAll(data);
|
2017-09-03 06:04:18 +00:00
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "addInfoItemList() after > offsetStart = " + offsetStart + ", "
|
|
|
|
+ "infoItemList.size() = " + infoItemList.size() + ", "
|
2022-01-24 19:57:23 +00:00
|
|
|
+ "hasHeader = " + hasHeader() + ", "
|
2020-03-31 17:20:15 +00:00
|
|
|
+ "showFooter = " + showFooter);
|
|
|
|
}
|
2019-04-27 18:23:52 +00:00
|
|
|
notifyItemRangeInserted(offsetStart, data.size());
|
2017-09-03 06:04:18 +00:00
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
if (showFooter) {
|
2020-08-16 08:24:58 +00:00
|
|
|
final int footerNow = sizeConsideringHeaderOffset();
|
2019-04-27 18:23:52 +00:00
|
|
|
notifyItemMoved(offsetStart, footerNow);
|
2017-09-03 06:04:18 +00:00
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "addInfoItemList() footer from " + offsetStart
|
|
|
|
+ " to " + footerNow);
|
|
|
|
}
|
2016-09-10 14:26:21 +00:00
|
|
|
}
|
2016-08-02 16:38:05 +00:00
|
|
|
}
|
|
|
|
|
2017-04-26 19:32:04 +00:00
|
|
|
public void clearStreamItemList() {
|
2017-09-03 06:04:18 +00:00
|
|
|
if (infoItemList.isEmpty()) {
|
2017-06-15 14:26:48 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-02-12 23:55:05 +00:00
|
|
|
infoItemList.clear();
|
2016-08-02 16:38:05 +00:00
|
|
|
notifyDataSetChanged();
|
|
|
|
}
|
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
public void setHeaderSupplier(@Nullable final Supplier<View> headerSupplier) {
|
|
|
|
final boolean changed = headerSupplier != this.headerSupplier;
|
|
|
|
this.headerSupplier = headerSupplier;
|
2020-03-31 17:20:15 +00:00
|
|
|
if (changed) {
|
|
|
|
notifyDataSetChanged();
|
|
|
|
}
|
2017-02-28 11:13:29 +00:00
|
|
|
}
|
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
protected boolean hasHeader() {
|
|
|
|
return this.headerSupplier != null;
|
2017-09-03 06:04:18 +00:00
|
|
|
}
|
|
|
|
|
2020-03-31 17:20:15 +00:00
|
|
|
public void showFooter(final boolean show) {
|
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "showFooter() called with: show = [" + show + "]");
|
|
|
|
}
|
|
|
|
if (show == showFooter) {
|
|
|
|
return;
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
|
|
|
|
showFooter = show;
|
2020-03-31 17:20:15 +00:00
|
|
|
if (show) {
|
|
|
|
notifyItemInserted(sizeConsideringHeaderOffset());
|
|
|
|
} else {
|
|
|
|
notifyItemRemoved(sizeConsideringHeaderOffset());
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private int sizeConsideringHeaderOffset() {
|
2022-01-16 16:08:13 +00:00
|
|
|
final int i = infoItemList.size() + (hasHeader() ? 1 : 0);
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "sizeConsideringHeaderOffset() called → " + i);
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
return i;
|
2017-02-27 14:58:09 +00:00
|
|
|
}
|
|
|
|
|
2022-01-15 16:28:03 +00:00
|
|
|
public List<InfoItem> getItemsList() {
|
2017-04-26 19:32:04 +00:00
|
|
|
return infoItemList;
|
|
|
|
}
|
|
|
|
|
2016-08-01 22:58:52 +00:00
|
|
|
@Override
|
|
|
|
public int getItemCount() {
|
2017-04-26 19:32:04 +00:00
|
|
|
int count = infoItemList.size();
|
2022-01-16 16:08:13 +00:00
|
|
|
if (hasHeader()) {
|
2020-03-31 17:20:15 +00:00
|
|
|
count++;
|
|
|
|
}
|
2022-01-16 16:08:13 +00:00
|
|
|
if (showFooter) {
|
2020-03-31 17:20:15 +00:00
|
|
|
count++;
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
|
|
|
|
if (DEBUG) {
|
2020-03-31 17:20:15 +00:00
|
|
|
Log.d(TAG, "getItemCount() called with: "
|
|
|
|
+ "count = " + count + ", infoItemList.size() = " + infoItemList.size() + ", "
|
2022-01-24 19:57:23 +00:00
|
|
|
+ "hasHeader = " + hasHeader() + ", "
|
2020-03-31 17:20:15 +00:00
|
|
|
+ "showFooter = " + showFooter);
|
2017-09-03 06:04:18 +00:00
|
|
|
}
|
2017-04-26 19:32:04 +00:00
|
|
|
return count;
|
2016-08-01 22:58:52 +00:00
|
|
|
}
|
|
|
|
|
2022-01-15 16:40:08 +00:00
|
|
|
@SuppressWarnings("FinalParameters")
|
2016-08-01 22:58:52 +00:00
|
|
|
@Override
|
2017-02-15 14:21:36 +00:00
|
|
|
public int getItemViewType(int position) {
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "getItemViewType() called with: position = [" + position + "]");
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
if (hasHeader() && position == 0) {
|
2017-09-03 06:04:18 +00:00
|
|
|
return HEADER_TYPE;
|
2022-01-16 16:08:13 +00:00
|
|
|
} else if (hasHeader()) {
|
2017-02-27 14:58:09 +00:00
|
|
|
position--;
|
|
|
|
}
|
2022-01-16 16:08:13 +00:00
|
|
|
if (position == infoItemList.size() && showFooter) {
|
2017-09-03 06:04:18 +00:00
|
|
|
return FOOTER_TYPE;
|
2017-02-28 11:13:29 +00:00
|
|
|
}
|
2018-01-26 06:24:59 +00:00
|
|
|
final InfoItem item = infoItemList.get(position);
|
2018-03-18 15:37:49 +00:00
|
|
|
switch (item.getInfoType()) {
|
2017-02-12 23:55:05 +00:00
|
|
|
case STREAM:
|
2022-11-02 18:56:10 +00:00
|
|
|
if (itemMode == ItemViewMode.CARD) {
|
|
|
|
return CARD_STREAM_HOLDER_TYPE;
|
|
|
|
} else if (itemMode == ItemViewMode.GRID) {
|
|
|
|
return GRID_STREAM_HOLDER_TYPE;
|
|
|
|
} else if (useMiniVariant) {
|
|
|
|
return MINI_STREAM_HOLDER_TYPE;
|
|
|
|
} else {
|
|
|
|
return STREAM_HOLDER_TYPE;
|
|
|
|
}
|
2017-02-28 11:13:29 +00:00
|
|
|
case CHANNEL:
|
2023-01-29 12:14:46 +00:00
|
|
|
if (itemMode == ItemViewMode.CARD) {
|
|
|
|
return CARD_CHANNEL_HOLDER_TYPE;
|
|
|
|
} else if (itemMode == ItemViewMode.GRID) {
|
2022-11-02 18:56:10 +00:00
|
|
|
return GRID_CHANNEL_HOLDER_TYPE;
|
|
|
|
} else if (useMiniVariant) {
|
|
|
|
return MINI_CHANNEL_HOLDER_TYPE;
|
|
|
|
} else {
|
|
|
|
return CHANNEL_HOLDER_TYPE;
|
|
|
|
}
|
2017-02-28 11:13:29 +00:00
|
|
|
case PLAYLIST:
|
2022-11-02 18:56:10 +00:00
|
|
|
if (itemMode == ItemViewMode.CARD) {
|
|
|
|
return CARD_PLAYLIST_HOLDER_TYPE;
|
|
|
|
} else if (itemMode == ItemViewMode.GRID) {
|
|
|
|
return GRID_PLAYLIST_HOLDER_TYPE;
|
|
|
|
} else if (useMiniVariant) {
|
|
|
|
return MINI_PLAYLIST_HOLDER_TYPE;
|
|
|
|
} else {
|
|
|
|
return PLAYLIST_HOLDER_TYPE;
|
|
|
|
}
|
2018-09-23 01:32:19 +00:00
|
|
|
case COMMENT:
|
2023-04-11 08:47:40 +00:00
|
|
|
return COMMENT_HOLDER_TYPE;
|
2017-02-15 14:21:36 +00:00
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-27 18:23:52 +00:00
|
|
|
@NonNull
|
2017-02-15 14:21:36 +00:00
|
|
|
@Override
|
2020-03-31 17:20:15 +00:00
|
|
|
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull final ViewGroup parent,
|
|
|
|
final int type) {
|
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "onCreateViewHolder() called with: "
|
|
|
|
+ "parent = [" + parent + "], type = [" + type + "]");
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
switch (type) {
|
2022-01-16 16:08:13 +00:00
|
|
|
// #4475 and #3368
|
|
|
|
// Always create a new instance otherwise the same instance
|
|
|
|
// is sometimes reused which causes a crash
|
2017-09-03 06:04:18 +00:00
|
|
|
case HEADER_TYPE:
|
2022-01-16 16:08:13 +00:00
|
|
|
return new HFHolder(headerSupplier.get());
|
2017-09-03 06:04:18 +00:00
|
|
|
case FOOTER_TYPE:
|
2022-01-16 16:08:13 +00:00
|
|
|
return new HFHolder(PignateFooterBinding
|
|
|
|
.inflate(layoutInflater, parent, false)
|
|
|
|
.getRoot()
|
|
|
|
);
|
2017-09-03 06:04:18 +00:00
|
|
|
case MINI_STREAM_HOLDER_TYPE:
|
|
|
|
return new StreamMiniInfoItemHolder(infoItemBuilder, parent);
|
|
|
|
case STREAM_HOLDER_TYPE:
|
|
|
|
return new StreamInfoItemHolder(infoItemBuilder, parent);
|
2018-08-22 07:14:01 +00:00
|
|
|
case GRID_STREAM_HOLDER_TYPE:
|
|
|
|
return new StreamGridInfoItemHolder(infoItemBuilder, parent);
|
2022-11-02 18:56:10 +00:00
|
|
|
case CARD_STREAM_HOLDER_TYPE:
|
|
|
|
return new StreamCardInfoItemHolder(infoItemBuilder, parent);
|
2017-09-03 06:04:18 +00:00
|
|
|
case MINI_CHANNEL_HOLDER_TYPE:
|
|
|
|
return new ChannelMiniInfoItemHolder(infoItemBuilder, parent);
|
|
|
|
case CHANNEL_HOLDER_TYPE:
|
|
|
|
return new ChannelInfoItemHolder(infoItemBuilder, parent);
|
2023-01-29 12:14:46 +00:00
|
|
|
case CARD_CHANNEL_HOLDER_TYPE:
|
|
|
|
return new ChannelCardInfoItemHolder(infoItemBuilder, parent);
|
2018-08-22 07:14:01 +00:00
|
|
|
case GRID_CHANNEL_HOLDER_TYPE:
|
|
|
|
return new ChannelGridInfoItemHolder(infoItemBuilder, parent);
|
2018-01-16 19:48:52 +00:00
|
|
|
case MINI_PLAYLIST_HOLDER_TYPE:
|
|
|
|
return new PlaylistMiniInfoItemHolder(infoItemBuilder, parent);
|
2017-09-03 06:04:18 +00:00
|
|
|
case PLAYLIST_HOLDER_TYPE:
|
|
|
|
return new PlaylistInfoItemHolder(infoItemBuilder, parent);
|
2018-08-22 07:14:01 +00:00
|
|
|
case GRID_PLAYLIST_HOLDER_TYPE:
|
|
|
|
return new PlaylistGridInfoItemHolder(infoItemBuilder, parent);
|
2022-11-02 18:56:10 +00:00
|
|
|
case CARD_PLAYLIST_HOLDER_TYPE:
|
|
|
|
return new PlaylistCardInfoItemHolder(infoItemBuilder, parent);
|
2018-09-23 01:32:19 +00:00
|
|
|
case COMMENT_HOLDER_TYPE:
|
2023-04-11 08:47:40 +00:00
|
|
|
return new CommentInfoItemHolder(infoItemBuilder, parent);
|
2017-02-12 23:55:05 +00:00
|
|
|
default:
|
2018-05-06 08:14:24 +00:00
|
|
|
return new FallbackViewHolder(new View(parent.getContext()));
|
2017-02-12 23:55:05 +00:00
|
|
|
}
|
2016-08-01 22:58:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-01-24 19:57:23 +00:00
|
|
|
public void onBindViewHolder(@NonNull final RecyclerView.ViewHolder holder,
|
|
|
|
final int position) {
|
2020-03-31 17:20:15 +00:00
|
|
|
if (DEBUG) {
|
|
|
|
Log.d(TAG, "onBindViewHolder() called with: "
|
|
|
|
+ "holder = [" + holder.getClass().getSimpleName() + "], "
|
|
|
|
+ "position = [" + position + "]");
|
|
|
|
}
|
2017-09-03 06:04:18 +00:00
|
|
|
if (holder instanceof InfoItemHolder) {
|
2022-01-24 19:57:23 +00:00
|
|
|
((InfoItemHolder) holder).updateFromItem(
|
|
|
|
// If header is present, offset the items by -1
|
|
|
|
infoItemList.get(hasHeader() ? position - 1 : position), recordManager);
|
2017-02-27 14:58:09 +00:00
|
|
|
}
|
2016-08-01 22:58:52 +00:00
|
|
|
}
|
2018-08-22 07:14:01 +00:00
|
|
|
|
|
|
|
public GridLayoutManager.SpanSizeLookup getSpanSizeLookup(final int spanCount) {
|
|
|
|
return new GridLayoutManager.SpanSizeLookup() {
|
|
|
|
@Override
|
2020-03-31 17:20:15 +00:00
|
|
|
public int getSpanSize(final int position) {
|
2018-08-22 07:14:01 +00:00
|
|
|
final int type = getItemViewType(position);
|
|
|
|
return type == HEADER_TYPE || type == FOOTER_TYPE ? spanCount : 1;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2020-03-31 17:20:15 +00:00
|
|
|
|
2022-01-16 16:08:13 +00:00
|
|
|
static class HFHolder extends RecyclerView.ViewHolder {
|
2020-03-31 17:20:15 +00:00
|
|
|
HFHolder(final View v) {
|
|
|
|
super(v);
|
|
|
|
}
|
|
|
|
}
|
2016-08-01 22:58:52 +00:00
|
|
|
}
|