mirror of https://github.com/NekoX-Dev/NekoX.git
680 lines
31 KiB
Java
680 lines
31 KiB
Java
package org.telegram.ui.Adapters;
|
|
|
|
import android.content.Context;
|
|
import android.graphics.Color;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.PorterDuffColorFilter;
|
|
import android.text.TextUtils;
|
|
import android.util.LongSparseArray;
|
|
import android.util.SparseArray;
|
|
import android.util.SparseIntArray;
|
|
import android.util.TypedValue;
|
|
import android.view.Gravity;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.ImageView;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.Space;
|
|
import android.widget.TextView;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
|
|
import org.telegram.messenger.AndroidUtilities;
|
|
import org.telegram.messenger.Emoji;
|
|
import org.telegram.messenger.LocaleController;
|
|
import org.telegram.messenger.MediaDataController;
|
|
import org.telegram.messenger.R;
|
|
import org.telegram.messenger.UserConfig;
|
|
import org.telegram.tgnet.ConnectionsManager;
|
|
import org.telegram.tgnet.TLRPC;
|
|
import org.telegram.ui.ActionBar.Theme;
|
|
import org.telegram.ui.ActionBar.ThemeDescription;
|
|
import org.telegram.ui.Cells.EmptyCell;
|
|
import org.telegram.ui.Cells.FeaturedStickerSetInfoCell;
|
|
import org.telegram.ui.Cells.StickerEmojiCell;
|
|
import org.telegram.ui.Cells.StickerSetNameCell;
|
|
import org.telegram.ui.Components.LayoutHelper;
|
|
import org.telegram.ui.Components.RecyclerListView;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
|
|
public class StickersSearchAdapter extends RecyclerListView.SelectionAdapter {
|
|
|
|
public static final int PAYLOAD_ANIMATED = 0;
|
|
|
|
public interface Delegate {
|
|
|
|
void onSearchStart();
|
|
|
|
void onSearchStop();
|
|
|
|
void setAdapterVisible(boolean visible);
|
|
|
|
void onStickerSetAdd(TLRPC.StickerSetCovered stickerSet, boolean primary);
|
|
|
|
void onStickerSetRemove(TLRPC.StickerSetCovered stickerSet);
|
|
|
|
int getStickersPerRow();
|
|
|
|
String[] getLastSearchKeyboardLanguage();
|
|
|
|
void setLastSearchKeyboardLanguage(String[] language);
|
|
}
|
|
|
|
private final int currentAccount = UserConfig.selectedAccount;
|
|
|
|
private final Context context;
|
|
private final Delegate delegate;
|
|
private final TLRPC.StickerSetCovered[] primaryInstallingStickerSets;
|
|
private final LongSparseArray<TLRPC.StickerSetCovered> installingStickerSets;
|
|
private final LongSparseArray<TLRPC.StickerSetCovered> removingStickerSets;
|
|
|
|
private SparseArray<Object> rowStartPack = new SparseArray<>();
|
|
private SparseArray<Object> cache = new SparseArray<>();
|
|
private SparseArray<Object> cacheParent = new SparseArray<>();
|
|
private SparseIntArray positionToRow = new SparseIntArray();
|
|
private SparseArray<String> positionToEmoji = new SparseArray<>();
|
|
private int totalItems;
|
|
|
|
private ArrayList<TLRPC.StickerSetCovered> serverPacks = new ArrayList<>();
|
|
private ArrayList<TLRPC.TL_messages_stickerSet> localPacks = new ArrayList<>();
|
|
private HashMap<TLRPC.TL_messages_stickerSet, Boolean> localPacksByShortName = new HashMap<>();
|
|
private HashMap<TLRPC.TL_messages_stickerSet, Integer> localPacksByName = new HashMap<>();
|
|
private HashMap<ArrayList<TLRPC.Document>, String> emojiStickers = new HashMap<>();
|
|
private ArrayList<ArrayList<TLRPC.Document>> emojiArrays = new ArrayList<>();
|
|
private SparseArray<TLRPC.StickerSetCovered> positionsToSets = new SparseArray<>();
|
|
|
|
private ImageView emptyImageView;
|
|
private TextView emptyTextView;
|
|
|
|
private int reqId;
|
|
private int reqId2;
|
|
|
|
private int emojiSearchId;
|
|
boolean cleared;
|
|
private String searchQuery;
|
|
private Runnable searchRunnable = new Runnable() {
|
|
|
|
private void clear() {
|
|
if (cleared) {
|
|
return;
|
|
}
|
|
cleared = true;
|
|
emojiStickers.clear();
|
|
emojiArrays.clear();
|
|
localPacks.clear();
|
|
serverPacks.clear();
|
|
localPacksByShortName.clear();
|
|
localPacksByName.clear();
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
if (TextUtils.isEmpty(searchQuery)) {
|
|
return;
|
|
}
|
|
delegate.onSearchStart();
|
|
cleared = false;
|
|
int lastId = ++emojiSearchId;
|
|
|
|
final ArrayList<TLRPC.Document> emojiStickersArray = new ArrayList<>(0);
|
|
final LongSparseArray<TLRPC.Document> emojiStickersMap = new LongSparseArray<>(0);
|
|
HashMap<String, ArrayList<TLRPC.Document>> allStickers = MediaDataController.getInstance(currentAccount).getAllStickers();
|
|
if (searchQuery.length() <= 14) {
|
|
CharSequence emoji = searchQuery;
|
|
int length = emoji.length();
|
|
for (int a = 0; a < length; a++) {
|
|
if (a < length - 1 && (emoji.charAt(a) == 0xD83C && emoji.charAt(a + 1) >= 0xDFFB && emoji.charAt(a + 1) <= 0xDFFF || emoji.charAt(a) == 0x200D && (emoji.charAt(a + 1) == 0x2640 || emoji.charAt(a + 1) == 0x2642))) {
|
|
emoji = TextUtils.concat(emoji.subSequence(0, a), emoji.subSequence(a + 2, emoji.length()));
|
|
length -= 2;
|
|
a--;
|
|
} else if (emoji.charAt(a) == 0xfe0f) {
|
|
emoji = TextUtils.concat(emoji.subSequence(0, a), emoji.subSequence(a + 1, emoji.length()));
|
|
length--;
|
|
a--;
|
|
}
|
|
}
|
|
ArrayList<TLRPC.Document> newStickers = allStickers != null ? allStickers.get(emoji.toString()) : null;
|
|
if (newStickers != null && !newStickers.isEmpty()) {
|
|
clear();
|
|
emojiStickersArray.addAll(newStickers);
|
|
for (int a = 0, size = newStickers.size(); a < size; a++) {
|
|
TLRPC.Document document = newStickers.get(a);
|
|
emojiStickersMap.put(document.id, document);
|
|
}
|
|
emojiStickers.put(emojiStickersArray, searchQuery);
|
|
emojiArrays.add(emojiStickersArray);
|
|
}
|
|
}
|
|
if (allStickers != null && !allStickers.isEmpty() && searchQuery.length() > 1) {
|
|
String[] newLanguage = AndroidUtilities.getCurrentKeyboardLanguage();
|
|
if (!Arrays.equals(delegate.getLastSearchKeyboardLanguage(), newLanguage)) {
|
|
MediaDataController.getInstance(currentAccount).fetchNewEmojiKeywords(newLanguage);
|
|
}
|
|
delegate.setLastSearchKeyboardLanguage(newLanguage);
|
|
MediaDataController.getInstance(currentAccount).getEmojiSuggestions(delegate.getLastSearchKeyboardLanguage(), searchQuery, false, new MediaDataController.KeywordResultCallback() {
|
|
@Override
|
|
public void run(ArrayList<MediaDataController.KeywordResult> param, String alias) {
|
|
if (lastId != emojiSearchId) {
|
|
return;
|
|
}
|
|
boolean added = false;
|
|
for (int a = 0, size = param.size(); a < size; a++) {
|
|
String emoji = param.get(a).emoji;
|
|
ArrayList<TLRPC.Document> newStickers = allStickers != null ? allStickers.get(emoji) : null;
|
|
if (newStickers != null && !newStickers.isEmpty()) {
|
|
clear();
|
|
if (!emojiStickers.containsKey(newStickers)) {
|
|
emojiStickers.put(newStickers, emoji);
|
|
emojiArrays.add(newStickers);
|
|
added = true;
|
|
}
|
|
}
|
|
}
|
|
if (added) {
|
|
notifyDataSetChanged();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
ArrayList<TLRPC.TL_messages_stickerSet> local = MediaDataController.getInstance(currentAccount).getStickerSets(MediaDataController.TYPE_IMAGE);
|
|
int index;
|
|
for (int a = 0, size = local.size(); a < size; a++) {
|
|
TLRPC.TL_messages_stickerSet set = local.get(a);
|
|
if ((index = AndroidUtilities.indexOfIgnoreCase(set.set.title, searchQuery)) >= 0) {
|
|
if (index == 0 || set.set.title.charAt(index - 1) == ' ') {
|
|
clear();
|
|
localPacks.add(set);
|
|
localPacksByName.put(set, index);
|
|
}
|
|
} else if (set.set.short_name != null && (index = AndroidUtilities.indexOfIgnoreCase(set.set.short_name, searchQuery)) >= 0) {
|
|
if (index == 0 || set.set.short_name.charAt(index - 1) == ' ') {
|
|
clear();
|
|
localPacks.add(set);
|
|
localPacksByShortName.put(set, true);
|
|
}
|
|
}
|
|
}
|
|
local = MediaDataController.getInstance(currentAccount).getStickerSets(MediaDataController.TYPE_FEATURED);
|
|
for (int a = 0, size = local.size(); a < size; a++) {
|
|
TLRPC.TL_messages_stickerSet set = local.get(a);
|
|
if ((index = AndroidUtilities.indexOfIgnoreCase(set.set.title, searchQuery)) >= 0) {
|
|
if (index == 0 || set.set.title.charAt(index - 1) == ' ') {
|
|
clear();
|
|
localPacks.add(set);
|
|
localPacksByName.put(set, index);
|
|
}
|
|
} else if (set.set.short_name != null && (index = AndroidUtilities.indexOfIgnoreCase(set.set.short_name, searchQuery)) >= 0) {
|
|
if (index == 0 || set.set.short_name.charAt(index - 1) == ' ') {
|
|
clear();
|
|
localPacks.add(set);
|
|
localPacksByShortName.put(set, true);
|
|
}
|
|
}
|
|
}
|
|
if ((!localPacks.isEmpty() || !emojiStickers.isEmpty())) {
|
|
delegate.setAdapterVisible(true);
|
|
}
|
|
final TLRPC.TL_messages_searchStickerSets req = new TLRPC.TL_messages_searchStickerSets();
|
|
req.q = searchQuery;
|
|
reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> {
|
|
if (response instanceof TLRPC.TL_messages_foundStickerSets) {
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (req.q.equals(searchQuery)) {
|
|
clear();
|
|
delegate.onSearchStop();
|
|
reqId = 0;
|
|
delegate.setAdapterVisible(true);
|
|
TLRPC.TL_messages_foundStickerSets res = (TLRPC.TL_messages_foundStickerSets) response;
|
|
serverPacks.addAll(res.sets);
|
|
notifyDataSetChanged();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
if (Emoji.isValidEmoji(searchQuery)) {
|
|
final TLRPC.TL_messages_getStickers req2 = new TLRPC.TL_messages_getStickers();
|
|
req2.emoticon = searchQuery;
|
|
req2.hash = 0;
|
|
reqId2 = ConnectionsManager.getInstance(currentAccount).sendRequest(req2, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (req2.emoticon.equals(searchQuery)) {
|
|
reqId2 = 0;
|
|
if (!(response instanceof TLRPC.TL_messages_stickers)) {
|
|
return;
|
|
}
|
|
TLRPC.TL_messages_stickers res = (TLRPC.TL_messages_stickers) response;
|
|
int oldCount = emojiStickersArray.size();
|
|
for (int a = 0, size = res.stickers.size(); a < size; a++) {
|
|
TLRPC.Document document = res.stickers.get(a);
|
|
if (emojiStickersMap.indexOfKey(document.id) >= 0) {
|
|
continue;
|
|
}
|
|
emojiStickersArray.add(document);
|
|
}
|
|
int newCount = emojiStickersArray.size();
|
|
if (oldCount != newCount) {
|
|
emojiStickers.put(emojiStickersArray, searchQuery);
|
|
if (oldCount == 0) {
|
|
emojiArrays.add(emojiStickersArray);
|
|
}
|
|
notifyDataSetChanged();
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
notifyDataSetChanged();
|
|
}
|
|
};
|
|
|
|
public StickersSearchAdapter(Context context, Delegate delegate, TLRPC.StickerSetCovered[] primaryInstallingStickerSets, LongSparseArray<TLRPC.StickerSetCovered> installingStickerSets, LongSparseArray<TLRPC.StickerSetCovered> removingStickerSets) {
|
|
this.context = context;
|
|
this.delegate = delegate;
|
|
this.primaryInstallingStickerSets = primaryInstallingStickerSets;
|
|
this.installingStickerSets = installingStickerSets;
|
|
this.removingStickerSets = removingStickerSets;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnabled(RecyclerView.ViewHolder holder) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getItemCount() {
|
|
return Math.max(1, totalItems + 1);
|
|
}
|
|
|
|
public Object getItem(int i) {
|
|
return cache.get(i);
|
|
}
|
|
|
|
public void search(String text) {
|
|
if (reqId != 0) {
|
|
ConnectionsManager.getInstance(currentAccount).cancelRequest(reqId, true);
|
|
reqId = 0;
|
|
}
|
|
if (reqId2 != 0) {
|
|
ConnectionsManager.getInstance(currentAccount).cancelRequest(reqId2, true);
|
|
reqId2 = 0;
|
|
}
|
|
if (TextUtils.isEmpty(text)) {
|
|
searchQuery = null;
|
|
localPacks.clear();
|
|
emojiStickers.clear();
|
|
serverPacks.clear();
|
|
delegate.setAdapterVisible(false);
|
|
notifyDataSetChanged();
|
|
} else {
|
|
searchQuery = text.toLowerCase();
|
|
}
|
|
AndroidUtilities.cancelRunOnUIThread(searchRunnable);
|
|
AndroidUtilities.runOnUIThread(searchRunnable, 300);
|
|
}
|
|
|
|
@Override
|
|
public int getItemViewType(int position) {
|
|
if (position == 0 && totalItems == 0) {
|
|
return 5;
|
|
} else if (position == getItemCount() - 1) {
|
|
return 4;
|
|
}
|
|
Object object = cache.get(position);
|
|
if (object != null) {
|
|
if (object instanceof TLRPC.Document) {
|
|
return 0;
|
|
} else if (object instanceof TLRPC.StickerSetCovered) {
|
|
return 3;
|
|
} else {
|
|
return 2;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
|
|
View view = null;
|
|
switch (viewType) {
|
|
case 0:
|
|
StickerEmojiCell stickerEmojiCell = new StickerEmojiCell(context) {
|
|
public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(82), MeasureSpec.EXACTLY));
|
|
}
|
|
};
|
|
view = stickerEmojiCell;
|
|
stickerEmojiCell.getImageView().setLayerNum(3);
|
|
break;
|
|
case 1:
|
|
view = new EmptyCell(context);
|
|
break;
|
|
case 2:
|
|
view = new StickerSetNameCell(context, false, true);
|
|
break;
|
|
case 3:
|
|
view = new FeaturedStickerSetInfoCell(context, 17, true);
|
|
((FeaturedStickerSetInfoCell) view).setAddOnClickListener(v -> {
|
|
final FeaturedStickerSetInfoCell cell = (FeaturedStickerSetInfoCell) v.getParent();
|
|
TLRPC.StickerSetCovered pack = cell.getStickerSet();
|
|
if (installingStickerSets.indexOfKey(pack.set.id) >= 0 || removingStickerSets.indexOfKey(pack.set.id) >= 0) {
|
|
return;
|
|
}
|
|
if (cell.isInstalled()) {
|
|
removingStickerSets.put(pack.set.id, pack);
|
|
delegate.onStickerSetRemove(cell.getStickerSet());
|
|
} else {
|
|
installStickerSet(pack, cell);
|
|
}
|
|
});
|
|
break;
|
|
case 4:
|
|
view = new View(context);
|
|
break;
|
|
case 5:
|
|
LinearLayout layout = new LinearLayout(context);
|
|
layout.setOrientation(LinearLayout.VERTICAL);
|
|
layout.setGravity(Gravity.CENTER);
|
|
|
|
emptyImageView = new ImageView(context);
|
|
emptyImageView.setScaleType(ImageView.ScaleType.CENTER);
|
|
emptyImageView.setImageResource(R.drawable.stickers_empty);
|
|
emptyImageView.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_chat_emojiPanelEmptyText), PorterDuff.Mode.MULTIPLY));
|
|
layout.addView(emptyImageView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT));
|
|
|
|
layout.addView(new Space(context), LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 15));
|
|
|
|
emptyTextView = new TextView(context);
|
|
emptyTextView.setText(LocaleController.getString("NoStickersFound", R.string.NoStickersFound));
|
|
emptyTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
emptyTextView.setTextColor(Theme.getColor(Theme.key_chat_emojiPanelEmptyText));
|
|
layout.addView(emptyTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT));
|
|
|
|
view = layout;
|
|
view.setMinimumHeight(AndroidUtilities.dp(112));
|
|
view.setLayoutParams(LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
break;
|
|
}
|
|
|
|
return new RecyclerListView.Holder(view);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
|
|
switch (holder.getItemViewType()) {
|
|
case 0: {
|
|
TLRPC.Document sticker = (TLRPC.Document) cache.get(position);
|
|
StickerEmojiCell cell = (StickerEmojiCell) holder.itemView;
|
|
cell.setSticker(sticker, cacheParent.get(position), positionToEmoji.get(position), false);
|
|
//cell.setRecent(recentStickers.contains(sticker) || favouriteStickers.contains(sticker));
|
|
break;
|
|
}
|
|
case 1: {
|
|
EmptyCell cell = (EmptyCell) holder.itemView;
|
|
cell.setHeight(0);
|
|
break;
|
|
}
|
|
case 2: {
|
|
StickerSetNameCell cell = (StickerSetNameCell) holder.itemView;
|
|
Object object = cache.get(position);
|
|
if (object instanceof TLRPC.TL_messages_stickerSet) {
|
|
TLRPC.TL_messages_stickerSet set = (TLRPC.TL_messages_stickerSet) object;
|
|
if (!TextUtils.isEmpty(searchQuery) && localPacksByShortName.containsKey(set)) {
|
|
if (set.set != null) {
|
|
cell.setText(set.set.title, 0);
|
|
}
|
|
cell.setUrl(set.set.short_name, searchQuery.length());
|
|
} else {
|
|
Integer start = localPacksByName.get(set);
|
|
if (set.set != null && start != null) {
|
|
cell.setText(set.set.title, 0, start, !TextUtils.isEmpty(searchQuery) ? searchQuery.length() : 0);
|
|
}
|
|
cell.setUrl(null, 0);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 3: {
|
|
bindFeaturedStickerSetInfoCell((FeaturedStickerSetInfoCell) holder.itemView, position, false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position, @NonNull List payloads) {
|
|
if (payloads.contains(PAYLOAD_ANIMATED)) {
|
|
if (holder.getItemViewType() == 3) {
|
|
bindFeaturedStickerSetInfoCell((FeaturedStickerSetInfoCell) holder.itemView, position, true);
|
|
}
|
|
} else {
|
|
super.onBindViewHolder(holder, position, payloads);
|
|
}
|
|
}
|
|
|
|
public void installStickerSet(TLRPC.InputStickerSet inputSet) {
|
|
for (int i = 0; i < serverPacks.size(); i++) {
|
|
final TLRPC.StickerSetCovered setCovered = serverPacks.get(i);
|
|
if (setCovered.set.id == inputSet.id) {
|
|
installStickerSet(setCovered, null);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void installStickerSet(TLRPC.StickerSetCovered pack, FeaturedStickerSetInfoCell cell) {
|
|
for (int i = 0; i < primaryInstallingStickerSets.length; i++) {
|
|
if (primaryInstallingStickerSets[i] != null) {
|
|
final TLRPC.TL_messages_stickerSet s = MediaDataController.getInstance(currentAccount).getStickerSetById(primaryInstallingStickerSets[i].set.id);
|
|
if (s != null && !s.set.archived) {
|
|
primaryInstallingStickerSets[i] = null;
|
|
break;
|
|
}
|
|
if (primaryInstallingStickerSets[i].set.id == pack.set.id) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean primary = false;
|
|
for (int i = 0; i < primaryInstallingStickerSets.length; i++) {
|
|
if (primaryInstallingStickerSets[i] == null) {
|
|
primaryInstallingStickerSets[i] = pack;
|
|
primary = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!primary && cell != null) {
|
|
cell.setAddDrawProgress(true, true);
|
|
}
|
|
installingStickerSets.put(pack.set.id, pack);
|
|
if (cell != null) {
|
|
delegate.onStickerSetAdd(cell.getStickerSet(), primary);
|
|
} else {
|
|
for (int i = 0, size = positionsToSets.size(); i < size; i++) {
|
|
final TLRPC.StickerSetCovered item = positionsToSets.get(i);
|
|
if (item != null && item.set.id == pack.set.id) {
|
|
notifyItemChanged(i, PAYLOAD_ANIMATED);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void bindFeaturedStickerSetInfoCell(FeaturedStickerSetInfoCell cell, int position, boolean animated) {
|
|
final MediaDataController mediaDataController = MediaDataController.getInstance(currentAccount);
|
|
ArrayList<Long> unreadStickers = mediaDataController.getUnreadStickerSets();
|
|
TLRPC.StickerSetCovered stickerSetCovered = (TLRPC.StickerSetCovered) cache.get(position);
|
|
boolean unread = unreadStickers != null && unreadStickers.contains(stickerSetCovered.set.id);
|
|
boolean forceInstalled = false;
|
|
for (int i = 0; i < primaryInstallingStickerSets.length; i++) {
|
|
if (primaryInstallingStickerSets[i] != null) {
|
|
final TLRPC.TL_messages_stickerSet s = MediaDataController.getInstance(currentAccount).getStickerSetById(primaryInstallingStickerSets[i].set.id);
|
|
if (s != null && !s.set.archived) {
|
|
primaryInstallingStickerSets[i] = null;
|
|
continue;
|
|
}
|
|
if (primaryInstallingStickerSets[i].set.id == stickerSetCovered.set.id) {
|
|
forceInstalled = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int idx = TextUtils.isEmpty(searchQuery) ? -1 : AndroidUtilities.indexOfIgnoreCase(stickerSetCovered.set.title, searchQuery);
|
|
if (idx >= 0) {
|
|
cell.setStickerSet(stickerSetCovered, unread, animated, idx, searchQuery.length(), forceInstalled);
|
|
} else {
|
|
cell.setStickerSet(stickerSetCovered, unread, animated, 0, 0, forceInstalled);
|
|
if (!TextUtils.isEmpty(searchQuery) && AndroidUtilities.indexOfIgnoreCase(stickerSetCovered.set.short_name, searchQuery) == 0) {
|
|
cell.setUrl(stickerSetCovered.set.short_name, searchQuery.length());
|
|
}
|
|
}
|
|
|
|
if (unread) {
|
|
mediaDataController.markFaturedStickersByIdAsRead(stickerSetCovered.set.id);
|
|
}
|
|
|
|
boolean installing = installingStickerSets.indexOfKey(stickerSetCovered.set.id) >= 0;
|
|
boolean removing = removingStickerSets.indexOfKey(stickerSetCovered.set.id) >= 0;
|
|
if (installing || removing) {
|
|
if (installing && cell.isInstalled()) {
|
|
installingStickerSets.remove(stickerSetCovered.set.id);
|
|
installing = false;
|
|
} else if (removing && !cell.isInstalled()) {
|
|
removingStickerSets.remove(stickerSetCovered.set.id);
|
|
removing = false;
|
|
}
|
|
}
|
|
cell.setAddDrawProgress(!forceInstalled && installing, animated);
|
|
mediaDataController.preloadStickerSetThumb(stickerSetCovered);
|
|
cell.setNeedDivider(position > 0);
|
|
}
|
|
|
|
@Override
|
|
public void notifyDataSetChanged() {
|
|
rowStartPack.clear();
|
|
positionToRow.clear();
|
|
cache.clear();
|
|
positionsToSets.clear();
|
|
positionToEmoji.clear();
|
|
totalItems = 0;
|
|
int startRow = 0;
|
|
for (int a = 0, serverCount = serverPacks.size(), localCount = localPacks.size(), emojiCount = (emojiArrays.isEmpty() ? 0 : 1); a < serverCount + localCount + emojiCount; a++) {
|
|
ArrayList<TLRPC.Document> documents;
|
|
Object pack = null;
|
|
String key;
|
|
int idx = a;
|
|
if (idx < localCount) {
|
|
TLRPC.TL_messages_stickerSet set = localPacks.get(idx);
|
|
documents = set.documents;
|
|
pack = set;
|
|
} else {
|
|
idx -= localCount;
|
|
if (idx < emojiCount) {
|
|
int documentsCount = 0;
|
|
String lastEmoji = "";
|
|
for (int i = 0, N = emojiArrays.size(); i < N; i++) {
|
|
documents = emojiArrays.get(i);
|
|
String emoji = emojiStickers.get(documents);
|
|
if (emoji != null && !lastEmoji.equals(emoji)) {
|
|
lastEmoji = emoji;
|
|
positionToEmoji.put(totalItems + documentsCount, lastEmoji);
|
|
}
|
|
for (int b = 0, size = documents.size(); b < size; b++) {
|
|
int num = documentsCount + totalItems;
|
|
int row = startRow + documentsCount / delegate.getStickersPerRow();
|
|
|
|
TLRPC.Document document = documents.get(b);
|
|
cache.put(num, document);
|
|
Object parent = MediaDataController.getInstance(currentAccount).getStickerSetById(MediaDataController.getStickerSetId(document));
|
|
if (parent != null) {
|
|
cacheParent.put(num, parent);
|
|
}
|
|
positionToRow.put(num, row);
|
|
if (a >= localCount && pack instanceof TLRPC.StickerSetCovered) {
|
|
positionsToSets.put(num, (TLRPC.StickerSetCovered) pack);
|
|
}
|
|
documentsCount++;
|
|
}
|
|
}
|
|
int count = (int) Math.ceil(documentsCount / (float) delegate.getStickersPerRow());
|
|
for (int b = 0, N = count; b < N; b++) {
|
|
rowStartPack.put(startRow + b, documentsCount);
|
|
}
|
|
totalItems += count * delegate.getStickersPerRow();
|
|
startRow += count;
|
|
continue;
|
|
} else {
|
|
idx -= emojiCount;
|
|
TLRPC.StickerSetCovered set = serverPacks.get(idx);
|
|
documents = set.covers;
|
|
pack = set;
|
|
}
|
|
}
|
|
if (documents.isEmpty()) {
|
|
continue;
|
|
}
|
|
int count = (int) Math.ceil(documents.size() / (float) delegate.getStickersPerRow());
|
|
cache.put(totalItems, pack);
|
|
if (a >= localCount && pack instanceof TLRPC.StickerSetCovered) {
|
|
positionsToSets.put(totalItems, (TLRPC.StickerSetCovered) pack);
|
|
}
|
|
positionToRow.put(totalItems, startRow);
|
|
for (int b = 0, size = documents.size(); b < size; b++) {
|
|
int num = 1 + b + totalItems;
|
|
int row = startRow + 1 + b / delegate.getStickersPerRow();
|
|
TLRPC.Document document = documents.get(b);
|
|
cache.put(num, document);
|
|
if (pack != null) {
|
|
cacheParent.put(num, pack);
|
|
}
|
|
positionToRow.put(num, row);
|
|
if (a >= localCount && pack instanceof TLRPC.StickerSetCovered) {
|
|
positionsToSets.put(num, (TLRPC.StickerSetCovered) pack);
|
|
}
|
|
}
|
|
for (int b = 0, N = count + 1; b < N; b++) {
|
|
rowStartPack.put(startRow + b, pack);
|
|
}
|
|
totalItems += 1 + count * delegate.getStickersPerRow();
|
|
startRow += count + 1;
|
|
}
|
|
super.notifyDataSetChanged();
|
|
}
|
|
|
|
public int getSpanSize(int position) {
|
|
if (position != totalItems) {
|
|
Object object = cache.get(position);
|
|
if (object == null || cache.get(position) instanceof TLRPC.Document) {
|
|
return 1;
|
|
}
|
|
}
|
|
return delegate.getStickersPerRow();
|
|
}
|
|
|
|
public TLRPC.StickerSetCovered getSetForPosition(int position) {
|
|
return positionsToSets.get(position);
|
|
}
|
|
|
|
public void updateColors(RecyclerListView listView) {
|
|
for (int i = 0, size = listView.getChildCount(); i < size; i++) {
|
|
final View child = listView.getChildAt(i);
|
|
if (child instanceof FeaturedStickerSetInfoCell) {
|
|
((FeaturedStickerSetInfoCell) child).updateColors();
|
|
} else if (child instanceof StickerSetNameCell) {
|
|
((StickerSetNameCell) child).updateColors();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void getThemeDescriptions(List<ThemeDescription> descriptions, RecyclerListView listView, ThemeDescription.ThemeDescriptionDelegate delegate) {
|
|
FeaturedStickerSetInfoCell.createThemeDescriptions(descriptions, listView, delegate);
|
|
StickerSetNameCell.createThemeDescriptions(descriptions, listView, delegate);
|
|
descriptions.add(new ThemeDescription(emptyImageView, ThemeDescription.FLAG_IMAGECOLOR, null, null, null, null, Theme.key_chat_emojiPanelEmptyText));
|
|
descriptions.add(new ThemeDescription(emptyTextView, ThemeDescription.FLAG_TEXTCOLOR, null, null, null, null, Theme.key_chat_emojiPanelEmptyText));
|
|
}
|
|
} |