mirror of https://github.com/NekoX-Dev/NekoX.git
1396 lines
67 KiB
Java
1396 lines
67 KiB
Java
package org.telegram.ui.Components;
|
|
|
|
import static org.telegram.messenger.AndroidUtilities.dp;
|
|
|
|
import android.animation.ValueAnimator;
|
|
import android.content.Context;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Path;
|
|
import android.graphics.Rect;
|
|
import android.os.SystemClock;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.util.LongSparseArray;
|
|
import android.util.SparseArray;
|
|
import android.util.TypedValue;
|
|
import android.view.Gravity;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.ArrayAdapter;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.core.math.MathUtils;
|
|
import androidx.recyclerview.widget.GridLayoutManager;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
|
|
import org.telegram.messenger.AndroidUtilities;
|
|
import org.telegram.messenger.FileLog;
|
|
import org.telegram.messenger.ImageReceiver;
|
|
import org.telegram.messenger.LocaleController;
|
|
import org.telegram.messenger.MediaDataController;
|
|
import org.telegram.messenger.MessageObject;
|
|
import org.telegram.messenger.MessagesController;
|
|
import org.telegram.messenger.NotificationCenter;
|
|
import org.telegram.messenger.R;
|
|
import org.telegram.messenger.UserConfig;
|
|
import org.telegram.messenger.Utilities;
|
|
import org.telegram.tgnet.ConnectionsManager;
|
|
import org.telegram.tgnet.TLRPC;
|
|
import org.telegram.ui.ActionBar.ActionBarMenuItem;
|
|
import org.telegram.ui.ActionBar.BaseFragment;
|
|
import org.telegram.ui.ActionBar.BottomSheet;
|
|
import org.telegram.ui.ActionBar.Theme;
|
|
import org.telegram.ui.ChatActivity;
|
|
import org.telegram.ui.Components.Premium.PremiumButtonView;
|
|
import org.telegram.ui.Components.Premium.PremiumFeatureBottomSheet;
|
|
import org.telegram.ui.LaunchActivity;
|
|
import org.telegram.ui.PremiumPreviewFragment;
|
|
import org.telegram.ui.ProfileActivity;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
public class EmojiPacksAlert extends BottomSheet implements NotificationCenter.NotificationCenterDelegate {
|
|
|
|
private LongSparseArray<AnimatedEmojiDrawable> animatedEmojiDrawables;
|
|
|
|
private BaseFragment fragment;
|
|
|
|
private View paddingView;
|
|
private EmojiPacksLoader customEmojiPacks;
|
|
|
|
private RecyclerListView listView;
|
|
private View shadowView;
|
|
private FrameLayout buttonsView;
|
|
private TextView addButtonView;
|
|
private TextView removeButtonView;
|
|
private PremiumButtonView premiumButtonView;
|
|
private GridLayoutManager gridLayoutManager;
|
|
|
|
private CircularProgressDrawable progressDrawable;
|
|
|
|
private boolean hasDescription;
|
|
private float loadT;
|
|
private float lastY;
|
|
private Float fromY;
|
|
|
|
@Override
|
|
protected boolean canDismissWithSwipe() {
|
|
return false;
|
|
}
|
|
|
|
public EmojiPacksAlert(BaseFragment fragment, Context context, Theme.ResourcesProvider resourceProvider, ArrayList<TLRPC.InputStickerSet> stickerSets) {
|
|
super(context, false, resourceProvider);
|
|
boolean single = stickerSets.size() <= 1;
|
|
this.fragment = fragment;
|
|
fixNavigationBar();
|
|
|
|
customEmojiPacks = new EmojiPacksLoader(currentAccount, stickerSets) {
|
|
@Override
|
|
protected void onUpdate() {
|
|
updateButton();
|
|
if (listView != null && listView.getAdapter() != null) {
|
|
listView.getAdapter().notifyDataSetChanged();
|
|
}
|
|
}
|
|
};
|
|
|
|
progressDrawable = new CircularProgressDrawable(AndroidUtilities.dp(32), AndroidUtilities.dp(3.5f), getThemedColor(Theme.key_featuredStickers_addButton));
|
|
|
|
containerView = new FrameLayout(context) {
|
|
|
|
private Paint paint = new Paint();
|
|
private Path path = new Path();
|
|
private Boolean lastOpen = null;
|
|
boolean attached;
|
|
SparseArray<ArrayList<EmojiImageView>> viewsGroupedByLines = new SparseArray<>();
|
|
ArrayList<DrawingInBackgroundLine> lineDrawables = new ArrayList<>();
|
|
ArrayList<DrawingInBackgroundLine> lineDrawablesTmp = new ArrayList<>();
|
|
ArrayList<ArrayList<EmojiImageView>> unusedArrays = new ArrayList<>();
|
|
ArrayList<DrawingInBackgroundLine> unusedLineDrawables = new ArrayList<>();
|
|
|
|
@Override
|
|
protected void dispatchDraw(Canvas canvas) {
|
|
if (!attached) {
|
|
return;
|
|
}
|
|
paint.setColor(getThemedColor(Theme.key_dialogBackground));
|
|
paint.setShadowLayer(dp(2), 0, dp(-0.66f), 0x1e000000);
|
|
path.reset();
|
|
float y = lastY = getListTop();
|
|
float pad = 0;
|
|
if (fromY != null) {
|
|
float wasY = y;
|
|
y = AndroidUtilities.lerp(fromY, y + containerView.getY(), loadT) - containerView.getY();
|
|
pad = y - wasY;
|
|
}
|
|
float stickToTop = (1f - MathUtils.clamp((y - containerView.getPaddingTop()) / AndroidUtilities.dp(32), 0, 1));
|
|
y -= stickToTop * containerView.getPaddingTop();
|
|
float r = dp((1f - stickToTop) * 14);
|
|
AndroidUtilities.rectTmp.set(getPaddingLeft(), y, getWidth() - getPaddingRight(), getBottom() + r);
|
|
path.addRoundRect(AndroidUtilities.rectTmp, r, r, Path.Direction.CW);
|
|
canvas.drawPath(path, paint);
|
|
|
|
boolean open = stickToTop > .75f;
|
|
if (lastOpen == null || open != lastOpen) {
|
|
updateLightStatusBar(lastOpen = open);
|
|
}
|
|
|
|
Theme.dialogs_onlineCirclePaint.setColor(getThemedColor(Theme.key_sheet_scrollUp));
|
|
Theme.dialogs_onlineCirclePaint.setAlpha((int) (MathUtils.clamp(y / (float) AndroidUtilities.dp(20), 0, 1) * Theme.dialogs_onlineCirclePaint.getAlpha()));
|
|
int w = AndroidUtilities.dp(36);
|
|
y += AndroidUtilities.dp(10);
|
|
AndroidUtilities.rectTmp.set((getMeasuredWidth() - w) / 2, y, (getMeasuredWidth() + w) / 2, y + AndroidUtilities.dp(4));
|
|
canvas.drawRoundRect(AndroidUtilities.rectTmp, AndroidUtilities.dp(2), AndroidUtilities.dp(2), Theme.dialogs_onlineCirclePaint);
|
|
|
|
shadowView.setVisibility(listView.canScrollVertically(1) || removeButtonView.getVisibility() == View.VISIBLE ? View.VISIBLE : View.INVISIBLE);
|
|
if (listView != null) {
|
|
canvas.save();
|
|
canvas.translate(listView.getLeft(), listView.getTop() + pad);
|
|
canvas.clipRect(0, 0, listView.getWidth(), listView.getHeight());
|
|
canvas.saveLayerAlpha(0, 0, listView.getWidth(), listView.getHeight(), (int) (255 * listView.getAlpha()), Canvas.ALL_SAVE_FLAG);
|
|
|
|
for (int i = 0; i < viewsGroupedByLines.size(); i++) {
|
|
ArrayList<EmojiImageView> arrayList = viewsGroupedByLines.valueAt(i);
|
|
arrayList.clear();
|
|
unusedArrays.add(arrayList);
|
|
}
|
|
viewsGroupedByLines.clear();
|
|
for (int i = 0; i < listView.getChildCount(); ++i) {
|
|
View child = listView.getChildAt(i);
|
|
if (child instanceof EmojiImageView) {
|
|
if (animatedEmojiDrawables == null) {
|
|
animatedEmojiDrawables = new LongSparseArray<>();
|
|
}
|
|
AnimatedEmojiSpan span = ((EmojiImageView) child).span;
|
|
if (span == null) {
|
|
continue;
|
|
}
|
|
long documentId = span.getDocumentId();
|
|
AnimatedEmojiDrawable drawable = animatedEmojiDrawables.get(documentId);
|
|
if (drawable == null) {
|
|
animatedEmojiDrawables.put(documentId, drawable = AnimatedEmojiDrawable.make(currentAccount, AnimatedEmojiDrawable.CACHE_TYPE_ALERT_PREVIEW, documentId));
|
|
}
|
|
drawable.addView(this);
|
|
ArrayList<EmojiImageView> arrayList = viewsGroupedByLines.get(child.getTop());
|
|
if (arrayList == null) {
|
|
if (!unusedArrays.isEmpty()) {
|
|
arrayList = unusedArrays.remove(unusedArrays.size() - 1);
|
|
} else {
|
|
arrayList = new ArrayList<>();
|
|
}
|
|
viewsGroupedByLines.put(child.getTop(), arrayList);
|
|
}
|
|
arrayList.add((EmojiImageView) child);
|
|
} else {
|
|
canvas.save();
|
|
canvas.translate(child.getLeft(), child.getTop());
|
|
child.draw(canvas);
|
|
canvas.restore();
|
|
}
|
|
}
|
|
|
|
lineDrawablesTmp.clear();
|
|
lineDrawablesTmp.addAll(lineDrawables);
|
|
lineDrawables.clear();
|
|
|
|
long time = System.currentTimeMillis();
|
|
for (int i = 0; i < viewsGroupedByLines.size(); i++) {
|
|
ArrayList<EmojiImageView> arrayList = viewsGroupedByLines.valueAt(i);
|
|
View firstView = arrayList.get(0);
|
|
int position = listView.getChildAdapterPosition(firstView);
|
|
DrawingInBackgroundLine drawable = null;
|
|
for (int k = 0; k < lineDrawablesTmp.size(); k++) {
|
|
if (lineDrawablesTmp.get(k).position == position) {
|
|
drawable = lineDrawablesTmp.get(k);
|
|
lineDrawablesTmp.remove(k);
|
|
break;
|
|
}
|
|
}
|
|
if (drawable == null) {
|
|
if (!unusedLineDrawables.isEmpty()) {
|
|
drawable = unusedLineDrawables.remove(unusedLineDrawables.size() - 1);
|
|
} else {
|
|
drawable = new DrawingInBackgroundLine();
|
|
drawable.currentLayerNum = 7;
|
|
}
|
|
drawable.position = position;
|
|
drawable.onAttachToWindow();
|
|
}
|
|
lineDrawables.add(drawable);
|
|
drawable.imageViewEmojis = arrayList;
|
|
canvas.save();
|
|
canvas.translate(0, firstView.getY() + firstView.getPaddingTop());
|
|
drawable.draw(canvas, time, getMeasuredWidth(), firstView.getMeasuredHeight() - firstView.getPaddingBottom(), 1f);
|
|
canvas.restore();
|
|
}
|
|
|
|
for (int i = 0; i < lineDrawablesTmp.size(); i++) {
|
|
if (unusedLineDrawables.size() < 3) {
|
|
unusedLineDrawables.add(lineDrawablesTmp.get(i));
|
|
lineDrawablesTmp.get(i).imageViewEmojis = null;
|
|
lineDrawablesTmp.get(i).reset();
|
|
|
|
} else {
|
|
lineDrawablesTmp.get(i).onDetachFromWindow();
|
|
}
|
|
}
|
|
lineDrawablesTmp.clear();
|
|
canvas.restore();
|
|
canvas.restore();
|
|
|
|
if (listView.getAlpha() < 1) {
|
|
int cx = getWidth() / 2;
|
|
int cy = ((int) y + getHeight()) / 2;
|
|
int R = AndroidUtilities.dp(16);
|
|
progressDrawable.setAlpha((int) (255 * (1f - listView.getAlpha())));
|
|
progressDrawable.setBounds(cx - R, cy - R, cx + R, cy + R);
|
|
progressDrawable.draw(canvas);
|
|
invalidate();
|
|
}
|
|
}
|
|
super.dispatchDraw(canvas);
|
|
}
|
|
|
|
@Override
|
|
public boolean dispatchTouchEvent(MotionEvent event) {
|
|
if (event.getAction() == MotionEvent.ACTION_DOWN && event.getY() < getListTop() - AndroidUtilities.dp(6)) {
|
|
dismiss();
|
|
}
|
|
return super.dispatchTouchEvent(event);
|
|
}
|
|
|
|
class DrawingInBackgroundLine extends DrawingInBackgroundThreadDrawable {
|
|
public int position;
|
|
ArrayList<EmojiImageView> imageViewEmojis;
|
|
ArrayList<EmojiImageView> drawInBackgroundViews = new ArrayList<>();
|
|
|
|
|
|
@Override
|
|
public void prepareDraw(long time) {
|
|
drawInBackgroundViews.clear();
|
|
for (int i = 0; i < imageViewEmojis.size(); i++) {
|
|
EmojiImageView imageView = imageViewEmojis.get(i);
|
|
AnimatedEmojiSpan span = imageView.span;
|
|
if (span == null) {
|
|
continue;
|
|
}
|
|
AnimatedEmojiDrawable drawable = animatedEmojiDrawables.get(imageView.span.getDocumentId());
|
|
if (drawable == null || drawable.getImageReceiver() == null) {
|
|
continue;
|
|
}
|
|
|
|
drawable.update(time);
|
|
imageView.backgroundThreadDrawHolder = drawable.getImageReceiver().setDrawInBackgroundThread(imageView.backgroundThreadDrawHolder);
|
|
imageView.backgroundThreadDrawHolder.time = time;
|
|
drawable.setAlpha(255);
|
|
AndroidUtilities.rectTmp2.set(imageView.getLeft() + imageView.getPaddingLeft(), imageView.getPaddingTop(), imageView.getRight() - imageView.getPaddingRight(), imageView.getMeasuredHeight() - imageView.getPaddingBottom());
|
|
imageView.backgroundThreadDrawHolder.setBounds(AndroidUtilities.rectTmp2);
|
|
imageView.imageReceiver = drawable.getImageReceiver();
|
|
drawInBackgroundViews.add(imageView);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void drawInBackground(Canvas canvas) {
|
|
for (int i = 0; i < drawInBackgroundViews.size(); i++) {
|
|
EmojiImageView imageView = drawInBackgroundViews.get(i);
|
|
imageView.imageReceiver.draw(canvas, imageView.backgroundThreadDrawHolder);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void drawInUiThread(Canvas canvas) {
|
|
if (imageViewEmojis != null) {
|
|
for (int i = 0; i < imageViewEmojis.size(); i++) {
|
|
EmojiImageView imageView = imageViewEmojis.get(i);
|
|
AnimatedEmojiSpan span = imageView.span;
|
|
if (span == null) {
|
|
continue;
|
|
}
|
|
AnimatedEmojiDrawable drawable = animatedEmojiDrawables.get(imageView.span.getDocumentId());
|
|
if (drawable == null || drawable.getImageReceiver() == null) {
|
|
continue;
|
|
}
|
|
if (imageView.imageReceiver != null) {
|
|
drawable.setAlpha((int) (255 * imageView.getAlpha()));
|
|
drawable.setBounds(imageView.getLeft() + imageView.getPaddingLeft(), imageView.getPaddingTop(), imageView.getRight() - imageView.getPaddingRight(), imageView.getMeasuredHeight() - imageView.getPaddingBottom());
|
|
drawable.draw(canvas);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onFrameReady() {
|
|
super.onFrameReady();
|
|
for (int i = 0; i < drawInBackgroundViews.size(); i++) {
|
|
EmojiImageView imageView = drawInBackgroundViews.get(i);
|
|
imageView.backgroundThreadDrawHolder.release();
|
|
}
|
|
containerView.invalidate();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
attached = true;
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
attached = false;
|
|
for (int i = 0; i < lineDrawables.size(); i++) {
|
|
lineDrawables.get(i).onDetachFromWindow();
|
|
}
|
|
for (int i = 0; i < unusedLineDrawables.size(); i++) {
|
|
unusedLineDrawables.get(i).onDetachFromWindow();
|
|
}
|
|
lineDrawables.clear();
|
|
}
|
|
};
|
|
|
|
paddingView = new View(context) {
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
boolean isPortrait = AndroidUtilities.displaySize.x < AndroidUtilities.displaySize.y;
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec((int) (AndroidUtilities.displaySize.y * (isPortrait ? .56f : .3f)), MeasureSpec.EXACTLY));
|
|
}
|
|
};
|
|
listView = new RecyclerListView(context) {
|
|
|
|
@Override
|
|
protected void onMeasure(int widthSpec, int heightSpec) {
|
|
int width = MeasureSpec.getSize(widthSpec);
|
|
gridLayoutManager.setSpanCount(Math.max(1, width / AndroidUtilities.dp(AndroidUtilities.isTablet() ? 60 : 45)));
|
|
super.onMeasure(widthSpec, heightSpec);
|
|
}
|
|
|
|
@Override
|
|
public void onScrolled(int dx, int dy) {
|
|
super.onScrolled(dx, dy);
|
|
containerView.invalidate();
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
AnimatedEmojiSpan.release(containerView, animatedEmojiDrawables);
|
|
}
|
|
|
|
@Override
|
|
public boolean drawChild(Canvas canvas, View child, long drawingTime) {
|
|
return false;
|
|
}
|
|
};
|
|
containerView.setPadding(backgroundPaddingLeft, AndroidUtilities.statusBarHeight, backgroundPaddingLeft, 0);
|
|
containerView.setClipChildren(false);
|
|
containerView.setClipToPadding(false);
|
|
containerView.setWillNotDraw(false);
|
|
listView.setPadding(AndroidUtilities.dp(8), 0, AndroidUtilities.dp(8), AndroidUtilities.dp(68));
|
|
listView.setAdapter(new Adapter());
|
|
listView.setLayoutManager(gridLayoutManager = new GridLayoutManager(context, 8));
|
|
listView.addItemDecoration(new RecyclerView.ItemDecoration() {
|
|
@Override
|
|
public void getItemOffsets(@NonNull Rect outRect, @NonNull View view, @NonNull RecyclerView parent, @NonNull RecyclerView.State state) {
|
|
if (view instanceof SeparatorView) {
|
|
outRect.left = -listView.getPaddingLeft();
|
|
outRect.right = -listView.getPaddingRight();
|
|
} else if (listView.getChildAdapterPosition(view) == 1) {
|
|
outRect.top = AndroidUtilities.dp(14);
|
|
}
|
|
}
|
|
});
|
|
listView.setOnItemClickListener((view, position) -> {
|
|
if (stickerSets == null || stickerSets.size() <= 1) {
|
|
return;
|
|
}
|
|
if (SystemClock.elapsedRealtime() - premiumButtonClicked < 250) {
|
|
return;
|
|
}
|
|
int i = 0;
|
|
int sz = 0;
|
|
for (int j = 0; i < customEmojiPacks.data.length; ++i) {
|
|
sz = customEmojiPacks.data[i].size();
|
|
if (customEmojiPacks.data.length > 1) {
|
|
sz = Math.min(gridLayoutManager.getSpanCount() * 2, sz);
|
|
}
|
|
j += 1 + sz + 1;
|
|
if (position < j) {
|
|
break;
|
|
}
|
|
}
|
|
TLRPC.TL_messages_stickerSet stickerSet = customEmojiPacks.stickerSets == null || i >= customEmojiPacks.stickerSets.size() ? null : customEmojiPacks.stickerSets.get(i);
|
|
if (stickerSet != null && stickerSet.set != null) {
|
|
ArrayList<TLRPC.InputStickerSet> inputStickerSets = new ArrayList<>();
|
|
TLRPC.TL_inputStickerSetID inputStickerSet = new TLRPC.TL_inputStickerSetID();
|
|
inputStickerSet.id = stickerSet.set.id;
|
|
inputStickerSet.access_hash = stickerSet.set.access_hash;
|
|
inputStickerSets.add(inputStickerSet);
|
|
new EmojiPacksAlert(fragment, getContext(), resourceProvider, inputStickerSets).show();
|
|
}
|
|
});
|
|
gridLayoutManager.setReverseLayout(false);
|
|
gridLayoutManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
|
|
@Override
|
|
public int getSpanSize(int position) {
|
|
return listView.getAdapter() != null && listView.getAdapter().getItemViewType(position) != 1 ? gridLayoutManager.getSpanCount() : 1;
|
|
}
|
|
});
|
|
|
|
containerView.addView(listView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.TOP | Gravity.LEFT));
|
|
|
|
shadowView = new View(context);
|
|
shadowView.setBackgroundColor(Theme.getColor(Theme.key_dialogShadowLine));
|
|
containerView.addView(shadowView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 1f / AndroidUtilities.density, Gravity.BOTTOM));
|
|
shadowView.setTranslationY(-AndroidUtilities.dp(68));
|
|
|
|
buttonsView = new FrameLayout(context);
|
|
buttonsView.setBackgroundColor(getThemedColor(Theme.key_dialogBackground));
|
|
containerView.addView(buttonsView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 68, Gravity.BOTTOM | Gravity.FILL_HORIZONTAL));
|
|
|
|
addButtonView = new TextView(context);
|
|
addButtonView.setVisibility(View.GONE);
|
|
addButtonView.setBackground(Theme.AdaptiveRipple.filledRect(getThemedColor(Theme.key_featuredStickers_addButton), 6));
|
|
addButtonView.setTextColor(getThemedColor(Theme.key_featuredStickers_buttonText));
|
|
addButtonView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
addButtonView.setGravity(Gravity.CENTER);
|
|
buttonsView.addView(addButtonView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 48, Gravity.BOTTOM, 12, 10, 12, 10));
|
|
|
|
removeButtonView = new TextView(context) {
|
|
@Override
|
|
public void setVisibility(int visibility) {
|
|
super.setVisibility(visibility);
|
|
}
|
|
};
|
|
removeButtonView.setVisibility(View.GONE);
|
|
removeButtonView.setBackground(Theme.createRadSelectorDrawable(0x0fffffff & getThemedColor(Theme.key_dialogTextRed), 0, 0));
|
|
removeButtonView.setTextColor(getThemedColor(Theme.key_dialogTextRed));
|
|
removeButtonView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
removeButtonView.setGravity(Gravity.CENTER);
|
|
removeButtonView.setClickable(true);
|
|
buttonsView.addView(removeButtonView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.BOTTOM, 0, 0, 0, 19));
|
|
|
|
premiumButtonView = new PremiumButtonView(context, false);
|
|
premiumButtonView.setButton(LocaleController.getString("UnlockPremiumEmoji", R.string.UnlockPremiumEmoji), ev -> {
|
|
showPremiumAlert();
|
|
});
|
|
premiumButtonView.setIcon(R.raw.unlock_icon);
|
|
premiumButtonView.buttonLayout.setClickable(true);
|
|
buttonsView.addView(premiumButtonView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 48, Gravity.BOTTOM, 12, 10, 12, 10));
|
|
|
|
updateButton();
|
|
MediaDataController.getInstance(fragment.getCurrentAccount()).checkStickers(MediaDataController.TYPE_EMOJIPACKS);
|
|
}
|
|
|
|
protected void onButtonClicked(boolean install) {
|
|
|
|
}
|
|
|
|
private void updateShowButton(boolean show, boolean animated) {
|
|
final float removeOffset = (removeButtonView.getVisibility() == View.VISIBLE ? AndroidUtilities.dp(19) : 0);
|
|
if (animated) {
|
|
buttonsView.animate().translationY(show ? removeOffset : AndroidUtilities.dp(16)).alpha(show ? 1 : 0).setDuration(250).setInterpolator(CubicBezierInterpolator.EASE_OUT_QUINT).start();
|
|
shadowView.animate().translationY(show ? -(AndroidUtilities.dp(68) - removeOffset) : 0).alpha(show ? 1 : 0).setDuration(250).setInterpolator(CubicBezierInterpolator.EASE_OUT_QUINT).start();
|
|
listView.animate().translationY(!show ? (AndroidUtilities.dp(68) - removeOffset) : 0).setDuration(250).setInterpolator(CubicBezierInterpolator.EASE_OUT_QUINT).start();
|
|
} else {
|
|
buttonsView.setAlpha(show ? 1f : 0);
|
|
buttonsView.setTranslationY(show ? removeOffset : AndroidUtilities.dp(16));
|
|
shadowView.setAlpha(show ? 1f : 0);
|
|
shadowView.setTranslationY(show ? -(AndroidUtilities.dp(68) - removeOffset) : 0);
|
|
listView.setTranslationY(!show ? (AndroidUtilities.dp(68) - removeOffset) : 0);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.stickersDidLoad);
|
|
}
|
|
|
|
@Override
|
|
public void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.stickersDidLoad);
|
|
}
|
|
|
|
@Override
|
|
public void didReceivedNotification(int id, int account, Object... args) {
|
|
if (id == NotificationCenter.stickersDidLoad) {
|
|
updateInstallment();
|
|
}
|
|
}
|
|
|
|
private long premiumButtonClicked;
|
|
public void showPremiumAlert() {
|
|
if (fragment != null) {
|
|
new PremiumFeatureBottomSheet(fragment, PremiumPreviewFragment.PREMIUM_FEATURE_ANIMATED_EMOJI, false).show();
|
|
} else if (getContext() instanceof LaunchActivity) {
|
|
((LaunchActivity) getContext()).presentFragment(new PremiumPreviewFragment(null));
|
|
}
|
|
}
|
|
|
|
private void updateLightStatusBar(boolean open) {
|
|
boolean openBgLight = AndroidUtilities.computePerceivedBrightness(getThemedColor(Theme.key_dialogBackground)) > .721f;
|
|
boolean closedBgLight = AndroidUtilities.computePerceivedBrightness(Theme.blendOver(getThemedColor(Theme.key_actionBarDefault), 0x33000000)) > .721f;
|
|
boolean isLight = open ? openBgLight : closedBgLight;
|
|
AndroidUtilities.setLightStatusBar(getWindow(), isLight);
|
|
}
|
|
|
|
public void updateInstallment() {
|
|
for (int i = 0; i < listView.getChildCount(); ++i) {
|
|
View child = listView.getChildAt(i);
|
|
if (child instanceof EmojiPackHeader) {
|
|
EmojiPackHeader header = (EmojiPackHeader) child;
|
|
if (header.set != null && header.set.set != null) {
|
|
header.toggle(MediaDataController.getInstance(currentAccount).isStickerPackInstalled(header.set.set.id), true);
|
|
}
|
|
}
|
|
}
|
|
updateButton();
|
|
}
|
|
|
|
public static void installSet(BaseFragment fragment, TLRPC.TL_messages_stickerSet set, boolean showBulletIn) {
|
|
installSet(fragment, set, showBulletIn, null, null);
|
|
}
|
|
public static void installSet(BaseFragment fragment, TLRPC.TL_messages_stickerSet set, boolean showBulletIn, Utilities.Callback<Boolean> onDone, Runnable onStickersLoaded) {
|
|
if (set == null || fragment == null) {
|
|
return;
|
|
}
|
|
if (MediaDataController.getInstance(fragment.getCurrentAccount()).cancelRemovingStickerSet(set.set.id)) {
|
|
if (onDone != null) {
|
|
onDone.run(true);
|
|
}
|
|
return;
|
|
}
|
|
TLRPC.TL_messages_installStickerSet req = new TLRPC.TL_messages_installStickerSet();
|
|
req.stickerset = new TLRPC.TL_inputStickerSetID();
|
|
req.stickerset.id = set.set.id;
|
|
req.stickerset.access_hash = set.set.access_hash;
|
|
ConnectionsManager.getInstance(fragment.getCurrentAccount()).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
int type = MediaDataController.TYPE_IMAGE;
|
|
if (set.set.masks) {
|
|
type = MediaDataController.TYPE_MASK;
|
|
} else if (set.set.emojis) {
|
|
type = MediaDataController.TYPE_EMOJIPACKS;
|
|
};
|
|
try {
|
|
if (error == null) {
|
|
if (showBulletIn && fragment.getFragmentView() != null) {
|
|
Bulletin.make(fragment, new StickerSetBulletinLayout(fragment.getFragmentView().getContext(), set, StickerSetBulletinLayout.TYPE_ADDED, null, fragment.getResourceProvider()), Bulletin.DURATION_SHORT).show();
|
|
}
|
|
if (response instanceof TLRPC.TL_messages_stickerSetInstallResultArchive) {
|
|
MediaDataController.getInstance(fragment.getCurrentAccount()).processStickerSetInstallResultArchive(fragment, true, type, (TLRPC.TL_messages_stickerSetInstallResultArchive) response);
|
|
}
|
|
if (onDone != null) {
|
|
onDone.run(true);
|
|
}
|
|
} else if (fragment.getFragmentView() != null) {
|
|
Toast.makeText(fragment.getFragmentView().getContext(), LocaleController.getString("ErrorOccurred", R.string.ErrorOccurred), Toast.LENGTH_SHORT).show();
|
|
if (onDone != null) {
|
|
onDone.run(false);
|
|
}
|
|
} else {
|
|
if (onDone != null) {
|
|
onDone.run(false);
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
MediaDataController.getInstance(fragment.getCurrentAccount()).loadStickers(type, false, true, false, p -> {
|
|
if (onStickersLoaded != null) {
|
|
onStickersLoaded.run();
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
|
|
public static void uninstallSet(BaseFragment fragment, TLRPC.TL_messages_stickerSet set, boolean showBulletin, Runnable onUndo) {
|
|
if (fragment == null || set == null || fragment.getFragmentView() == null) {
|
|
return;
|
|
}
|
|
// set.set.official ? 1 : 0
|
|
MediaDataController.getInstance(fragment.getCurrentAccount()).toggleStickerSet(fragment.getFragmentView().getContext(), set, 0, fragment, true, showBulletin, onUndo);
|
|
}
|
|
|
|
private ValueAnimator loadAnimator;
|
|
private void loadAnimation() {
|
|
if (loadAnimator != null) {
|
|
return;
|
|
}
|
|
loadAnimator = ValueAnimator.ofFloat(loadT, 1);
|
|
fromY = lastY + containerView.getY();
|
|
loadAnimator.addUpdateListener(a -> {
|
|
loadT = (float) a.getAnimatedValue();
|
|
listView.setAlpha(loadT);
|
|
addButtonView.setAlpha(loadT);
|
|
removeButtonView.setAlpha(loadT);
|
|
containerView.invalidate();
|
|
});
|
|
loadAnimator.setDuration(250);
|
|
loadAnimator.setInterpolator(CubicBezierInterpolator.EASE_OUT_QUINT);
|
|
loadAnimator.start();
|
|
}
|
|
|
|
boolean first = false;
|
|
boolean loaded = true;
|
|
private void updateButton() {
|
|
if (buttonsView == null) {
|
|
return;
|
|
}
|
|
|
|
ArrayList<TLRPC.TL_messages_stickerSet> allPacks = customEmojiPacks.stickerSets == null ? new ArrayList<>() : new ArrayList<>(customEmojiPacks.stickerSets);
|
|
for (int i = 0; i < allPacks.size(); ++i) {
|
|
if (allPacks.get(i) == null) {
|
|
allPacks.remove(i--);
|
|
}
|
|
}
|
|
MediaDataController mediaDataController = MediaDataController.getInstance(currentAccount);
|
|
ArrayList<TLRPC.TL_messages_stickerSet> installedPacks = new ArrayList<>();
|
|
ArrayList<TLRPC.TL_messages_stickerSet> notInstalledPacks = new ArrayList<>();
|
|
for (int i = 0; i < allPacks.size(); ++i) {
|
|
TLRPC.TL_messages_stickerSet stickerSet = allPacks.get(i);
|
|
if (stickerSet != null && stickerSet.set != null) {
|
|
if (!mediaDataController.isStickerPackInstalled(stickerSet.set.id)) {
|
|
notInstalledPacks.add(stickerSet);
|
|
} else {
|
|
installedPacks.add(stickerSet);
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean mePremium = UserConfig.getInstance(currentAccount).isPremium();
|
|
ArrayList<TLRPC.TL_messages_stickerSet> canInstallPacks = new ArrayList<>(notInstalledPacks);
|
|
for (int i = 0; i < canInstallPacks.size(); ++i) {
|
|
if (MessageObject.isPremiumEmojiPack(canInstallPacks.get(i)) && !mePremium) {
|
|
canInstallPacks.remove(i--);
|
|
}
|
|
}
|
|
|
|
boolean loadedNow = customEmojiPacks.inputStickerSets != null && allPacks.size() == customEmojiPacks.inputStickerSets.size();
|
|
if (!loaded && loadedNow) {
|
|
loadAnimation();
|
|
}
|
|
loaded = loadedNow;
|
|
if (!loaded) {
|
|
listView.setAlpha(0);
|
|
}
|
|
|
|
if (canInstallPacks.size() <= 0 && notInstalledPacks.size() >= 0 && !mePremium || !loaded) {
|
|
premiumButtonView.setVisibility(View.VISIBLE);
|
|
addButtonView.setVisibility(View.GONE);
|
|
removeButtonView.setVisibility(View.GONE);
|
|
updateShowButton(true, !first);
|
|
} else {
|
|
premiumButtonView.setVisibility(View.INVISIBLE);
|
|
if (canInstallPacks.size() > 0) {
|
|
addButtonView.setVisibility(View.VISIBLE);
|
|
removeButtonView.setVisibility(View.GONE);
|
|
if (canInstallPacks.size() == 1) {
|
|
addButtonView.setText(LocaleController.formatString("AddStickersCount", R.string.AddStickersCount, LocaleController.formatPluralString("EmojiCountButton", canInstallPacks.get(0).documents.size())));
|
|
} else {
|
|
addButtonView.setText(LocaleController.formatString("AddStickersCount", R.string.AddStickersCount, LocaleController.formatPluralString("EmojiPackCount", canInstallPacks.size())));
|
|
}
|
|
addButtonView.setOnClickListener(ev -> {
|
|
final int count = canInstallPacks.size();
|
|
final int[] status = new int[2];
|
|
for (int i = 0; i < canInstallPacks.size(); ++i) {
|
|
installSet(fragment, canInstallPacks.get(i), count == 1, count > 1 ?
|
|
result -> {
|
|
status[0]++;
|
|
if (result) {
|
|
status[1]++;
|
|
}
|
|
if (status[0] == count && status[1] > 0) {
|
|
dismiss();
|
|
Bulletin.make(fragment, new StickerSetBulletinLayout(fragment.getFragmentView().getContext(), canInstallPacks.get(0), status[1], StickerSetBulletinLayout.TYPE_ADDED,null, fragment.getResourceProvider()), Bulletin.DURATION_SHORT).show();
|
|
}
|
|
} : null,
|
|
null
|
|
);
|
|
}
|
|
onButtonClicked(true);
|
|
if (count <= 1) {
|
|
dismiss();
|
|
}
|
|
});
|
|
updateShowButton(true, !first);
|
|
} else if (installedPacks.size() > 0) {
|
|
addButtonView.setVisibility(View.GONE);
|
|
removeButtonView.setVisibility(View.VISIBLE);
|
|
if (installedPacks.size() == 1) {
|
|
removeButtonView.setText(LocaleController.formatString("RemoveStickersCount", R.string.RemoveStickersCount, LocaleController.formatPluralString("EmojiCountButton", installedPacks.get(0).documents.size())));
|
|
} else {
|
|
removeButtonView.setText(LocaleController.formatString("RemoveStickersCount", R.string.RemoveStickersCount, LocaleController.formatPluralString("EmojiPackCount", installedPacks.size())));
|
|
}
|
|
|
|
removeButtonView.setOnClickListener(ev -> {
|
|
dismiss();
|
|
if (fragment != null) {
|
|
MediaDataController.getInstance(fragment.getCurrentAccount()).removeMultipleStickerSets(fragment.getFragmentView().getContext(), fragment, installedPacks);
|
|
} else {
|
|
for (int i = 0; i < installedPacks.size(); ++i) {
|
|
TLRPC.TL_messages_stickerSet stickerSet = installedPacks.get(i);
|
|
uninstallSet(fragment, stickerSet, i == 0, null);
|
|
}
|
|
}
|
|
onButtonClicked(false);
|
|
});
|
|
updateShowButton(true, !first);
|
|
} else {
|
|
addButtonView.setVisibility(View.GONE);
|
|
removeButtonView.setVisibility(View.GONE);
|
|
updateShowButton(false, !first);
|
|
}
|
|
}
|
|
first = false;
|
|
}
|
|
|
|
private int getListTop() {
|
|
if (containerView == null) {
|
|
return 0;
|
|
}
|
|
if (listView == null || listView.getChildCount() < 1) {
|
|
return containerView.getPaddingTop();
|
|
}
|
|
View view = listView.getChildAt(0);
|
|
if (view != paddingView) {
|
|
return containerView.getPaddingTop();
|
|
}
|
|
return paddingView.getBottom() + containerView.getPaddingTop();
|
|
}
|
|
|
|
@Override
|
|
public void show() {
|
|
super.show();
|
|
NotificationCenter.getGlobalInstance().postNotificationName(NotificationCenter.stopAllHeavyOperations, 4);
|
|
}
|
|
|
|
@Override
|
|
public void dismiss() {
|
|
super.dismiss();
|
|
NotificationCenter.getGlobalInstance().postNotificationName(NotificationCenter.startAllHeavyOperations, 4);
|
|
}
|
|
|
|
@Override
|
|
public int getContainerViewHeight() {
|
|
return (listView == null ? 0 : listView.getMeasuredHeight()) - getListTop() + (containerView == null ? 0 : containerView.getPaddingTop()) + AndroidUtilities.navigationBarHeight + AndroidUtilities.dp(8);
|
|
}
|
|
|
|
class SeparatorView extends View {
|
|
public SeparatorView(Context context) {
|
|
super(context);
|
|
setBackgroundColor(getThemedColor(Theme.key_chat_emojiPanelShadowLine));
|
|
RecyclerView.LayoutParams params = new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, AndroidUtilities.getShadowHeight());
|
|
params.topMargin = AndroidUtilities.dp(14);
|
|
setLayoutParams(params);
|
|
}
|
|
}
|
|
|
|
private class Adapter extends RecyclerView.Adapter {
|
|
|
|
@NonNull
|
|
@Override
|
|
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
|
|
View view = null;
|
|
if (viewType == 0) {
|
|
view = paddingView;
|
|
} else if (viewType == 1) {
|
|
view = new EmojiImageView(getContext());
|
|
} else if (viewType == 2) {
|
|
view = new EmojiPackHeader(getContext(), customEmojiPacks.data.length <= 1);
|
|
} else if (viewType == 3) {
|
|
view = new TextView(getContext());
|
|
} else if (viewType == 4) {
|
|
view = new SeparatorView(getContext());
|
|
}
|
|
return new RecyclerListView.Holder(view);
|
|
}
|
|
|
|
@Override
|
|
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
|
|
position--;
|
|
switch (holder.getItemViewType()) {
|
|
case 3:
|
|
TextView textView = (TextView) holder.itemView;
|
|
textView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 13);
|
|
textView.setTextColor(getThemedColor(Theme.key_chat_emojiPanelTrendingDescription));
|
|
textView.setText(AndroidUtilities.replaceTags(LocaleController.getString("PremiumPreviewEmojiPack", R.string.PremiumPreviewEmojiPack)));
|
|
textView.setPadding(AndroidUtilities.dp(14), 0, AndroidUtilities.dp(30), AndroidUtilities.dp(14));
|
|
break;
|
|
case 1:
|
|
if (hasDescription) {
|
|
position--;
|
|
}
|
|
EmojiImageView view = (EmojiImageView) holder.itemView;
|
|
EmojiView.CustomEmoji customEmoji = null;
|
|
for (int i = 0, j = 0; i < customEmojiPacks.data.length; ++i) {
|
|
int size = customEmojiPacks.data[i].size();
|
|
if (customEmojiPacks.data.length > 1) {
|
|
size = Math.min(gridLayoutManager.getSpanCount() * 2, size);
|
|
}
|
|
if (position > j && position <= j + size) {
|
|
customEmoji = customEmojiPacks.data[i].get(position - j - 1);
|
|
break;
|
|
}
|
|
j += 1 + size + 1;
|
|
}
|
|
if (view.span == null && customEmoji != null || customEmoji == null && view.span != null || customEmoji != null && view.span.documentId != customEmoji.documentId) {
|
|
if (customEmoji == null) {
|
|
view.span = null;
|
|
} else {
|
|
TLRPC.TL_inputStickerSetID inputStickerSet = new TLRPC.TL_inputStickerSetID();
|
|
inputStickerSet.id = customEmoji.stickerSet.set.id;
|
|
inputStickerSet.short_name = customEmoji.stickerSet.set.short_name;
|
|
inputStickerSet.access_hash = customEmoji.stickerSet.set.access_hash;
|
|
view.span = new AnimatedEmojiSpan(customEmoji.documentId, null);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
if (hasDescription && position > 0) {
|
|
position--;
|
|
}
|
|
int i = 0;
|
|
for (int j = 0; i < customEmojiPacks.data.length; ++i) {
|
|
int sz = customEmojiPacks.data[i].size();
|
|
if (customEmojiPacks.data.length > 1) {
|
|
sz = Math.min(gridLayoutManager.getSpanCount() * 2, sz);
|
|
}
|
|
if (position == j) {
|
|
break;
|
|
}
|
|
j += 1 + sz + 1;
|
|
}
|
|
TLRPC.TL_messages_stickerSet stickerSet = customEmojiPacks.stickerSets == null || i >= customEmojiPacks.stickerSets.size() ? null : customEmojiPacks.stickerSets.get(i);
|
|
boolean premium = false;
|
|
if (stickerSet != null && stickerSet.documents != null) {
|
|
for (int j = 0; j < stickerSet.documents.size(); ++j) {
|
|
if (!MessageObject.isFreeEmoji(stickerSet.documents.get(j))) {
|
|
premium = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (i < customEmojiPacks.data.length) {
|
|
((EmojiPackHeader) holder.itemView).set(stickerSet, stickerSet == null || stickerSet.documents == null ? 0 : stickerSet.documents.size(), premium);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getItemViewType(int position) {
|
|
if (position == 0) {
|
|
return 0;
|
|
}
|
|
position--;
|
|
if (hasDescription) {
|
|
if (position == 1) {
|
|
return 3;
|
|
} else if (position > 0) {
|
|
position--;
|
|
}
|
|
}
|
|
for (int i = 0, j = 0; i < customEmojiPacks.data.length; ++i) {
|
|
if (position == j) {
|
|
return 2;
|
|
}
|
|
int count = customEmojiPacks.data[i].size();
|
|
if (customEmojiPacks.data.length > 1) {
|
|
count = Math.min(gridLayoutManager.getSpanCount() * 2, count);
|
|
}
|
|
j += 1 + count;
|
|
if (position == j) {
|
|
return 4;
|
|
}
|
|
j++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public int getItemCount() {
|
|
hasDescription = !UserConfig.getInstance(currentAccount).isPremium() && customEmojiPacks.stickerSets != null && customEmojiPacks.stickerSets.size() == 1 && MessageObject.isPremiumEmojiPack(customEmojiPacks.stickerSets.get(0));
|
|
return 1 + (hasDescription ? 1 : 0) + customEmojiPacks.getItemsCount() + Math.max(0, customEmojiPacks.data.length - 1);
|
|
}
|
|
}
|
|
|
|
private void onSubItemClick(int id) {
|
|
if (customEmojiPacks == null || customEmojiPacks.stickerSets == null || customEmojiPacks.stickerSets.isEmpty()) {
|
|
return;
|
|
}
|
|
TLRPC.TL_messages_stickerSet stickerSet = customEmojiPacks.stickerSets.get(0);
|
|
String stickersUrl;
|
|
if (stickerSet.set != null && stickerSet.set.emojis) {
|
|
stickersUrl = "https://" + MessagesController.getInstance(currentAccount).linkPrefix + "/addemoji/" + stickerSet.set.short_name;
|
|
} else {
|
|
stickersUrl = "https://" + MessagesController.getInstance(currentAccount).linkPrefix + "/addstickers/" + stickerSet.set.short_name;
|
|
}
|
|
if (id == 1) {
|
|
Context context = null;
|
|
if (fragment != null) {
|
|
context = fragment.getParentActivity();
|
|
}
|
|
if (context == null) {
|
|
context = getContext();
|
|
}
|
|
ShareAlert alert = new ShareAlert(context, null, stickersUrl, false, stickersUrl, false, resourcesProvider) {
|
|
@Override
|
|
protected void onSend(androidx.collection.LongSparseArray<TLRPC.Dialog> dids, int count) {
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
UndoView undoView;
|
|
if (fragment instanceof ChatActivity) {
|
|
undoView = ((ChatActivity) fragment).getUndoView();
|
|
} else if (fragment instanceof ProfileActivity) {
|
|
undoView = ((ProfileActivity) fragment).getUndoView();
|
|
} else {
|
|
undoView = null;
|
|
}
|
|
if (undoView != null) {
|
|
if (dids.size() == 1) {
|
|
undoView.showWithAction(dids.valueAt(0).id, UndoView.ACTION_FWD_MESSAGES, count);
|
|
} else {
|
|
undoView.showWithAction(0, UndoView.ACTION_FWD_MESSAGES, count, dids.size(), null, null);
|
|
}
|
|
}
|
|
}, 100);
|
|
}
|
|
};
|
|
if (fragment != null) {
|
|
fragment.showDialog(alert);
|
|
} else {
|
|
alert.show();
|
|
}
|
|
} else if (id == 2) {
|
|
try {
|
|
AndroidUtilities.addToClipboard(stickersUrl);
|
|
BulletinFactory.of((FrameLayout) containerView, resourcesProvider).createCopyLinkBulletin().show();
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
}
|
|
private class EmojiImageView extends View {
|
|
public ImageReceiver.BackgroundThreadDrawHolder backgroundThreadDrawHolder;
|
|
public ImageReceiver imageReceiver;
|
|
|
|
public EmojiImageView(Context context) {
|
|
super(context);
|
|
}
|
|
|
|
public AnimatedEmojiSpan span;
|
|
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
setPadding(AndroidUtilities.dp(2), AndroidUtilities.dp(2), AndroidUtilities.dp(2), AndroidUtilities.dp(2));
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.EXACTLY));
|
|
}
|
|
}
|
|
|
|
private class EmojiPackHeader extends FrameLayout {
|
|
|
|
public TextView titleView;
|
|
public TextView subtitleView;
|
|
public TextView addButtonView;
|
|
public TextView removeButtonView;
|
|
public PremiumButtonView unlockButtonView;
|
|
public ActionBarMenuItem optionsButton;
|
|
|
|
private boolean single;
|
|
|
|
public BaseFragment dummyFragment = new BaseFragment() {
|
|
@Override
|
|
public int getCurrentAccount() {
|
|
return currentAccount;
|
|
}
|
|
|
|
@Override
|
|
public View getFragmentView() {
|
|
return EmojiPacksAlert.this.containerView;
|
|
}
|
|
|
|
@Override
|
|
public FrameLayout getLayoutContainer() {
|
|
return (FrameLayout) EmojiPacksAlert.this.containerView;
|
|
}
|
|
|
|
@Override
|
|
public Theme.ResourcesProvider getResourceProvider() {
|
|
return resourcesProvider;
|
|
}
|
|
};
|
|
|
|
public EmojiPackHeader(Context context, boolean single) {
|
|
super(context);
|
|
|
|
this.single = single;
|
|
|
|
float endMarginDp = 8;
|
|
if (!single) {
|
|
if (!UserConfig.getInstance(currentAccount).isPremium()) {
|
|
unlockButtonView = new PremiumButtonView(context, AndroidUtilities.dp(4), false);
|
|
unlockButtonView.setButton(LocaleController.getString("Unlock", R.string.Unlock), ev -> {
|
|
premiumButtonClicked = SystemClock.elapsedRealtime();
|
|
showPremiumAlert();
|
|
});
|
|
unlockButtonView.setIcon(R.raw.unlock_icon);
|
|
|
|
MarginLayoutParams iconLayout = (MarginLayoutParams) unlockButtonView.getIconView().getLayoutParams();
|
|
iconLayout.leftMargin = AndroidUtilities.dp(1);
|
|
iconLayout.topMargin = AndroidUtilities.dp(1);
|
|
iconLayout.width = iconLayout.height = AndroidUtilities.dp(20);
|
|
MarginLayoutParams layout = (MarginLayoutParams) unlockButtonView.getTextView().getLayoutParams();
|
|
layout.leftMargin = AndroidUtilities.dp(3);
|
|
unlockButtonView.getChildAt(0).setPadding(AndroidUtilities.dp(8), 0, AndroidUtilities.dp(8), 0);
|
|
|
|
addView(unlockButtonView, LayoutHelper.createFrameRelatively(LayoutHelper.WRAP_CONTENT, 28, Gravity.END | Gravity.TOP, 0, 15.66f, 5.66f, 0));
|
|
|
|
unlockButtonView.measure(MeasureSpec.makeMeasureSpec(99999, MeasureSpec.AT_MOST), MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(28), MeasureSpec.EXACTLY));
|
|
endMarginDp = (unlockButtonView.getMeasuredWidth() + AndroidUtilities.dp(8 + 8)) / AndroidUtilities.density;
|
|
}
|
|
|
|
addButtonView = new TextView(context);
|
|
addButtonView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
addButtonView.setTextColor(getThemedColor(Theme.key_featuredStickers_buttonText));
|
|
addButtonView.setBackground(Theme.AdaptiveRipple.filledRect(getThemedColor(Theme.key_featuredStickers_addButton), 4));
|
|
addButtonView.setText(LocaleController.getString("Add", R.string.Add));
|
|
addButtonView.setPadding(AndroidUtilities.dp(18), 0, AndroidUtilities.dp(18), 0);
|
|
addButtonView.setGravity(Gravity.CENTER);
|
|
addButtonView.setOnClickListener(e -> {
|
|
installSet(dummyFragment, set, true);
|
|
toggle(true, true);
|
|
});
|
|
addView(addButtonView, LayoutHelper.createFrameRelatively(LayoutHelper.WRAP_CONTENT, 28, Gravity.END | Gravity.TOP, 0, 15.66f, 5.66f, 0));
|
|
|
|
addButtonView.measure(MeasureSpec.makeMeasureSpec(99999, MeasureSpec.AT_MOST), MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(28), MeasureSpec.EXACTLY));
|
|
endMarginDp = Math.max(endMarginDp, (addButtonView.getMeasuredWidth() + AndroidUtilities.dp(8 + 8)) / AndroidUtilities.density);
|
|
|
|
removeButtonView = new TextView(context);
|
|
removeButtonView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
removeButtonView.setTextColor(getThemedColor(Theme.key_featuredStickers_addButton));
|
|
removeButtonView.setBackground(Theme.createRadSelectorDrawable(0x0fffffff & getThemedColor(Theme.key_featuredStickers_addButton), 4, 4));
|
|
removeButtonView.setText(LocaleController.getString("StickersRemove", R.string.StickersRemove));
|
|
removeButtonView.setPadding(AndroidUtilities.dp(12), 0, AndroidUtilities.dp(12), 0);
|
|
removeButtonView.setGravity(Gravity.CENTER);
|
|
removeButtonView.setOnClickListener(e -> {
|
|
uninstallSet(dummyFragment, set, true, () -> {
|
|
toggle(true, true);
|
|
});
|
|
toggle(false, true);
|
|
});
|
|
removeButtonView.setClickable(false);
|
|
addView(removeButtonView, LayoutHelper.createFrameRelatively(LayoutHelper.WRAP_CONTENT, 28, Gravity.END | Gravity.TOP, 0, 15.66f, 5.66f, 0));
|
|
|
|
removeButtonView.setScaleX(0);
|
|
removeButtonView.setScaleY(0);
|
|
removeButtonView.setAlpha(0);
|
|
|
|
removeButtonView.measure(MeasureSpec.makeMeasureSpec(99999, MeasureSpec.AT_MOST), MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(28), MeasureSpec.EXACTLY));
|
|
endMarginDp = Math.max(endMarginDp, (removeButtonView.getMeasuredWidth() + AndroidUtilities.dp(8 + 8)) / AndroidUtilities.density);
|
|
}
|
|
|
|
titleView = new TextView(context);
|
|
titleView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleView.setEllipsize(TextUtils.TruncateAt.END);
|
|
titleView.setSingleLine(true);
|
|
titleView.setLines(1);
|
|
titleView.setTextColor(getThemedColor(Theme.key_dialogTextBlack));
|
|
if (single) {
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 20);
|
|
addView(titleView, LayoutHelper.createFrameRelatively(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.START | Gravity.TOP, 14, 11, endMarginDp, 0));
|
|
} else {
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 17);
|
|
addView(titleView, LayoutHelper.createFrameRelatively(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.START | Gravity.TOP, 8, 10, endMarginDp, 0));
|
|
}
|
|
|
|
if (!single) {
|
|
subtitleView = new TextView(context);
|
|
subtitleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 13);
|
|
subtitleView.setTextColor(getThemedColor(Theme.key_dialogTextGray2));
|
|
subtitleView.setEllipsize(TextUtils.TruncateAt.END);
|
|
subtitleView.setSingleLine(true);
|
|
subtitleView.setLines(1);
|
|
addView(subtitleView, LayoutHelper.createFrameRelatively(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.START | Gravity.TOP, 8, 31.66f, endMarginDp, 0));
|
|
}
|
|
|
|
if (single) {
|
|
optionsButton = new ActionBarMenuItem(context, null, 0, getThemedColor(Theme.key_sheet_other), resourcesProvider);
|
|
optionsButton.setLongClickEnabled(false);
|
|
optionsButton.setSubMenuOpenSide(2);
|
|
optionsButton.setIcon(R.drawable.ic_ab_other);
|
|
optionsButton.setBackgroundDrawable(Theme.createSelectorDrawable(getThemedColor(Theme.key_player_actionBarSelector), 1));
|
|
addView(optionsButton, LayoutHelper.createFrame(40, 40, Gravity.TOP | Gravity.RIGHT, 0, 5, 5 - backgroundPaddingLeft / AndroidUtilities.density, 0));
|
|
optionsButton.addSubItem(1, R.drawable.msg_share, LocaleController.getString("StickersShare", R.string.StickersShare));
|
|
optionsButton.addSubItem(2, R.drawable.msg_link, LocaleController.getString("CopyLink", R.string.CopyLink));
|
|
optionsButton.setOnClickListener(v -> optionsButton.toggleSubMenu());
|
|
optionsButton.setDelegate(EmojiPacksAlert.this::onSubItemClick);
|
|
optionsButton.setContentDescription(LocaleController.getString("AccDescrMoreOptions", R.string.AccDescrMoreOptions));
|
|
}
|
|
}
|
|
|
|
private TLRPC.TL_messages_stickerSet set;
|
|
private boolean toggled = false;
|
|
private float toggleT = 0;
|
|
private ValueAnimator animator;
|
|
private void toggle(boolean enable, boolean animated) {
|
|
if (toggled == enable) {
|
|
return;
|
|
}
|
|
toggled = enable;
|
|
|
|
if (animator != null) {
|
|
animator.cancel();
|
|
animator = null;
|
|
}
|
|
|
|
if (addButtonView == null || removeButtonView == null) {
|
|
return;
|
|
}
|
|
|
|
addButtonView.setClickable(!enable);
|
|
removeButtonView.setClickable(enable);
|
|
|
|
if (animated) {
|
|
animator = ValueAnimator.ofFloat(toggleT, enable ? 1f : 0f); // 1 - remove button, 0 - add button
|
|
animator.addUpdateListener(a -> {
|
|
toggleT = (float) a.getAnimatedValue();
|
|
addButtonView.setScaleX(1f - toggleT);
|
|
addButtonView.setScaleY(1f - toggleT);
|
|
addButtonView.setAlpha(1f - toggleT);
|
|
removeButtonView.setScaleX(toggleT);
|
|
removeButtonView.setScaleY(toggleT);
|
|
removeButtonView.setAlpha(toggleT);
|
|
});
|
|
animator.setInterpolator(CubicBezierInterpolator.EASE_OUT_QUINT);
|
|
animator.setDuration(250);
|
|
animator.start();
|
|
} else {
|
|
toggleT = enable ? 1 : 0;
|
|
addButtonView.setScaleX(enable ? 0 : 1);
|
|
addButtonView.setScaleY(enable ? 0 : 1);
|
|
addButtonView.setAlpha(enable ? 0 : 1);
|
|
removeButtonView.setScaleX(enable ? 1 : 0);
|
|
removeButtonView.setScaleY(enable ? 1 : 0);
|
|
removeButtonView.setAlpha(enable ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
public void set(TLRPC.TL_messages_stickerSet set, int size, boolean premium) {
|
|
this.set = set;
|
|
|
|
if (set != null && set.set != null) {
|
|
titleView.setText(set.set.title);
|
|
} else {
|
|
titleView.setText(null);
|
|
}
|
|
|
|
if (subtitleView != null) {
|
|
subtitleView.setText(LocaleController.formatPluralString("EmojiCount", size));
|
|
}
|
|
|
|
if (premium && unlockButtonView != null && !UserConfig.getInstance(currentAccount).isPremium()) {
|
|
unlockButtonView.setVisibility(VISIBLE);
|
|
if (addButtonView != null) {
|
|
addButtonView.setVisibility(GONE);
|
|
}
|
|
if (removeButtonView != null) {
|
|
removeButtonView.setVisibility(GONE);
|
|
}
|
|
} else {
|
|
if (unlockButtonView != null) {
|
|
unlockButtonView.setVisibility(GONE);
|
|
}
|
|
if (addButtonView != null) {
|
|
addButtonView.setVisibility(VISIBLE);
|
|
}
|
|
if (removeButtonView != null) {
|
|
removeButtonView.setVisibility(VISIBLE);
|
|
}
|
|
|
|
toggle(set != null && MediaDataController.getInstance(currentAccount).isStickerPackInstalled(set.set.id), false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(single ? 42 : 56), MeasureSpec.EXACTLY));
|
|
}
|
|
}
|
|
|
|
class EmojiPacksLoader implements NotificationCenter.NotificationCenterDelegate {
|
|
final int loadingStickersCount = 12;
|
|
|
|
public ArrayList<TLRPC.InputStickerSet> inputStickerSets;
|
|
public ArrayList<TLRPC.TL_messages_stickerSet> stickerSets;
|
|
public ArrayList<EmojiView.CustomEmoji>[] data;
|
|
private int currentAccount;
|
|
|
|
public EmojiPacksLoader(int currentAccount, ArrayList<TLRPC.InputStickerSet> inputStickerSets) {
|
|
this.currentAccount = currentAccount;
|
|
if (inputStickerSets == null) {
|
|
inputStickerSets = new ArrayList<>();
|
|
}
|
|
this.inputStickerSets = inputStickerSets;
|
|
init();
|
|
}
|
|
|
|
private void init() {
|
|
stickerSets = new ArrayList<>(inputStickerSets.size());
|
|
data = new ArrayList[inputStickerSets.size()];
|
|
NotificationCenter.getInstance(currentAccount).addObserver(this, NotificationCenter.groupStickersDidLoad);
|
|
final boolean[] failed = new boolean[1];
|
|
for (int i = 0; i < data.length; ++i) {
|
|
TLRPC.TL_messages_stickerSet stickerSet = MediaDataController.getInstance(currentAccount).getStickerSet(inputStickerSets.get(i), false, () -> {
|
|
if (!failed[0]) {
|
|
failed[0] = true;
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
dismiss();
|
|
BulletinFactory.of(fragment).createErrorBulletin(LocaleController.getString("AddEmojiNotFound", R.string.AddEmojiNotFound)).show();
|
|
});
|
|
}
|
|
});
|
|
if (data.length == 1 && stickerSet != null && stickerSet.set != null && !stickerSet.set.emojis) {
|
|
AndroidUtilities.runOnUIThread(() -> EmojiPacksAlert.this.dismiss());
|
|
StickersAlert alert = new StickersAlert(getContext(), fragment, inputStickerSets.get(i), null, fragment instanceof ChatActivity ? ((ChatActivity) fragment).getChatActivityEnterView() : null, resourcesProvider);
|
|
alert.show();
|
|
return;
|
|
}
|
|
stickerSets.add(stickerSet);
|
|
putStickerSet(i, stickerSet);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void didReceivedNotification(int id, int account, Object... args) {
|
|
if (id == NotificationCenter.groupStickersDidLoad) {
|
|
for (int i = 0; i < stickerSets.size(); ++i) {
|
|
if (stickerSets.get(i) == null) {
|
|
TLRPC.TL_messages_stickerSet stickerSet = MediaDataController.getInstance(currentAccount).getStickerSet(this.inputStickerSets.get(i), true);
|
|
if (stickerSets.size() == 1 && stickerSet != null && stickerSet.set != null && !stickerSet.set.emojis) {
|
|
EmojiPacksAlert.this.dismiss();
|
|
StickersAlert alert = new StickersAlert(getContext(), fragment, inputStickerSets.get(i), null, fragment instanceof ChatActivity ? ((ChatActivity) fragment).getChatActivityEnterView() : null, resourcesProvider);
|
|
alert.show();
|
|
return;
|
|
}
|
|
stickerSets.set(i, stickerSet);
|
|
if (stickerSet != null) {
|
|
putStickerSet(i, stickerSet);
|
|
}
|
|
}
|
|
}
|
|
onUpdate();
|
|
}
|
|
}
|
|
|
|
private void putStickerSet(int index, TLRPC.TL_messages_stickerSet stickerSet) {
|
|
if (index < 0 || index >= data.length) {
|
|
return;
|
|
}
|
|
if (stickerSet == null || stickerSet.documents == null) {
|
|
data[index] = new ArrayList<>(loadingStickersCount);
|
|
for (int j = 0; j < loadingStickersCount; ++j) {
|
|
data[index].add(null);
|
|
}
|
|
} else {
|
|
data[index] = new ArrayList<>();
|
|
for (int j = 0; j < stickerSet.documents.size(); ++j) {
|
|
TLRPC.Document document = stickerSet.documents.get(j);
|
|
if (document == null) {
|
|
data[index].add(null);
|
|
} else {
|
|
EmojiView.CustomEmoji customEmoji = new EmojiView.CustomEmoji();
|
|
customEmoji.emoticon = findEmoticon(stickerSet, document.id);
|
|
customEmoji.stickerSet = stickerSet;
|
|
customEmoji.documentId = document.id;
|
|
data[index].add(customEmoji);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void recycle() {
|
|
NotificationCenter.getInstance(currentAccount).removeObserver(this, NotificationCenter.groupStickersDidLoad);
|
|
}
|
|
|
|
public String getTitle(int index) {
|
|
if (index < 0 || index >= stickerSets.size()) {
|
|
return null;
|
|
}
|
|
TLRPC.TL_messages_stickerSet stickerSet = stickerSets.get(index);
|
|
if (stickerSet == null || stickerSet.set == null) {
|
|
return null;
|
|
}
|
|
return stickerSet.set.title;
|
|
}
|
|
|
|
protected void onUpdate() {
|
|
|
|
}
|
|
|
|
public int getItemsCount() {
|
|
if (data == null) {
|
|
return 0;
|
|
}
|
|
int count = 0;
|
|
for (int i = 0; i < data.length; ++i) {
|
|
if (data[i] == null) {
|
|
continue;
|
|
}
|
|
if (data.length == 1) {
|
|
count += data[i].size();
|
|
} else {
|
|
count += Math.min(gridLayoutManager.getSpanCount() * 2, data[i].size());
|
|
}
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public String findEmoticon(long documentId) {
|
|
String emoticon;
|
|
for (int i = 0; i < stickerSets.size(); ++i) {
|
|
emoticon = findEmoticon(stickerSets.get(i), documentId);
|
|
if (emoticon != null) {
|
|
return emoticon;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String findEmoticon(TLRPC.InputStickerSet inputStickerSet, long documentId) {
|
|
if (inputStickerSet == null) {
|
|
return null;
|
|
}
|
|
TLRPC.TL_messages_stickerSet stickerSet = null;
|
|
for (int i = 0; i < stickerSets.size(); ++i) {
|
|
TLRPC.TL_messages_stickerSet s = stickerSets.get(i);
|
|
if (s != null && s.set != null && (inputStickerSet.id == s.set.id || inputStickerSet.short_name != null && inputStickerSet.short_name.equals(s.set.short_name))) {
|
|
stickerSet = s;
|
|
break;
|
|
}
|
|
}
|
|
return findEmoticon(stickerSet, documentId);
|
|
}
|
|
|
|
public String findEmoticon(TLRPC.TL_messages_stickerSet stickerSet, long documentId) {
|
|
if (stickerSet == null) {
|
|
return null;
|
|
}
|
|
for (int o = 0; o < stickerSet.packs.size(); ++o) {
|
|
TLRPC.TL_stickerPack pack = stickerSet.packs.get(o);
|
|
if (pack.documents != null && pack.documents.contains(documentId)) {
|
|
return pack.emoticon;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
} |