mirror of https://github.com/NekoX-Dev/NekoX.git
6538 lines
331 KiB
Java
6538 lines
331 KiB
Java
/*
|
|
* This is the source code of Telegram for Android v. 5.x.x.
|
|
* It is licensed under GNU GPL v. 2 or later.
|
|
* You should have received a copy of the license in this archive (see LICENSE).
|
|
*
|
|
* Copyright Nikolai Kudashov, 2013-2018.
|
|
*/
|
|
|
|
package org.telegram.ui;
|
|
|
|
import android.Manifest;
|
|
import android.animation.Animator;
|
|
import android.animation.AnimatorListenerAdapter;
|
|
import android.animation.AnimatorSet;
|
|
import android.animation.ObjectAnimator;
|
|
import android.animation.StateListAnimator;
|
|
import android.animation.ValueAnimator;
|
|
import android.annotation.SuppressLint;
|
|
import android.app.Activity;
|
|
import android.app.Dialog;
|
|
import android.content.ActivityNotFoundException;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.res.Configuration;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Outline;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Path;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.PorterDuffColorFilter;
|
|
import android.graphics.Rect;
|
|
import android.graphics.RectF;
|
|
import android.graphics.Typeface;
|
|
import android.graphics.drawable.BitmapDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.telephony.PhoneNumberUtils;
|
|
//import android.telephony.TelephonyManager;
|
|
import android.text.Editable;
|
|
import android.text.InputType;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.Spanned;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.TextWatcher;
|
|
import android.text.method.PasswordTransformationMethod;
|
|
import android.text.style.ClickableSpan;
|
|
import android.text.style.ReplacementSpan;
|
|
import android.util.Base64;
|
|
import android.util.TypedValue;
|
|
import android.view.Gravity;
|
|
import android.view.HapticFeedbackConstants;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewOutlineProvider;
|
|
import android.view.animation.AccelerateDecelerateInterpolator;
|
|
import android.view.animation.Animation;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.view.animation.Interpolator;
|
|
import android.view.inputmethod.EditorInfo;
|
|
import android.widget.AdapterView;
|
|
import android.widget.EditText;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.ImageView;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.ScrollView;
|
|
import android.widget.Space;
|
|
import android.widget.TextView;
|
|
import android.widget.ViewSwitcher;
|
|
|
|
import androidx.annotation.IntDef;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.core.graphics.ColorUtils;
|
|
|
|
import org.telegram.PhoneFormat.PhoneFormat;
|
|
import org.telegram.messenger.AccountInstance;
|
|
import org.telegram.messenger.AndroidUtilities;
|
|
import org.telegram.messenger.ApplicationLoader;
|
|
import org.telegram.messenger.BuildVars;
|
|
import org.telegram.messenger.ContactsController;
|
|
import org.telegram.messenger.Emoji;
|
|
import org.telegram.messenger.FileLog;
|
|
import org.telegram.messenger.ImageLocation;
|
|
import org.telegram.messenger.LocaleController;
|
|
import org.telegram.messenger.MediaDataController;
|
|
import org.telegram.messenger.MessageObject;
|
|
import org.telegram.messenger.MessagesController;
|
|
import org.telegram.messenger.MessagesStorage;
|
|
import org.telegram.messenger.NotificationCenter;
|
|
import org.telegram.messenger.R;
|
|
import org.telegram.messenger.SRPHelper;
|
|
import org.telegram.messenger.SharedConfig;
|
|
import org.telegram.messenger.UserConfig;
|
|
import org.telegram.messenger.Utilities;
|
|
import org.telegram.tgnet.ConnectionsManager;
|
|
import org.telegram.tgnet.RequestDelegate;
|
|
import org.telegram.tgnet.SerializedData;
|
|
import org.telegram.tgnet.TLRPC;
|
|
import org.telegram.ui.ActionBar.ActionBar;
|
|
import org.telegram.ui.ActionBar.ActionBarMenu;
|
|
import org.telegram.ui.ActionBar.ActionBarMenuItem;
|
|
import org.telegram.ui.ActionBar.AlertDialog;
|
|
import org.telegram.ui.ActionBar.BaseFragment;
|
|
import org.telegram.ui.ActionBar.Theme;
|
|
import org.telegram.ui.ActionBar.ThemeDescription;
|
|
import org.telegram.ui.Cells.CheckBoxCell;
|
|
import org.telegram.ui.Components.AlertsCreator;
|
|
import org.telegram.ui.Components.AnimatedPhoneNumberEditText;
|
|
import org.telegram.ui.Components.AvatarDrawable;
|
|
import org.telegram.ui.Components.BackupImageView;
|
|
import org.telegram.ui.Components.Bulletin;
|
|
import org.telegram.ui.Components.BulletinFactory;
|
|
import org.telegram.ui.Components.CombinedDrawable;
|
|
import org.telegram.ui.Components.CubicBezierInterpolator;
|
|
import org.telegram.ui.Components.CustomPhoneKeyboardView;
|
|
import org.telegram.ui.Components.Easings;
|
|
import org.telegram.ui.Components.EditTextBoldCursor;
|
|
import org.telegram.ui.Components.ImageUpdater;
|
|
import org.telegram.ui.Components.LayoutHelper;
|
|
import org.telegram.ui.Components.OutlineTextContainerView;
|
|
import org.telegram.ui.Components.RLottieDrawable;
|
|
import org.telegram.ui.Components.RLottieImageView;
|
|
import org.telegram.ui.Components.RadialProgressView;
|
|
import org.telegram.ui.Components.SimpleThemeDescription;
|
|
import org.telegram.ui.Components.SizeNotifierFrameLayout;
|
|
import org.telegram.ui.Components.SlideView;
|
|
import org.telegram.ui.Components.TextStyleSpan;
|
|
import org.telegram.ui.Components.TextViewSwitcher;
|
|
import org.telegram.ui.Components.TransformableLoginButtonView;
|
|
import org.telegram.ui.Components.URLSpanNoUnderline;
|
|
import org.telegram.ui.Components.VerticalPositionAutoAnimator;
|
|
import org.telegram.ui.Components.spoilers.SpoilersTextView;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.InputStreamReader;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
import java.util.Timer;
|
|
import java.util.TimerTask;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
|
import tw.nekomimi.nekogram.NekoXConfig;
|
|
import tw.nekomimi.nekogram.ui.EditTextAutoFill;
|
|
import tw.nekomimi.nekogram.utils.AlertUtil;
|
|
import tw.nekomimi.nekogram.utils.ProxyUtil;
|
|
|
|
@SuppressLint("HardwareIds")
|
|
public class LoginActivity extends BaseFragment implements NotificationCenter.NotificationCenterDelegate {
|
|
private final static int SHOW_DELAY = SharedConfig.getDevicePerformanceClass() <= SharedConfig.PERFORMANCE_CLASS_AVERAGE ? 150 : 100;
|
|
|
|
public final static int AUTH_TYPE_MESSAGE = 1,
|
|
AUTH_TYPE_SMS = 2,
|
|
AUTH_TYPE_FLASH_CALL = 3,
|
|
AUTH_TYPE_CALL = 4,
|
|
AUTH_TYPE_MISSED_CALL = 11;
|
|
|
|
private final static int VIEW_PHONE_INPUT = 0,
|
|
VIEW_CODE_MESSAGE = 1,
|
|
VIEW_CODE_SMS = 2,
|
|
VIEW_CODE_FLASH_CALL = 3,
|
|
VIEW_CODE_CALL = 4,
|
|
VIEW_REGISTER = 5,
|
|
VIEW_PASSWORD = 6,
|
|
VIEW_RECOVER = 7,
|
|
VIEW_RESET_WAIT = 8,
|
|
VIEW_NEW_PASSWORD_STAGE_1 = 9,
|
|
VIEW_NEW_PASSWORD_STAGE_2 = 10,
|
|
VIEW_CODE_MISSED_CALL = 11;
|
|
|
|
private final static int COUNTRY_STATE_NOT_SET_OR_VALID = 0,
|
|
COUNTRY_STATE_EMPTY = 1,
|
|
COUNTRY_STATE_INVALID = 2;
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({
|
|
AUTH_TYPE_MESSAGE,
|
|
AUTH_TYPE_SMS,
|
|
AUTH_TYPE_FLASH_CALL,
|
|
AUTH_TYPE_CALL,
|
|
AUTH_TYPE_MISSED_CALL
|
|
})
|
|
public @interface AuthType {}
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({
|
|
VIEW_PHONE_INPUT,
|
|
VIEW_CODE_MESSAGE,
|
|
VIEW_CODE_SMS,
|
|
VIEW_CODE_FLASH_CALL,
|
|
VIEW_CODE_CALL,
|
|
VIEW_REGISTER,
|
|
VIEW_PASSWORD,
|
|
VIEW_RECOVER,
|
|
VIEW_RESET_WAIT,
|
|
VIEW_NEW_PASSWORD_STAGE_1,
|
|
VIEW_NEW_PASSWORD_STAGE_2,
|
|
VIEW_CODE_MISSED_CALL
|
|
})
|
|
private @interface ViewNumber {}
|
|
|
|
@IntDef({
|
|
COUNTRY_STATE_NOT_SET_OR_VALID,
|
|
COUNTRY_STATE_EMPTY,
|
|
COUNTRY_STATE_INVALID
|
|
})
|
|
private @interface CountryState {}
|
|
|
|
@ViewNumber
|
|
private int currentViewNum;
|
|
private SlideView[] views = new SlideView[12];
|
|
private CustomPhoneKeyboardView keyboardView;
|
|
|
|
private boolean restoringState;
|
|
|
|
private Dialog permissionsDialog;
|
|
private Dialog permissionsShowDialog;
|
|
private ArrayList<String> permissionsItems = new ArrayList<>();
|
|
private ArrayList<String> permissionsShowItems = new ArrayList<>();
|
|
private boolean checkPermissions = true;
|
|
private boolean checkShowPermissions = true;
|
|
private boolean newAccount;
|
|
private boolean syncContacts = false;
|
|
private boolean testBackend = false;
|
|
|
|
private boolean cancelAccountDeletionMode = false;
|
|
private String cancelDeletionPhone;
|
|
private Bundle cancelDeletionParams;
|
|
private TLRPC.TL_auth_sentCode cancelDeletionCode;
|
|
|
|
private int currentDoneType;
|
|
private AnimatorSet[] showDoneAnimation = new AnimatorSet[2];
|
|
private AnimatorSet doneItemAnimation;
|
|
private TransformableLoginButtonView floatingButtonIcon;
|
|
private FrameLayout floatingButtonContainer;
|
|
private VerticalPositionAutoAnimator floatingAutoAnimator;
|
|
private RadialProgressView floatingProgressView;
|
|
private int progressRequestId;
|
|
private boolean[] doneButtonVisible = new boolean[]{true, false};
|
|
|
|
private AlertDialog cancelDeleteProgressDialog;
|
|
|
|
private SizeNotifierFrameLayout sizeNotifierFrameLayout;
|
|
private Runnable keyboardHideCallback;
|
|
|
|
private ImageView backButtonView;
|
|
private RadialProgressView radialProgressView;
|
|
|
|
// Open animation stuff
|
|
private LinearLayout keyboardLinearLayout;
|
|
private FrameLayout slideViewsContainer;
|
|
private View introView;
|
|
private TextView startMessagingButton;
|
|
|
|
private boolean customKeyboardWasVisible = false;
|
|
|
|
private boolean isAnimatingIntro;
|
|
private Runnable animationFinishCallback;
|
|
|
|
private PhoneNumberConfirmView phoneNumberConfirmView;
|
|
|
|
private static final int DONE_TYPE_FLOATING = 0;
|
|
private static final int DONE_TYPE_ACTION = 1;
|
|
|
|
private final static int done_button = 1;
|
|
|
|
private boolean needRequestPermissions;
|
|
|
|
private boolean[] doneProgressVisible = new boolean[2];
|
|
private Runnable[] editDoneCallback = new Runnable[2];
|
|
private boolean[] postedEditDoneCallback = new boolean[2];
|
|
|
|
private static Map<String, PhoneNumberExclusionRule> phoneNumberExclusionRules = new HashMap<>();
|
|
|
|
// NekoX Definitions
|
|
|
|
ActionBarMenuItem menu = null;
|
|
|
|
private static final int menu_proxy = 2;
|
|
private static final int menu_language = 3;
|
|
private static final int menu_bot_login = 4;
|
|
private static final int menu_other = 5;
|
|
//private int menu_custom_api = 6;
|
|
// private int menu_custom_dc = 7;
|
|
private static final int menu_qr_login = 8;
|
|
|
|
TLRPC.TL_auth_exportLoginToken exportLoginTokenRequest = null;
|
|
AlertDialog exportLoginTokenProgress = null;
|
|
android.app.AlertDialog exportLoginTokenDialog = null;
|
|
|
|
|
|
static {
|
|
phoneNumberExclusionRules.put("60", hintLengthFrom -> --hintLengthFrom);
|
|
phoneNumberExclusionRules.put("372", hintLengthFrom -> --hintLengthFrom);
|
|
}
|
|
|
|
private static class ProgressView extends View {
|
|
|
|
private final Path path = new Path();
|
|
private final RectF rect = new RectF();
|
|
private final RectF boundsRect = new RectF();
|
|
private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
private final Paint paint2 = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
|
|
private long startTime;
|
|
private long duration;
|
|
private boolean animating;
|
|
|
|
private float radius;
|
|
|
|
public ProgressView(Context context) {
|
|
super(context);
|
|
paint.setColor(Theme.getColor(Theme.key_login_progressInner));
|
|
paint2.setColor(Theme.getColor(Theme.key_login_progressOuter));
|
|
}
|
|
|
|
public void startProgressAnimation(long duration) {
|
|
this.animating = true;
|
|
this.duration = duration;
|
|
this.startTime = System.currentTimeMillis();
|
|
invalidate();
|
|
}
|
|
|
|
public void resetProgressAnimation() {
|
|
duration = 0;
|
|
startTime = 0;
|
|
animating = false;
|
|
invalidate();
|
|
}
|
|
|
|
public boolean isProgressAnimationRunning() {
|
|
return animating;
|
|
}
|
|
|
|
@Override
|
|
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
|
|
path.rewind();
|
|
radius = h / 2f;
|
|
boundsRect.set(0, 0, w, h);
|
|
rect.set(boundsRect);
|
|
path.addRoundRect(boundsRect, radius, radius, Path.Direction.CW);
|
|
}
|
|
|
|
@Override
|
|
protected void onDraw(Canvas canvas) {
|
|
final float progress;
|
|
if (duration > 0) {
|
|
progress = Math.min(1f, (System.currentTimeMillis() - startTime) / (float) duration);
|
|
} else {
|
|
progress = 0f;
|
|
}
|
|
|
|
canvas.clipPath(path);
|
|
canvas.drawRoundRect(boundsRect, radius, radius, paint);
|
|
rect.right = boundsRect.right * progress;
|
|
canvas.drawRoundRect(rect, radius, radius, paint2);
|
|
|
|
if (animating &= duration > 0 && progress < 1f) {
|
|
postInvalidateOnAnimation();
|
|
}
|
|
}
|
|
}
|
|
|
|
public LoginActivity() {
|
|
super();
|
|
}
|
|
|
|
public LoginActivity(int account) {
|
|
super();
|
|
currentAccount = account;
|
|
newAccount = true;
|
|
}
|
|
|
|
public LoginActivity cancelAccountDeletion(String phone, Bundle params, TLRPC.TL_auth_sentCode sentCode) {
|
|
cancelDeletionPhone = phone;
|
|
cancelDeletionParams = params;
|
|
cancelDeletionCode = sentCode;
|
|
cancelAccountDeletionMode = true;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void onFragmentDestroy() {
|
|
super.onFragmentDestroy();
|
|
for (int a = 0; a < views.length; a++) {
|
|
if (views[a] != null) {
|
|
views[a].onDestroyActivity();
|
|
}
|
|
}
|
|
if (cancelDeleteProgressDialog != null) {
|
|
cancelDeleteProgressDialog.dismiss();
|
|
cancelDeleteProgressDialog = null;
|
|
}
|
|
for (Runnable callback : editDoneCallback) {
|
|
if (callback != null) {
|
|
AndroidUtilities.cancelRunOnUIThread(callback);
|
|
}
|
|
}
|
|
|
|
SharedConfig.loginingAccount = -1;
|
|
}
|
|
|
|
@Override
|
|
public View createView(Context context) {
|
|
actionBar.setAddToContainer(false);
|
|
actionBar.setActionBarMenuOnItemClick(new ActionBar.ActionBarMenuOnItemClick() {
|
|
@Override
|
|
public void onItemClick(int id) {
|
|
if (id == done_button) {
|
|
onDoneButtonPressed();
|
|
} else if (id == -1) {
|
|
if (onBackPressed()) {
|
|
finishFragment();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
currentDoneType = DONE_TYPE_FLOATING;
|
|
doneButtonVisible[DONE_TYPE_FLOATING] = true;
|
|
doneButtonVisible[DONE_TYPE_ACTION] = false;
|
|
|
|
sizeNotifierFrameLayout = new SizeNotifierFrameLayout(context) {
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
MarginLayoutParams marginLayoutParams = (MarginLayoutParams) floatingButtonContainer.getLayoutParams();
|
|
int keyboardOffset = isCustomKeyboardVisible() ? AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP) : 0;
|
|
if (isCustomKeyboardVisible() && measureKeyboardHeight() > AndroidUtilities.dp(20)) {
|
|
keyboardOffset -= measureKeyboardHeight();
|
|
}
|
|
if (Bulletin.getVisibleBulletin() != null && Bulletin.getVisibleBulletin().isShowing()) {
|
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
|
marginLayoutParams.bottomMargin = AndroidUtilities.dp(16) + Bulletin.getVisibleBulletin().getLayout().getMeasuredHeight() - AndroidUtilities.dp(10) + keyboardOffset;
|
|
} else {
|
|
marginLayoutParams.bottomMargin = AndroidUtilities.dp(16) + keyboardOffset;
|
|
}
|
|
|
|
int statusBarHeight = AndroidUtilities.isTablet() ? 0 : AndroidUtilities.statusBarHeight;
|
|
marginLayoutParams = (MarginLayoutParams) backButtonView.getLayoutParams();
|
|
marginLayoutParams.topMargin = AndroidUtilities.dp(16) + statusBarHeight;
|
|
|
|
marginLayoutParams = (MarginLayoutParams) radialProgressView.getLayoutParams();
|
|
marginLayoutParams.topMargin = AndroidUtilities.dp(16) + statusBarHeight;
|
|
|
|
marginLayoutParams = (MarginLayoutParams) menu.getLayoutParams();
|
|
marginLayoutParams.topMargin = AndroidUtilities.dp(16) + statusBarHeight;
|
|
|
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
|
}
|
|
};
|
|
sizeNotifierFrameLayout.setDelegate((keyboardHeight, isWidthGreater) -> {
|
|
if (keyboardHeight > AndroidUtilities.dp(20) && isCustomKeyboardVisible()) {
|
|
AndroidUtilities.hideKeyboard(fragmentView);
|
|
}
|
|
if (keyboardHeight <= AndroidUtilities.dp(20) && keyboardHideCallback != null) {
|
|
keyboardHideCallback.run();
|
|
keyboardHideCallback = null;
|
|
}
|
|
});
|
|
fragmentView = sizeNotifierFrameLayout;
|
|
|
|
ScrollView scrollView = new ScrollView(context) {
|
|
@Override
|
|
public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
|
|
if (currentViewNum == VIEW_CODE_MESSAGE || currentViewNum == VIEW_CODE_SMS || currentViewNum == VIEW_CODE_CALL) {
|
|
rectangle.bottom += AndroidUtilities.dp(40);
|
|
}
|
|
return super.requestChildRectangleOnScreen(child, rectangle, immediate);
|
|
}
|
|
};
|
|
scrollView.setFillViewport(true);
|
|
sizeNotifierFrameLayout.addView(scrollView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
keyboardLinearLayout = new LinearLayout(context);
|
|
keyboardLinearLayout.setOrientation(LinearLayout.VERTICAL);
|
|
scrollView.addView(keyboardLinearLayout, LayoutHelper.createScroll(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.LEFT));
|
|
|
|
Space spacer = new Space(context);
|
|
spacer.setMinimumHeight(AndroidUtilities.isTablet() ? 0 : AndroidUtilities.statusBarHeight);
|
|
keyboardLinearLayout.addView(spacer);
|
|
slideViewsContainer = new FrameLayout(context) {
|
|
@Override
|
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
|
super.onLayout(changed, left, top, right, bottom);
|
|
for (SlideView slideView : views) {
|
|
MarginLayoutParams params = (MarginLayoutParams) slideView.getLayoutParams();
|
|
int childBottom = getHeight() + AndroidUtilities.dp(16);
|
|
if (!slideView.hasCustomKeyboard() && keyboardView.getVisibility() == VISIBLE) {
|
|
childBottom += AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP);
|
|
}
|
|
slideView.layout(params.leftMargin, params.topMargin, getWidth() - params.rightMargin, childBottom);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
|
int width = getMeasuredWidth(), height = getMeasuredHeight();
|
|
|
|
for (SlideView slideView : views) {
|
|
MarginLayoutParams params = (MarginLayoutParams) slideView.getLayoutParams();
|
|
int childHeight = height - params.topMargin + AndroidUtilities.dp(16);
|
|
if (!slideView.hasCustomKeyboard() && keyboardView.getVisibility() == VISIBLE) {
|
|
childHeight += AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP);
|
|
}
|
|
slideView.measure(MeasureSpec.makeMeasureSpec(width - params.rightMargin - params.leftMargin, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
|
|
}
|
|
}
|
|
};
|
|
keyboardLinearLayout.addView(slideViewsContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 0, 1f));
|
|
keyboardView = new CustomPhoneKeyboardView(context);
|
|
keyboardLinearLayout.addView(keyboardView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP));
|
|
|
|
views[VIEW_PHONE_INPUT] = new PhoneView(context);
|
|
views[VIEW_CODE_MESSAGE] = new LoginActivitySmsView(context, AUTH_TYPE_MESSAGE);
|
|
views[VIEW_CODE_SMS] = new LoginActivitySmsView(context, AUTH_TYPE_SMS);
|
|
views[VIEW_CODE_FLASH_CALL] = new LoginActivitySmsView(context, AUTH_TYPE_FLASH_CALL);
|
|
views[VIEW_CODE_CALL] = new LoginActivitySmsView(context, AUTH_TYPE_CALL);
|
|
views[VIEW_REGISTER] = new LoginActivityRegisterView(context);
|
|
views[VIEW_PASSWORD] = new LoginActivityPasswordView(context);
|
|
views[VIEW_RECOVER] = new LoginActivityRecoverView(context);
|
|
views[VIEW_RESET_WAIT] = new LoginActivityResetWaitView(context);
|
|
views[VIEW_NEW_PASSWORD_STAGE_1] = new LoginActivityNewPasswordView(context, 0);
|
|
views[VIEW_NEW_PASSWORD_STAGE_2] = new LoginActivityNewPasswordView(context, 1);
|
|
views[VIEW_CODE_MISSED_CALL] = new LoginActivitySmsView(context, AUTH_TYPE_MISSED_CALL);
|
|
|
|
for (int a = 0; a < views.length; a++) {
|
|
views[a].setVisibility(a == 0 ? View.VISIBLE : View.GONE);
|
|
slideViewsContainer.addView(views[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.CENTER, AndroidUtilities.isTablet() ? 26 : 18, 30, AndroidUtilities.isTablet() ? 26 : 18, 0));
|
|
}
|
|
|
|
Bundle savedInstanceState = loadCurrentState(newAccount);
|
|
if (savedInstanceState != null) {
|
|
currentViewNum = savedInstanceState.getInt("currentViewNum", 0);
|
|
syncContacts = savedInstanceState.getInt("syncContacts", 0) == 1;
|
|
if (currentViewNum >= VIEW_CODE_MESSAGE && currentViewNum <= VIEW_CODE_CALL) {
|
|
int time = savedInstanceState.getInt("open");
|
|
if (time != 0 && Math.abs(System.currentTimeMillis() / 1000 - time) >= 24 * 60 * 60) {
|
|
currentViewNum = VIEW_PHONE_INPUT;
|
|
savedInstanceState = null;
|
|
clearCurrentState();
|
|
}
|
|
} else if (currentViewNum == VIEW_PASSWORD) {
|
|
LoginActivityPasswordView view = (LoginActivityPasswordView) views[VIEW_PASSWORD];
|
|
if (view.currentPassword == null) {
|
|
currentViewNum = VIEW_PHONE_INPUT;
|
|
savedInstanceState = null;
|
|
clearCurrentState();
|
|
}
|
|
} else if (currentViewNum == VIEW_RECOVER) {
|
|
LoginActivityRecoverView view = (LoginActivityRecoverView) views[VIEW_RECOVER];
|
|
if (view.passwordString == null) {
|
|
currentViewNum = VIEW_PHONE_INPUT;
|
|
savedInstanceState = null;
|
|
clearCurrentState();
|
|
}
|
|
}
|
|
}
|
|
|
|
floatingButtonContainer = new FrameLayout(context);
|
|
floatingButtonContainer.setVisibility(doneButtonVisible[DONE_TYPE_FLOATING] ? View.VISIBLE : View.GONE);
|
|
if (Build.VERSION.SDK_INT >= 21) {
|
|
StateListAnimator animator = new StateListAnimator();
|
|
animator.addState(new int[]{android.R.attr.state_pressed}, ObjectAnimator.ofFloat(floatingButtonIcon, "translationZ", AndroidUtilities.dp(2), AndroidUtilities.dp(4)).setDuration(200));
|
|
animator.addState(new int[]{}, ObjectAnimator.ofFloat(floatingButtonIcon, "translationZ", AndroidUtilities.dp(4), AndroidUtilities.dp(2)).setDuration(200));
|
|
floatingButtonContainer.setStateListAnimator(animator);
|
|
floatingButtonContainer.setOutlineProvider(new ViewOutlineProvider() {
|
|
@SuppressLint("NewApi")
|
|
@Override
|
|
public void getOutline(View view, Outline outline) {
|
|
outline.setOval(0, 0, AndroidUtilities.dp(56), AndroidUtilities.dp(56));
|
|
}
|
|
});
|
|
}
|
|
floatingAutoAnimator = VerticalPositionAutoAnimator.attach(floatingButtonContainer);
|
|
sizeNotifierFrameLayout.addView(floatingButtonContainer, LayoutHelper.createFrame(Build.VERSION.SDK_INT >= 21 ? 56 : 60, Build.VERSION.SDK_INT >= 21 ? 56 : 60, Gravity.RIGHT | Gravity.BOTTOM, 0, 0, 24, 16));
|
|
floatingButtonContainer.setOnClickListener(view -> onDoneButtonPressed());
|
|
floatingAutoAnimator.addUpdateListener((animation, value, velocity) -> {
|
|
if (phoneNumberConfirmView != null) {
|
|
phoneNumberConfirmView.updateFabPosition();
|
|
}
|
|
});
|
|
|
|
backButtonView = new ImageView(context);
|
|
backButtonView.setImageResource(R.drawable.ic_ab_back);
|
|
backButtonView.setOnClickListener(v -> {
|
|
if (onBackPressed()) {
|
|
finishFragment();
|
|
}
|
|
});
|
|
backButtonView.setContentDescription(LocaleController.getString(R.string.Back));
|
|
int padding = AndroidUtilities.dp(4);
|
|
backButtonView.setPadding(padding, padding, padding, padding);
|
|
sizeNotifierFrameLayout.addView(backButtonView, LayoutHelper.createFrame(32, 32, Gravity.LEFT | Gravity.TOP, 16, 16, 0, 0));
|
|
|
|
menu = new ActionBarMenuItem(context, null, 0, Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
menu.setIcon(R.drawable.ic_ab_other);
|
|
menu.setSubMenuOpenSide(1);
|
|
menu.setBackground(Theme.createSelectorDrawable(Theme.getColor(Theme.key_listSelector)));
|
|
|
|
menu.addSubItem(menu_proxy, R.drawable.proxy_on, LocaleController.getString("Proxy", R.string.Proxy));
|
|
menu.addSubItem(menu_language, R.drawable.ic_translate, LocaleController.getString("Language", R.string.Language));
|
|
menu.addSubItem(menu_bot_login, R.drawable.list_bot, LocaleController.getString("BotLogin", R.string.BotLogin));
|
|
menu.addSubItem(menu_qr_login, R.drawable.wallet_qr, LocaleController.getString("ImportLogin", R.string.ImportLogin));
|
|
// otherItem.addSubItem(menu_custom_api, R.drawable.baseline_vpn_key_24, LocaleController.getString("CustomApi", R.string.CustomApi));
|
|
// menu.addSubItem(menu_custom_dc, R.drawable.baseline_sync_24, LocaleController.getString("CustomBackend", R.string.CustomBackend));
|
|
|
|
menu.setOnClickListener(v -> {
|
|
menu.toggleSubMenu();
|
|
});
|
|
menu.setDelegate((id) -> {
|
|
if (id == menu_proxy){
|
|
presentFragment(new ProxyListActivity());
|
|
} else if (id == menu_language) {
|
|
presentFragment(new LanguageSelectActivity());
|
|
} else if (id == menu_bot_login) {
|
|
doBotLogin(context);
|
|
} else if (id == menu_qr_login) {
|
|
getConnectionsManager().cleanup(false);
|
|
regenerateLoginToken(false);
|
|
}
|
|
});
|
|
menu.setContentDescription(LocaleController.getString(R.string.items_other));
|
|
padding = AndroidUtilities.dp(4);
|
|
menu.setPadding(padding, padding, padding, padding);
|
|
sizeNotifierFrameLayout.addView(menu, LayoutHelper.createFrame(32, 32, Gravity.RIGHT | Gravity.TOP, 0, 16, 16, 0));
|
|
|
|
radialProgressView = new RadialProgressView(context);
|
|
radialProgressView.setSize(AndroidUtilities.dp(20));
|
|
radialProgressView.setAlpha(0);
|
|
radialProgressView.setScaleX(0.1f);
|
|
radialProgressView.setScaleY(0.1f);
|
|
sizeNotifierFrameLayout.addView(radialProgressView, LayoutHelper.createFrame(32, 32, Gravity.RIGHT | Gravity.TOP, 0, 16, 16, 0));
|
|
|
|
floatingButtonIcon = new TransformableLoginButtonView(context);
|
|
floatingButtonIcon.setTransformType(TransformableLoginButtonView.TRANSFORM_OPEN_ARROW);
|
|
floatingButtonIcon.setProgress(1f);
|
|
floatingButtonIcon.setDrawBackground(false);
|
|
floatingButtonContainer.setContentDescription(LocaleController.getString("Done", R.string.Done));
|
|
floatingButtonContainer.addView(floatingButtonIcon, LayoutHelper.createFrame(Build.VERSION.SDK_INT >= 21 ? 56 : 60, Build.VERSION.SDK_INT >= 21 ? 56 : 60));
|
|
|
|
floatingProgressView = new RadialProgressView(context);
|
|
floatingProgressView.setSize(AndroidUtilities.dp(22));
|
|
floatingProgressView.setAlpha(0.0f);
|
|
floatingProgressView.setScaleX(0.1f);
|
|
floatingProgressView.setScaleY(0.1f);
|
|
floatingProgressView.setVisibility(View.INVISIBLE);
|
|
floatingButtonContainer.addView(floatingProgressView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
if (savedInstanceState != null) {
|
|
restoringState = true;
|
|
}
|
|
for (int a = 0; a < views.length; a++) {
|
|
SlideView v = views[a];
|
|
if (savedInstanceState != null) {
|
|
if (a >= VIEW_CODE_MESSAGE && a <= VIEW_CODE_CALL) {
|
|
if (a == currentViewNum) {
|
|
v.restoreStateParams(savedInstanceState);
|
|
}
|
|
} else {
|
|
v.restoreStateParams(savedInstanceState);
|
|
}
|
|
}
|
|
if (currentViewNum == a) {
|
|
backButtonView.setVisibility(v.needBackButton() || newAccount ? View.VISIBLE : View.GONE);
|
|
v.setVisibility(View.VISIBLE);
|
|
v.onShow();
|
|
|
|
setCustomKeyboardVisible(v.hasCustomKeyboard(), false);
|
|
|
|
currentDoneType = DONE_TYPE_FLOATING;
|
|
boolean needFloatingButton = a == VIEW_PHONE_INPUT || a == VIEW_REGISTER ||
|
|
a == VIEW_PASSWORD || a == VIEW_NEW_PASSWORD_STAGE_1 || a == VIEW_NEW_PASSWORD_STAGE_2;
|
|
showDoneButton(needFloatingButton, false);
|
|
if (a == VIEW_CODE_MESSAGE || a == VIEW_CODE_SMS || a == VIEW_CODE_FLASH_CALL || a == VIEW_CODE_CALL) {
|
|
currentDoneType = DONE_TYPE_ACTION;
|
|
}
|
|
} else {
|
|
if (v.getVisibility() != View.GONE) {
|
|
v.setVisibility(View.GONE);
|
|
v.onHide();
|
|
}
|
|
}
|
|
}
|
|
restoringState = false;
|
|
|
|
updateColors();
|
|
|
|
if (cancelAccountDeletionMode) {
|
|
fillNextCodeParams(cancelDeletionParams, cancelDeletionCode, false);
|
|
}
|
|
|
|
return fragmentView;
|
|
}
|
|
|
|
private boolean isCustomKeyboardForceDisabled() {
|
|
return AndroidUtilities.displaySize.x > AndroidUtilities.displaySize.y || AndroidUtilities.isTablet() || AndroidUtilities.isAccessibilityTouchExplorationEnabled();
|
|
}
|
|
|
|
private boolean isCustomKeyboardVisible() {
|
|
return views[currentViewNum].hasCustomKeyboard() && !isCustomKeyboardForceDisabled();
|
|
}
|
|
|
|
private void setCustomKeyboardVisible(boolean visible, boolean animate) {
|
|
if (customKeyboardWasVisible == visible && animate) return;
|
|
customKeyboardWasVisible = visible;
|
|
|
|
if (isCustomKeyboardForceDisabled()) {
|
|
visible = false;
|
|
}
|
|
|
|
if (visible) {
|
|
AndroidUtilities.hideKeyboard(fragmentView);
|
|
AndroidUtilities.requestAltFocusable(getParentActivity(), classGuid);
|
|
if (animate) {
|
|
ValueAnimator anim = ValueAnimator.ofFloat(0, 1).setDuration(300);
|
|
anim.setInterpolator(CubicBezierInterpolator.DEFAULT);
|
|
anim.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
keyboardView.setAlpha(val);
|
|
keyboardView.setTranslationY((1f - val) * AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP));
|
|
});
|
|
anim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationStart(Animator animation) {
|
|
keyboardView.setVisibility(View.VISIBLE);
|
|
}
|
|
});
|
|
anim.start();
|
|
} else {
|
|
keyboardView.setVisibility(View.VISIBLE);
|
|
}
|
|
} else {
|
|
AndroidUtilities.removeAltFocusable(getParentActivity(), classGuid);
|
|
if (animate) {
|
|
ValueAnimator anim = ValueAnimator.ofFloat(1, 0).setDuration(300);
|
|
anim.setInterpolator(Easings.easeInOutQuad);
|
|
anim.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
keyboardView.setAlpha(val);
|
|
keyboardView.setTranslationY((1f - val) * AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP));
|
|
});
|
|
anim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
keyboardView.setVisibility(View.GONE);
|
|
}
|
|
});
|
|
anim.start();
|
|
} else {
|
|
keyboardView.setVisibility(View.GONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPause() {
|
|
super.onPause();
|
|
if (newAccount) {
|
|
ConnectionsManager.getInstance(currentAccount).setAppPaused(true, false);
|
|
}
|
|
AndroidUtilities.removeAltFocusable(getParentActivity(), classGuid);
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
if (newAccount) {
|
|
ConnectionsManager.getInstance(currentAccount).setAppPaused(false, false);
|
|
}
|
|
AndroidUtilities.requestAdjustResize(getParentActivity(), classGuid);
|
|
fragmentView.requestLayout();
|
|
try {
|
|
if (currentViewNum >= VIEW_CODE_MESSAGE && currentViewNum <= VIEW_CODE_CALL && views[currentViewNum] instanceof LoginActivitySmsView) {
|
|
int time = ((LoginActivitySmsView) views[currentViewNum]).openTime;
|
|
if (time != 0 && Math.abs(System.currentTimeMillis() / 1000 - time) >= 24 * 60 * 60) {
|
|
views[currentViewNum].onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, false, null, true);
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
if (currentViewNum == VIEW_PHONE_INPUT && !needRequestPermissions) {
|
|
SlideView view = views[currentViewNum];
|
|
if (view != null) {
|
|
view.onShow();
|
|
}
|
|
}
|
|
|
|
if (isCustomKeyboardVisible()) {
|
|
AndroidUtilities.hideKeyboard(fragmentView);
|
|
AndroidUtilities.requestAltFocusable(getParentActivity(), classGuid);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasForceLightStatusBar() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onConfigurationChanged(Configuration newConfig) {
|
|
setCustomKeyboardVisible(views[currentViewNum].hasCustomKeyboard(), false);
|
|
if (phoneNumberConfirmView != null) {
|
|
phoneNumberConfirmView.dismiss();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onRequestPermissionsResultFragment(int requestCode, String[] permissions, int[] grantResults) {
|
|
if (permissions.length == 0 || grantResults.length == 0) return;
|
|
|
|
boolean granted = grantResults[0] == PackageManager.PERMISSION_GRANTED;
|
|
if (requestCode == 6) {
|
|
checkPermissions = false;
|
|
if (currentViewNum == VIEW_PHONE_INPUT) {
|
|
((PhoneView)views[currentViewNum]).confirmedNumber = true;
|
|
views[currentViewNum].onNextPressed(null);
|
|
}
|
|
} else if (requestCode == BasePermissionsActivity.REQUEST_CODE_CALLS) {
|
|
checkShowPermissions = false;
|
|
if (currentViewNum == VIEW_PHONE_INPUT) {
|
|
((PhoneView) views[currentViewNum]).fillNumber();
|
|
}
|
|
} else if (requestCode == BasePermissionsActivity.REQUEST_CODE_OPEN_CAMERA) {
|
|
if (granted) {
|
|
LoginActivityRegisterView registerView = (LoginActivityRegisterView) views[VIEW_REGISTER];
|
|
registerView.imageUpdater.openCamera();
|
|
}
|
|
} else if (requestCode == BasePermissionsActivity.REQUEST_CODE_EXTERNAL_STORAGE_FOR_AVATAR) {
|
|
if (granted) {
|
|
LoginActivityRegisterView registerView = (LoginActivityRegisterView) views[VIEW_REGISTER];
|
|
registerView.post(() -> registerView.imageUpdater.openGallery());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Bundle loadCurrentState(boolean newAccount) {
|
|
if (newAccount) {
|
|
return null;
|
|
}
|
|
try {
|
|
Bundle bundle = new Bundle();
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("logininfo2", Context.MODE_PRIVATE);
|
|
Map<String, ?> params = preferences.getAll();
|
|
for (Map.Entry<String, ?> entry : params.entrySet()) {
|
|
String key = entry.getKey();
|
|
Object value = entry.getValue();
|
|
String[] args = key.split("_\\|_");
|
|
if (args.length == 1) {
|
|
if (value instanceof String) {
|
|
bundle.putString(key, (String) value);
|
|
} else if (value instanceof Integer) {
|
|
bundle.putInt(key, (Integer) value);
|
|
}
|
|
} else if (args.length == 2) {
|
|
Bundle inner = bundle.getBundle(args[0]);
|
|
if (inner == null) {
|
|
inner = new Bundle();
|
|
bundle.putBundle(args[0], inner);
|
|
}
|
|
if (value instanceof String) {
|
|
inner.putString(args[1], (String) value);
|
|
} else if (value instanceof Integer) {
|
|
inner.putInt(args[1], (Integer) value);
|
|
}
|
|
}
|
|
}
|
|
return bundle;
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void clearCurrentState() {
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("logininfo2", Context.MODE_PRIVATE);
|
|
SharedPreferences.Editor editor = preferences.edit();
|
|
editor.clear();
|
|
editor.commit();
|
|
}
|
|
|
|
private void putBundleToEditor(Bundle bundle, SharedPreferences.Editor editor, String prefix) {
|
|
Set<String> keys = bundle.keySet();
|
|
for (String key : keys) {
|
|
Object obj = bundle.get(key);
|
|
if (obj instanceof String) {
|
|
if (prefix != null) {
|
|
editor.putString(prefix + "_|_" + key, (String) obj);
|
|
} else {
|
|
editor.putString(key, (String) obj);
|
|
}
|
|
} else if (obj instanceof Integer) {
|
|
if (prefix != null) {
|
|
editor.putInt(prefix + "_|_" + key, (Integer) obj);
|
|
} else {
|
|
editor.putInt(key, (Integer) obj);
|
|
}
|
|
} else if (obj instanceof Bundle) {
|
|
putBundleToEditor((Bundle) obj, editor, key);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onDialogDismiss(Dialog dialog) {
|
|
if (Build.VERSION.SDK_INT >= 23) {
|
|
if (dialog == permissionsDialog && !permissionsItems.isEmpty() && getParentActivity() != null) {
|
|
try {
|
|
getParentActivity().requestPermissions(permissionsItems.toArray(new String[0]), 6);
|
|
} catch (Exception ignore) {
|
|
|
|
}
|
|
} else if (dialog == permissionsShowDialog && !permissionsShowItems.isEmpty() && getParentActivity() != null) {
|
|
AndroidUtilities.runOnUIThread(() -> needRequestPermissions = false, 200);
|
|
try {
|
|
getParentActivity().requestPermissions(permissionsShowItems.toArray(new String[0]), 7);
|
|
} catch (Exception ignore) {
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed() {
|
|
if (currentViewNum == VIEW_PHONE_INPUT) {
|
|
for (int a = 0; a < views.length; a++) {
|
|
if (views[a] != null) {
|
|
views[a].onDestroyActivity();
|
|
}
|
|
}
|
|
clearCurrentState();
|
|
return true;
|
|
} else if (currentViewNum == VIEW_PASSWORD) {
|
|
views[currentViewNum].onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
} else if (currentViewNum == VIEW_RECOVER || currentViewNum == VIEW_RESET_WAIT) {
|
|
views[currentViewNum].onBackPressed(true);
|
|
setPage(VIEW_PASSWORD, true, null, true);
|
|
} else if ((currentViewNum >= VIEW_CODE_MESSAGE && currentViewNum <= VIEW_CODE_CALL) || currentViewNum == AUTH_TYPE_MISSED_CALL) {
|
|
if (views[currentViewNum].onBackPressed(false)) {
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
}
|
|
} else if (currentViewNum == VIEW_REGISTER) {
|
|
((LoginActivityRegisterView) views[currentViewNum]).wrongNumber.callOnClick();
|
|
} else if (currentViewNum == VIEW_NEW_PASSWORD_STAGE_1) {
|
|
views[currentViewNum].onBackPressed(true);
|
|
setPage(VIEW_RECOVER, true, null, true);
|
|
} else if (currentViewNum == VIEW_NEW_PASSWORD_STAGE_2) {
|
|
views[currentViewNum].onBackPressed(true);
|
|
setPage(VIEW_NEW_PASSWORD_STAGE_1, true, null, true);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResultFragment(int requestCode, int resultCode, Intent data) {
|
|
LoginActivityRegisterView registerView = (LoginActivityRegisterView) views[VIEW_REGISTER];
|
|
if (registerView != null) {
|
|
registerView.imageUpdater.onActivityResult(requestCode, resultCode, data);
|
|
}
|
|
}
|
|
|
|
private void needShowAlert(String title, String text) {
|
|
if (text == null || getParentActivity() == null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setTitle(title);
|
|
builder.setMessage(text);
|
|
builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
|
|
showDialog(builder.create());
|
|
}
|
|
|
|
private void onFieldError(View view, boolean allowErrorSelection) {
|
|
view.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
|
|
AndroidUtilities.shakeViewSpring(view, 3.5f);
|
|
|
|
if (allowErrorSelection) {
|
|
if (view instanceof OutlineTextContainerView) {
|
|
Runnable callback = (Runnable) view.getTag(R.id.timeout_callback);
|
|
if (callback != null) {
|
|
view.removeCallbacks(callback);
|
|
}
|
|
|
|
OutlineTextContainerView outlineTextContainerView = (OutlineTextContainerView) view;
|
|
AtomicReference<Runnable> timeoutCallbackRef = new AtomicReference<>(); // We can't use timeoutCallback before declaration otherwise
|
|
EditText editText = outlineTextContainerView.getAttachedEditText();
|
|
TextWatcher textWatcher = new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
editText.post(()-> {
|
|
editText.removeTextChangedListener(this);
|
|
editText.removeCallbacks(timeoutCallbackRef.get());
|
|
timeoutCallbackRef.get().run();
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {}
|
|
};
|
|
|
|
outlineTextContainerView.animateError(1f);
|
|
Runnable timeoutCallback = () -> {
|
|
outlineTextContainerView.animateError(0f);
|
|
view.setTag(R.id.timeout_callback, null);
|
|
if (editText != null) {
|
|
editText.post(()-> editText.removeTextChangedListener(textWatcher));
|
|
}
|
|
};
|
|
timeoutCallbackRef.set(timeoutCallback);
|
|
view.postDelayed(timeoutCallback, 2000);
|
|
view.setTag(R.id.timeout_callback, timeoutCallback);
|
|
|
|
if (editText != null) {
|
|
editText.addTextChangedListener(textWatcher);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void needShowInvalidAlert(BaseFragment fragment, final String phoneNumber, final boolean banned) {
|
|
if (fragment == null || fragment.getParentActivity() == null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(fragment.getParentActivity());
|
|
builder.setTitle(LocaleController.getString(R.string.RestorePasswordNoEmailTitle));
|
|
if (banned) {
|
|
builder.setMessage(LocaleController.getString("BannedPhoneNumber", R.string.BannedPhoneNumber));
|
|
} else {
|
|
builder.setMessage(LocaleController.getString("InvalidPhoneNumber", R.string.InvalidPhoneNumber));
|
|
}
|
|
builder.setNeutralButton(LocaleController.getString("BotHelp", R.string.BotHelp), (dialog, which) -> {
|
|
try {
|
|
PackageInfo pInfo = ApplicationLoader.applicationContext.getPackageManager().getPackageInfo(ApplicationLoader.applicationContext.getPackageName(), 0);
|
|
String version = String.format(Locale.US, "%s (%d)", pInfo.versionName, pInfo.versionCode);
|
|
|
|
Intent mailer = new Intent(Intent.ACTION_SENDTO);
|
|
mailer.setData(Uri.parse("mailto:"));
|
|
mailer.putExtra(Intent.EXTRA_EMAIL, new String[]{banned ? "recover@telegram.org" : "login@stel.com"});
|
|
if (banned) {
|
|
mailer.putExtra(Intent.EXTRA_SUBJECT, "Banned phone number: " + phoneNumber);
|
|
mailer.putExtra(Intent.EXTRA_TEXT, "I'm trying to use my mobile phone number: " + phoneNumber + "\nBut Telegram says it's banned. Please help.\n\nApp version: " + version + "\nOS version: SDK " + Build.VERSION.SDK_INT + "\nDevice Name: " + Build.MANUFACTURER + Build.MODEL + "\nLocale: " + Locale.getDefault());
|
|
} else {
|
|
mailer.putExtra(Intent.EXTRA_SUBJECT, "Invalid phone number: " + phoneNumber);
|
|
mailer.putExtra(Intent.EXTRA_TEXT, "I'm trying to use my mobile phone number: " + phoneNumber + "\nBut Telegram says it's invalid. Please help.\n\nApp version: " + version + "\nOS version: SDK " + Build.VERSION.SDK_INT + "\nDevice Name: " + Build.MANUFACTURER + Build.MODEL + "\nLocale: " + Locale.getDefault());
|
|
}
|
|
fragment.getParentActivity().startActivity(Intent.createChooser(mailer, "Send email..."));
|
|
} catch (Exception e) {
|
|
AlertDialog.Builder builder2 = new AlertDialog.Builder(fragment.getParentActivity());
|
|
builder2.setTitle(LocaleController.getString(R.string.RestorePasswordNoEmailTitle));
|
|
builder2.setMessage(LocaleController.getString("NoMailInstalled", R.string.NoMailInstalled));
|
|
builder2.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
|
|
fragment.showDialog(builder2.create());
|
|
}
|
|
});
|
|
builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
|
|
fragment.showDialog(builder.create());
|
|
}
|
|
|
|
private void showDoneButton(boolean show, boolean animated) {
|
|
boolean floating = currentDoneType == 0;
|
|
if (doneButtonVisible[currentDoneType] == show) {
|
|
return;
|
|
}
|
|
|
|
if (showDoneAnimation[currentDoneType] != null) {
|
|
if (animated) {
|
|
showDoneAnimation[currentDoneType].removeAllListeners();
|
|
}
|
|
showDoneAnimation[currentDoneType].cancel();
|
|
}
|
|
doneButtonVisible[currentDoneType] = show;
|
|
if (animated) {
|
|
showDoneAnimation[currentDoneType] = new AnimatorSet();
|
|
if (show) {
|
|
if (floating) {
|
|
if (floatingButtonContainer.getVisibility() != View.VISIBLE) {
|
|
floatingAutoAnimator.setOffsetY(AndroidUtilities.dpf2(70f));
|
|
floatingButtonContainer.setVisibility(View.VISIBLE);
|
|
}
|
|
ValueAnimator offsetAnimator = ValueAnimator.ofFloat(floatingAutoAnimator.getOffsetY(), 0);
|
|
offsetAnimator.addUpdateListener(animation -> {
|
|
float val = (Float) animation.getAnimatedValue();
|
|
floatingAutoAnimator.setOffsetY(val);
|
|
floatingButtonContainer.setAlpha(1f - (val / AndroidUtilities.dpf2(70f)));
|
|
});
|
|
showDoneAnimation[currentDoneType].play(offsetAnimator);
|
|
}
|
|
} else {
|
|
if (floating) {
|
|
ValueAnimator offsetAnimator = ValueAnimator.ofFloat(floatingAutoAnimator.getOffsetY(), AndroidUtilities.dpf2(70f));
|
|
offsetAnimator.addUpdateListener(animation -> {
|
|
float val = (Float) animation.getAnimatedValue();
|
|
floatingAutoAnimator.setOffsetY(val);
|
|
floatingButtonContainer.setAlpha(1f - (val / AndroidUtilities.dpf2(70f)));
|
|
});
|
|
showDoneAnimation[currentDoneType].play(offsetAnimator);
|
|
}
|
|
}
|
|
showDoneAnimation[currentDoneType].addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (showDoneAnimation[floating ? 0 : 1] != null && showDoneAnimation[floating ? 0 : 1].equals(animation)) {
|
|
if (!show) {
|
|
if (floating) {
|
|
floatingButtonContainer.setVisibility(View.GONE);
|
|
}
|
|
|
|
if (floating && floatingButtonIcon.getAlpha() != 1f) {
|
|
floatingButtonIcon.setAlpha(1f);
|
|
floatingButtonIcon.setScaleX(1f);
|
|
floatingButtonIcon.setScaleY(1f);
|
|
floatingButtonIcon.setVisibility(View.VISIBLE);
|
|
floatingButtonContainer.setEnabled(true);
|
|
floatingProgressView.setAlpha(0f);
|
|
floatingProgressView.setScaleX(0.1f);
|
|
floatingProgressView.setScaleY(0.1f);
|
|
floatingProgressView.setVisibility(View.INVISIBLE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAnimationCancel(Animator animation) {
|
|
if (showDoneAnimation[floating ? 0 : 1] != null && showDoneAnimation[floating ? 0 : 1].equals(animation)) {
|
|
showDoneAnimation[floating ? 0 : 1] = null;
|
|
}
|
|
}
|
|
});
|
|
final int duration;
|
|
final Interpolator interpolator;
|
|
if (floating) {
|
|
if (show) {
|
|
duration = 200;
|
|
interpolator = AndroidUtilities.decelerateInterpolator;
|
|
} else {
|
|
duration = 150;
|
|
interpolator = AndroidUtilities.accelerateInterpolator;
|
|
}
|
|
} else {
|
|
duration = 150;
|
|
interpolator = null;
|
|
}
|
|
showDoneAnimation[currentDoneType].setDuration(duration);
|
|
showDoneAnimation[currentDoneType].setInterpolator(interpolator);
|
|
showDoneAnimation[currentDoneType].start();
|
|
} else {
|
|
if (show) {
|
|
if (floating) {
|
|
floatingButtonContainer.setVisibility(View.VISIBLE);
|
|
floatingAutoAnimator.setOffsetY(0f);
|
|
}
|
|
} else {
|
|
if (floating) {
|
|
floatingButtonContainer.setVisibility(View.GONE);
|
|
floatingAutoAnimator.setOffsetY(AndroidUtilities.dpf2(70f));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void onDoneButtonPressed() {
|
|
if (!doneButtonVisible[currentDoneType]) {
|
|
return;
|
|
}
|
|
if (radialProgressView.getTag() != null) {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setTitle(LocaleController.getString(R.string.NekoX));
|
|
builder.setMessage(LocaleController.getString("StopLoading", R.string.StopLoading));
|
|
builder.setPositiveButton(LocaleController.getString("WaitMore", R.string.WaitMore), null);
|
|
builder.setNegativeButton(LocaleController.getString("Stop", R.string.Stop), (dialogInterface, i) -> {
|
|
views[currentViewNum].onCancelPressed();
|
|
needHideProgress(true);
|
|
});
|
|
showDialog(builder.create());
|
|
} else {
|
|
views[currentViewNum].onNextPressed(null);
|
|
}
|
|
}
|
|
|
|
private void showEditDoneProgress(boolean show, boolean animated) {
|
|
showEditDoneProgress(show, animated, false);
|
|
}
|
|
|
|
private void showEditDoneProgress(boolean show, boolean animated, boolean fromCallback) {
|
|
if (animated && doneProgressVisible[currentDoneType] == show && !fromCallback) {
|
|
return;
|
|
}
|
|
boolean floating = currentDoneType == DONE_TYPE_FLOATING;
|
|
|
|
if (!fromCallback && !floating) {
|
|
doneProgressVisible[currentDoneType] = show;
|
|
int doneType = currentDoneType;
|
|
if (animated) {
|
|
if (postedEditDoneCallback[currentDoneType]) {
|
|
AndroidUtilities.cancelRunOnUIThread(editDoneCallback[currentDoneType]);
|
|
postedEditDoneCallback[currentDoneType] = false;
|
|
return;
|
|
} else if (show) {
|
|
AndroidUtilities.runOnUIThread(editDoneCallback[currentDoneType] = () -> {
|
|
int type = currentDoneType;
|
|
currentDoneType = doneType;
|
|
showEditDoneProgress(show, animated, true);
|
|
currentDoneType = type;
|
|
}, 2000);
|
|
postedEditDoneCallback[currentDoneType] = true;
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
postedEditDoneCallback[currentDoneType] = false;
|
|
doneProgressVisible[currentDoneType] = show;
|
|
}
|
|
|
|
if (doneItemAnimation != null) {
|
|
doneItemAnimation.cancel();
|
|
}
|
|
|
|
if (animated) {
|
|
doneItemAnimation = new AnimatorSet();
|
|
ValueAnimator animator = ValueAnimator.ofFloat(show ? 0 : 1, show ? 1 : 0);
|
|
animator.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationStart(Animator animation) {
|
|
if (show) {
|
|
if (floating) {
|
|
floatingButtonIcon.setVisibility(View.VISIBLE);
|
|
floatingProgressView.setVisibility(View.VISIBLE);
|
|
floatingButtonContainer.setEnabled(false);
|
|
} else {
|
|
radialProgressView.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (floating) {
|
|
if (!show) {
|
|
floatingProgressView.setVisibility(View.INVISIBLE);
|
|
floatingButtonIcon.setVisibility(View.VISIBLE);
|
|
floatingButtonContainer.setEnabled(true);
|
|
} else {
|
|
floatingButtonIcon.setVisibility(View.INVISIBLE);
|
|
floatingProgressView.setVisibility(View.VISIBLE);
|
|
}
|
|
} else if (!show) {
|
|
radialProgressView.setVisibility(View.INVISIBLE);
|
|
}
|
|
|
|
if (doneItemAnimation != null && doneItemAnimation.equals(animation)) {
|
|
doneItemAnimation = null;
|
|
}
|
|
}
|
|
});
|
|
animator.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
|
|
if (floating) {
|
|
float scale = 0.1f + 0.9f * (1f - val);
|
|
floatingButtonIcon.setScaleX(scale);
|
|
floatingButtonIcon.setScaleY(scale);
|
|
floatingButtonIcon.setAlpha(1f - val);
|
|
|
|
scale = 0.1f + 0.9f * val;
|
|
floatingProgressView.setScaleX(scale);
|
|
floatingProgressView.setScaleY(scale);
|
|
floatingProgressView.setAlpha(val);
|
|
} else {
|
|
float scale = 0.1f + 0.9f * val;
|
|
radialProgressView.setScaleX(scale);
|
|
radialProgressView.setScaleY(scale);
|
|
radialProgressView.setAlpha(val);
|
|
}
|
|
});
|
|
doneItemAnimation.playTogether(animator);
|
|
doneItemAnimation.setDuration(150);
|
|
doneItemAnimation.start();
|
|
} else {
|
|
if (show) {
|
|
if (floating) {
|
|
floatingProgressView.setVisibility(View.VISIBLE);
|
|
floatingButtonIcon.setVisibility(View.INVISIBLE);
|
|
floatingButtonContainer.setEnabled(false);
|
|
floatingButtonIcon.setScaleX(0.1f);
|
|
floatingButtonIcon.setScaleY(0.1f);
|
|
floatingButtonIcon.setAlpha(0.0f);
|
|
floatingProgressView.setScaleX(1.0f);
|
|
floatingProgressView.setScaleY(1.0f);
|
|
floatingProgressView.setAlpha(1.0f);
|
|
} else {
|
|
radialProgressView.setVisibility(View.VISIBLE);
|
|
radialProgressView.setScaleX(1.0f);
|
|
radialProgressView.setScaleY(1.0f);
|
|
radialProgressView.setAlpha(1.0f);
|
|
}
|
|
} else {
|
|
radialProgressView.setTag(null);
|
|
if (floating) {
|
|
floatingProgressView.setVisibility(View.INVISIBLE);
|
|
floatingButtonIcon.setVisibility(View.VISIBLE);
|
|
floatingButtonContainer.setEnabled(true);
|
|
floatingProgressView.setScaleX(0.1f);
|
|
floatingProgressView.setScaleY(0.1f);
|
|
floatingProgressView.setAlpha(0.0f);
|
|
floatingButtonIcon.setScaleX(1.0f);
|
|
floatingButtonIcon.setScaleY(1.0f);
|
|
floatingButtonIcon.setAlpha(1.0f);
|
|
} else {
|
|
radialProgressView.setVisibility(View.INVISIBLE);
|
|
radialProgressView.setScaleX(0.1f);
|
|
radialProgressView.setScaleY(0.1f);
|
|
radialProgressView.setAlpha(0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void needShowProgress(int requestId) {
|
|
needShowProgress(requestId, true);
|
|
}
|
|
|
|
private void needShowProgress(int requestId, boolean animated) {
|
|
if (cancelAccountDeletionMode && requestId == 0) {
|
|
if (cancelDeleteProgressDialog != null || getParentActivity() == null || getParentActivity().isFinishing()) {
|
|
return;
|
|
}
|
|
|
|
cancelDeleteProgressDialog = new AlertDialog(getParentActivity(), 3);
|
|
cancelDeleteProgressDialog.setCanCancel(false);
|
|
cancelDeleteProgressDialog.show();
|
|
return;
|
|
}
|
|
|
|
progressRequestId = requestId;
|
|
showEditDoneProgress(true, animated);
|
|
}
|
|
|
|
private void needHideProgress(boolean cancel) {
|
|
needHideProgress(cancel, true);
|
|
}
|
|
|
|
private void needHideProgress(boolean cancel, boolean animated) {
|
|
if (progressRequestId != 0) {
|
|
if (cancel) {
|
|
ConnectionsManager.getInstance(currentAccount).cancelRequest(progressRequestId, true);
|
|
}
|
|
progressRequestId = 0;
|
|
}
|
|
|
|
if (cancelAccountDeletionMode && cancelDeleteProgressDialog != null) {
|
|
cancelDeleteProgressDialog.dismiss();
|
|
cancelDeleteProgressDialog = null;
|
|
}
|
|
|
|
showEditDoneProgress(false, animated);
|
|
}
|
|
|
|
public void setPage(@ViewNumber int page, boolean animated, Bundle params, boolean back) {
|
|
boolean needFloatingButton = page == VIEW_PHONE_INPUT || page == VIEW_REGISTER || page == VIEW_PASSWORD ||
|
|
page == VIEW_NEW_PASSWORD_STAGE_1 || page == VIEW_NEW_PASSWORD_STAGE_2;
|
|
if (needFloatingButton) {
|
|
if (page == VIEW_PHONE_INPUT) {
|
|
checkPermissions = true;
|
|
checkShowPermissions = true;
|
|
}
|
|
currentDoneType = DONE_TYPE_ACTION;
|
|
showDoneButton(false, animated);
|
|
// Force reset radial progress
|
|
showEditDoneProgress(false, animated);
|
|
currentDoneType = DONE_TYPE_FLOATING;
|
|
showEditDoneProgress(false, animated);
|
|
if (!animated) {
|
|
showDoneButton(true, false);
|
|
}
|
|
} else {
|
|
currentDoneType = DONE_TYPE_FLOATING;
|
|
showDoneButton(false, animated);
|
|
showEditDoneProgress(false, animated);
|
|
if (page != VIEW_RESET_WAIT) {
|
|
currentDoneType = DONE_TYPE_ACTION;
|
|
}
|
|
}
|
|
if (animated) {
|
|
final SlideView outView = views[currentViewNum];
|
|
final SlideView newView = views[page];
|
|
currentViewNum = page;
|
|
backButtonView.setVisibility(newView.needBackButton() || newAccount ? View.VISIBLE : View.GONE);
|
|
|
|
newView.setParams(params, false);
|
|
setParentActivityTitle(newView.getHeaderName());
|
|
newView.onShow();
|
|
newView.setX(back ? -AndroidUtilities.displaySize.x : AndroidUtilities.displaySize.x);
|
|
newView.setVisibility(View.VISIBLE);
|
|
|
|
AnimatorSet pagesAnimation = new AnimatorSet();
|
|
pagesAnimation.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (currentDoneType == DONE_TYPE_FLOATING && needFloatingButton) {
|
|
showDoneButton(true, true);
|
|
}
|
|
outView.setVisibility(View.GONE);
|
|
outView.setX(0);
|
|
}
|
|
});
|
|
pagesAnimation.playTogether(
|
|
ObjectAnimator.ofFloat(outView, View.TRANSLATION_X, back ? AndroidUtilities.displaySize.x : -AndroidUtilities.displaySize.x),
|
|
ObjectAnimator.ofFloat(newView, View.TRANSLATION_X, 0));
|
|
pagesAnimation.setDuration(300);
|
|
pagesAnimation.setInterpolator(new AccelerateDecelerateInterpolator());
|
|
pagesAnimation.start();
|
|
|
|
setCustomKeyboardVisible(newView.hasCustomKeyboard(), true);
|
|
} else {
|
|
backButtonView.setVisibility(views[page].needBackButton() || newAccount ? View.VISIBLE : View.GONE);
|
|
views[currentViewNum].setVisibility(View.GONE);
|
|
currentViewNum = page;
|
|
views[page].setParams(params, false);
|
|
views[page].setVisibility(View.VISIBLE);
|
|
setParentActivityTitle(views[page].getHeaderName());
|
|
views[page].onShow();
|
|
|
|
setCustomKeyboardVisible(views[page].hasCustomKeyboard(), false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void saveSelfArgs(Bundle outState) {
|
|
try {
|
|
Bundle bundle = new Bundle();
|
|
bundle.putInt("currentViewNum", currentViewNum);
|
|
bundle.putInt("syncContacts", syncContacts ? 1 : 0);
|
|
for (int a = 0; a <= currentViewNum; a++) {
|
|
SlideView v = views[a];
|
|
if (v != null) {
|
|
v.saveStateParams(bundle);
|
|
}
|
|
}
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("logininfo2", Context.MODE_PRIVATE);
|
|
SharedPreferences.Editor editor = preferences.edit();
|
|
editor.clear();
|
|
putBundleToEditor(bundle, editor, null);
|
|
editor.commit();
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
|
|
private void needFinishActivity(boolean afterSignup, boolean showSetPasswordConfirm, int otherwiseRelogin) {
|
|
SharedConfig.activeAccounts.add(currentAccount);
|
|
SharedConfig.saveAccounts();
|
|
if (getParentActivity() != null) {
|
|
AndroidUtilities.setLightStatusBar(getParentActivity().getWindow(), false);
|
|
}
|
|
clearCurrentState();
|
|
if (getParentActivity() instanceof LaunchActivity) {
|
|
if (newAccount) {
|
|
newAccount = false;
|
|
((LaunchActivity) getParentActivity()).switchToAccount(currentAccount, false, obj -> {
|
|
Bundle args = new Bundle();
|
|
args.putBoolean("afterSignup", afterSignup);
|
|
return new DialogsActivity(args);
|
|
});
|
|
finishFragment();
|
|
} else {
|
|
|
|
if (afterSignup && showSetPasswordConfirm) {
|
|
TwoStepVerificationSetupActivity twoStepVerification = new TwoStepVerificationSetupActivity(TwoStepVerificationSetupActivity.TYPE_INTRO, null);
|
|
twoStepVerification.setBlockingAlert(otherwiseRelogin);
|
|
twoStepVerification.setFromRegistration(true);
|
|
presentFragment(twoStepVerification, true);
|
|
} else {
|
|
Bundle args = new Bundle();
|
|
args.putBoolean("afterSignup", afterSignup);
|
|
DialogsActivity dialogsActivity = new DialogsActivity(args);
|
|
presentFragment(dialogsActivity, true);
|
|
}
|
|
|
|
NotificationCenter.getInstance(currentAccount).postNotificationName(NotificationCenter.mainUserInfoChanged);
|
|
LocaleController.getInstance().loadRemoteLanguages(currentAccount);
|
|
}
|
|
} else if (getParentActivity() instanceof ExternalActionActivity) {
|
|
((ExternalActionActivity) getParentActivity()).onFinishLogin();
|
|
}
|
|
}
|
|
|
|
private void onAuthSuccess(TLRPC.TL_auth_authorization res) {
|
|
onAuthSuccess(res, false);
|
|
}
|
|
|
|
private void onAuthSuccess(TLRPC.TL_auth_authorization res, boolean afterSignup) {
|
|
MessagesController.getInstance(currentAccount).cleanup();
|
|
ConnectionsManager.getInstance(currentAccount).setUserId(res.user.id);
|
|
UserConfig.getInstance(currentAccount).clearConfig();
|
|
MessagesController.getInstance(currentAccount).cleanup();
|
|
UserConfig.getInstance(currentAccount).syncContacts = syncContacts;
|
|
UserConfig.getInstance(currentAccount).setCurrentUser(res.user);
|
|
UserConfig.getInstance(currentAccount).saveConfig(true);
|
|
MessagesStorage.getInstance(currentAccount).cleanup(true);
|
|
ArrayList<TLRPC.User> users = new ArrayList<>();
|
|
users.add(res.user);
|
|
MessagesStorage.getInstance(currentAccount).putUsersAndChats(users, null, true, true);
|
|
MessagesController.getInstance(currentAccount).putUser(res.user, false);
|
|
ContactsController.getInstance(currentAccount).checkAppAccount();
|
|
MessagesController.getInstance(currentAccount).checkPromoInfo(true);
|
|
ConnectionsManager.getInstance(currentAccount).updateDcSettings();
|
|
|
|
if (afterSignup) {
|
|
MessagesController.getInstance(currentAccount).putDialogsEndReachedAfterRegistration();
|
|
}
|
|
MediaDataController.getInstance(currentAccount).loadStickersByEmojiOrName(AndroidUtilities.STICKERS_PLACEHOLDER_PACK_NAME, false, true);
|
|
|
|
needFinishActivity(afterSignup, res.setup_password_required, res.otherwise_relogin_days);
|
|
}
|
|
|
|
private void fillNextCodeParams(Bundle params, TLRPC.TL_auth_sentCode res) {
|
|
fillNextCodeParams(params, res, true);
|
|
}
|
|
|
|
private void fillNextCodeParams(Bundle params, TLRPC.TL_auth_sentCode res, boolean animate) {
|
|
params.putString("phoneHash", res.phone_code_hash);
|
|
if (res.next_type instanceof TLRPC.TL_auth_codeTypeCall) {
|
|
params.putInt("nextType", AUTH_TYPE_CALL);
|
|
} else if (res.next_type instanceof TLRPC.TL_auth_codeTypeFlashCall) {
|
|
params.putInt("nextType", AUTH_TYPE_FLASH_CALL);
|
|
} else if (res.next_type instanceof TLRPC.TL_auth_codeTypeSms) {
|
|
params.putInt("nextType", AUTH_TYPE_SMS);
|
|
} else if (res.next_type instanceof TLRPC.TL_auth_codeTypeMissedCall) {
|
|
params.putInt("nextType", AUTH_TYPE_MISSED_CALL);
|
|
}
|
|
if (res.type instanceof TLRPC.TL_auth_sentCodeTypeApp) {
|
|
params.putInt("type", 1);
|
|
params.putInt("length", res.type.length);
|
|
setPage(VIEW_CODE_MESSAGE, animate, params, false);
|
|
} else {
|
|
if (res.timeout == 0) {
|
|
res.timeout = 60;
|
|
}
|
|
params.putInt("timeout", res.timeout * 1000);
|
|
if (res.type instanceof TLRPC.TL_auth_sentCodeTypeCall) {
|
|
params.putInt("type", 4);
|
|
params.putInt("length", res.type.length);
|
|
setPage(VIEW_CODE_CALL, animate, params, false);
|
|
} else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeFlashCall) {
|
|
params.putInt("type", 3);
|
|
params.putString("pattern", res.type.pattern);
|
|
setPage(VIEW_CODE_FLASH_CALL, animate, params, false);
|
|
} else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeSms) {
|
|
params.putInt("type", 2);
|
|
params.putInt("length", res.type.length);
|
|
setPage(VIEW_CODE_SMS, animate, params, false);
|
|
} else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeMissedCall) {
|
|
params.putInt("type", AUTH_TYPE_MISSED_CALL);
|
|
params.putInt("length", res.type.length);
|
|
params.putString("prefix", res.type.prefix);
|
|
setPage(VIEW_CODE_MISSED_CALL, animate, params, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private TLRPC.TL_help_termsOfService currentTermsOfService;
|
|
|
|
public class PhoneView extends SlideView implements AdapterView.OnItemSelectedListener, NotificationCenter.NotificationCenterDelegate {
|
|
private AnimatedPhoneNumberEditText codeField;
|
|
private AnimatedPhoneNumberEditText phoneField;
|
|
private TextView titleView;
|
|
private TextViewSwitcher countryButton;
|
|
private OutlineTextContainerView countryOutlineView;
|
|
private OutlineTextContainerView phoneOutlineView;
|
|
private TextView plusTextView;
|
|
private TextView subtitleView;
|
|
private View codeDividerView;
|
|
private ImageView chevronRight;
|
|
private CheckBoxCell syncContactsBox;
|
|
private CheckBoxCell testBackendCheckBox;
|
|
|
|
@CountryState
|
|
private int countryState = COUNTRY_STATE_NOT_SET_OR_VALID;
|
|
private CountrySelectActivity.Country currentCountry;
|
|
|
|
private ArrayList<CountrySelectActivity.Country> countriesArray = new ArrayList<>();
|
|
private HashMap<String, CountrySelectActivity.Country> codesMap = new HashMap<>();
|
|
private HashMap<String, String> phoneFormatMap = new HashMap<>();
|
|
|
|
private boolean ignoreSelection = false;
|
|
private boolean ignoreOnTextChange = false;
|
|
private boolean ignoreOnPhoneChange = false;
|
|
private boolean nextPressed = false;
|
|
private boolean confirmedNumber = false;
|
|
|
|
public PhoneView(Context context) {
|
|
super(context);
|
|
|
|
setOrientation(VERTICAL);
|
|
setGravity(Gravity.CENTER);
|
|
|
|
titleView = new TextView(context);
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleView.setText(LocaleController.getString(R.string.YourNumber));
|
|
titleView.setGravity(Gravity.CENTER);
|
|
titleView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(titleView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 32, 0, 32, 0));
|
|
|
|
subtitleView = new TextView(context);
|
|
subtitleView.setText(LocaleController.getString("StartText", R.string.StartText));
|
|
subtitleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
subtitleView.setGravity(Gravity.CENTER);
|
|
subtitleView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(subtitleView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 32, 8, 32, 0));
|
|
|
|
countryButton = new TextViewSwitcher(context);
|
|
countryButton.setFactory(() -> {
|
|
TextView tv = new TextView(context);
|
|
tv.setPadding(AndroidUtilities.dp(16), AndroidUtilities.dp(12), AndroidUtilities.dp(16), AndroidUtilities.dp(12));
|
|
tv.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
tv.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
tv.setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
|
|
tv.setMaxLines(1);
|
|
tv.setSingleLine(true);
|
|
tv.setEllipsize(TextUtils.TruncateAt.END);
|
|
tv.setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_HORIZONTAL);
|
|
return tv;
|
|
});
|
|
|
|
Animation anim = AnimationUtils.loadAnimation(context, R.anim.text_in);
|
|
anim.setInterpolator(Easings.easeInOutQuad);
|
|
countryButton.setInAnimation(anim);
|
|
|
|
chevronRight = new ImageView(context);
|
|
chevronRight.setImageResource(R.drawable.msg_inputarrow);
|
|
|
|
LinearLayout countryButtonLinearLayout = new LinearLayout(context);
|
|
countryButtonLinearLayout.setOrientation(HORIZONTAL);
|
|
countryButtonLinearLayout.setGravity(Gravity.CENTER_VERTICAL);
|
|
countryButtonLinearLayout.addView(countryButton, LayoutHelper.createLinear(0, LayoutHelper.WRAP_CONTENT, 1f, 0, 0, 0, 0));
|
|
countryButtonLinearLayout.addView(chevronRight, LayoutHelper.createLinearRelatively(24, 24, 0, 0, 0, 14, 0));
|
|
|
|
countryOutlineView = new OutlineTextContainerView(context);
|
|
countryOutlineView.setText(LocaleController.getString(R.string.Country));
|
|
countryOutlineView.addView(countryButtonLinearLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.TOP, 0, 0, 0, 0));
|
|
countryOutlineView.setForceUseCenter(true);
|
|
countryOutlineView.setFocusable(true);
|
|
countryOutlineView.setContentDescription(LocaleController.getString(R.string.Country));
|
|
countryOutlineView.setOnFocusChangeListener((v, hasFocus) -> countryOutlineView.animateSelection(hasFocus ? 1 : 0));
|
|
addView(countryOutlineView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 58, 16, 24, 16, 14));
|
|
countryOutlineView.setOnClickListener(view -> {
|
|
CountrySelectActivity fragment = new CountrySelectActivity(true, countriesArray);
|
|
fragment.setCountrySelectActivityDelegate((country) -> {
|
|
selectCountry(country);
|
|
AndroidUtilities.runOnUIThread(() -> showKeyboard(phoneField), 300);
|
|
phoneField.requestFocus();
|
|
phoneField.setSelection(phoneField.length());
|
|
});
|
|
presentFragment(fragment);
|
|
});
|
|
|
|
LinearLayout linearLayout = new LinearLayout(context);
|
|
linearLayout.setOrientation(HORIZONTAL);
|
|
|
|
phoneOutlineView = new OutlineTextContainerView(context);
|
|
phoneOutlineView.addView(linearLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_VERTICAL, 16, 8, 16, 8));
|
|
phoneOutlineView.setText(LocaleController.getString(R.string.PhoneNumber));
|
|
addView(phoneOutlineView, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 58, 16, 8, 16, 8));
|
|
|
|
plusTextView = new TextView(context);
|
|
plusTextView.setText("+");
|
|
plusTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
plusTextView.setFocusable(false);
|
|
linearLayout.addView(plusTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT));
|
|
|
|
codeField = new AnimatedPhoneNumberEditText(context) {
|
|
@Override
|
|
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
|
|
super.onFocusChanged(focused, direction, previouslyFocusedRect);
|
|
phoneOutlineView.animateSelection(focused || phoneField.isFocused() ? 1f : 0f);
|
|
|
|
if (focused) {
|
|
keyboardView.setEditText(this);
|
|
}
|
|
}
|
|
};
|
|
codeField.setInputType(InputType.TYPE_CLASS_PHONE);
|
|
codeField.setCursorSize(AndroidUtilities.dp(20));
|
|
codeField.setCursorWidth(1.5f);
|
|
codeField.setPadding(AndroidUtilities.dp(10), 0, 0, 0);
|
|
codeField.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
codeField.setMaxLines(1);
|
|
codeField.setGravity(Gravity.LEFT | Gravity.CENTER_VERTICAL);
|
|
codeField.setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
codeField.setBackground(null);
|
|
// codeField.setLineColors(getThemedColor(Theme.key_windowBackgroundWhiteInputField), getThemedColor(Theme.key_windowBackgroundWhiteInputFieldActivated), getThemedColor(Theme.key_windowBackgroundWhiteRedText3));
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
|
|
codeField.setShowSoftInputOnFocus(!(hasCustomKeyboard() && !isCustomKeyboardForceDisabled()));
|
|
}
|
|
codeField.setContentDescription(LocaleController.getString(R.string.LoginAccessibilityCountryCode));
|
|
linearLayout.addView(codeField, LayoutHelper.createLinear(55, 36, -9, 0, 0, 0));
|
|
codeField.addTextChangedListener(new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable editable) {
|
|
if (ignoreOnTextChange) {
|
|
return;
|
|
}
|
|
ignoreOnTextChange = true;
|
|
String text = PhoneFormat.stripExceptNumbers(codeField.getText().toString());
|
|
codeField.setText(text);
|
|
if (text.length() == 0) {
|
|
setCountryButtonText(null);
|
|
phoneField.setHintText(null);
|
|
countryState = COUNTRY_STATE_EMPTY;
|
|
} else {
|
|
CountrySelectActivity.Country country;
|
|
boolean ok = false;
|
|
String textToSet = null;
|
|
if (text.length() > 4) {
|
|
for (int a = 4; a >= 1; a--) {
|
|
String sub = text.substring(0, a);
|
|
country = codesMap.get(sub);
|
|
if (country != null) {
|
|
ok = true;
|
|
textToSet = text.substring(a) + phoneField.getText().toString();
|
|
codeField.setText(text = sub);
|
|
break;
|
|
}
|
|
}
|
|
if (!ok) {
|
|
textToSet = text.substring(1) + phoneField.getText().toString();
|
|
codeField.setText(text = text.substring(0, 1));
|
|
}
|
|
}
|
|
|
|
CountrySelectActivity.Country lastMatchedCountry = null;
|
|
int matchedCountries = 0;
|
|
for (CountrySelectActivity.Country c : codesMap.values()) {
|
|
if (c.code.startsWith(text)) {
|
|
matchedCountries++;
|
|
if (c.code.equals(text)) {
|
|
lastMatchedCountry = c;
|
|
}
|
|
}
|
|
}
|
|
if (matchedCountries == 1 && lastMatchedCountry != null && textToSet == null) {
|
|
textToSet = text.substring(lastMatchedCountry.code.length()) + phoneField.getText().toString();
|
|
codeField.setText(text = lastMatchedCountry.code);
|
|
}
|
|
|
|
country = codesMap.get(text);
|
|
if (country != null) {
|
|
ignoreSelection = true;
|
|
currentCountry = country;
|
|
setCountryHint(text, country);
|
|
countryState = COUNTRY_STATE_NOT_SET_OR_VALID;
|
|
} else {
|
|
setCountryButtonText(null);
|
|
phoneField.setHintText(null);
|
|
countryState = COUNTRY_STATE_INVALID;
|
|
}
|
|
if (!ok) {
|
|
codeField.setSelection(codeField.getText().length());
|
|
}
|
|
if (textToSet != null) {
|
|
phoneField.requestFocus();
|
|
phoneField.setText(textToSet);
|
|
phoneField.setSelection(phoneField.length());
|
|
}
|
|
}
|
|
ignoreOnTextChange = false;
|
|
}
|
|
});
|
|
codeField.setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (i == EditorInfo.IME_ACTION_NEXT) {
|
|
phoneField.requestFocus();
|
|
phoneField.setSelection(phoneField.length());
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
codeDividerView = new View(context);
|
|
LayoutParams params = LayoutHelper.createLinear(0, LayoutHelper.MATCH_PARENT, 4, 8, 12, 8);
|
|
params.width = Math.max(2, AndroidUtilities.dp(0.5f));
|
|
linearLayout.addView(codeDividerView, params);
|
|
|
|
phoneField = new AnimatedPhoneNumberEditText(context) {
|
|
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent event) {
|
|
if (keyCode == KeyEvent.KEYCODE_DEL && phoneField.length() == 0) {
|
|
codeField.requestFocus();
|
|
codeField.setSelection(codeField.length());
|
|
codeField.dispatchKeyEvent(event);
|
|
}
|
|
return super.onKeyDown(keyCode, event);
|
|
}
|
|
|
|
|
|
@Override
|
|
public boolean onTouchEvent(MotionEvent event) {
|
|
if (event.getAction() == MotionEvent.ACTION_DOWN) {
|
|
if (!showKeyboard(this)) {
|
|
clearFocus();
|
|
requestFocus();
|
|
}
|
|
}
|
|
return super.onTouchEvent(event);
|
|
}
|
|
|
|
@Override
|
|
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
|
|
super.onFocusChanged(focused, direction, previouslyFocusedRect);
|
|
phoneOutlineView.animateSelection(focused || codeField.isFocused() ? 1f : 0f);
|
|
|
|
if (focused) {
|
|
keyboardView.setEditText(this);
|
|
keyboardView.setDispatchBackWhenEmpty(true);
|
|
|
|
if (countryState == COUNTRY_STATE_INVALID) {
|
|
setCountryButtonText(LocaleController.getString(R.string.WrongCountry));
|
|
}
|
|
} else {
|
|
if (countryState == COUNTRY_STATE_INVALID) {
|
|
setCountryButtonText(null);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
phoneField.setInputType(InputType.TYPE_CLASS_PHONE);
|
|
phoneField.setPadding(0, 0, 0, 0);
|
|
phoneField.setCursorSize(AndroidUtilities.dp(20));
|
|
phoneField.setCursorWidth(1.5f);
|
|
phoneField.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
phoneField.setMaxLines(1);
|
|
phoneField.setGravity(Gravity.LEFT | Gravity.CENTER_VERTICAL);
|
|
phoneField.setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
phoneField.setBackground(null);
|
|
// phoneField.setLineColors(getThemedColor(Theme.key_windowBackgroundWhiteInputField), getThemedColor(Theme.key_windowBackgroundWhiteInputFieldActivated), getThemedColor(Theme.key_windowBackgroundWhiteRedText3));
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
|
|
phoneField.setShowSoftInputOnFocus(!(hasCustomKeyboard() && !isCustomKeyboardForceDisabled()));
|
|
}
|
|
phoneField.setContentDescription(LocaleController.getString(R.string.PhoneNumber));
|
|
linearLayout.addView(phoneField, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 36));
|
|
phoneField.addTextChangedListener(new TextWatcher() {
|
|
|
|
private int characterAction = -1;
|
|
private int actionPosition;
|
|
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
if (count == 0 && after == 1) {
|
|
characterAction = 1;
|
|
} else if (count == 1 && after == 0) {
|
|
if (s.charAt(start) == ' ' && start > 0) {
|
|
characterAction = 3;
|
|
actionPosition = start - 1;
|
|
} else {
|
|
characterAction = 2;
|
|
}
|
|
} else {
|
|
characterAction = -1;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {
|
|
if (ignoreOnPhoneChange) {
|
|
return;
|
|
}
|
|
int start = phoneField.getSelectionStart();
|
|
String phoneChars = "0123456789";
|
|
String str = phoneField.getText().toString();
|
|
if (characterAction == 3) {
|
|
str = str.substring(0, actionPosition) + str.substring(actionPosition + 1);
|
|
start--;
|
|
}
|
|
StringBuilder builder = new StringBuilder(str.length());
|
|
for (int a = 0; a < str.length(); a++) {
|
|
String ch = str.substring(a, a + 1);
|
|
if (phoneChars.contains(ch)) {
|
|
builder.append(ch);
|
|
}
|
|
}
|
|
ignoreOnPhoneChange = true;
|
|
String hint = phoneField.getHintText();
|
|
if (hint != null) {
|
|
for (int a = 0; a < builder.length(); a++) {
|
|
if (a < hint.length()) {
|
|
if (hint.charAt(a) == ' ') {
|
|
builder.insert(a, ' ');
|
|
a++;
|
|
if (start == a && characterAction != 2 && characterAction != 3) {
|
|
start++;
|
|
}
|
|
}
|
|
} else {
|
|
builder.insert(a, ' ');
|
|
if (start == a + 1 && characterAction != 2 && characterAction != 3) {
|
|
start++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.replace(0, s.length(), builder);
|
|
if (start >= 0) {
|
|
phoneField.setSelection(Math.min(start, phoneField.length()));
|
|
}
|
|
phoneField.onTextChange();
|
|
ignoreOnPhoneChange = false;
|
|
}
|
|
});
|
|
phoneField.setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (i == EditorInfo.IME_ACTION_NEXT) {
|
|
if (phoneNumberConfirmView != null) {
|
|
phoneNumberConfirmView.popupFabContainer.callOnClick();
|
|
return true;
|
|
}
|
|
onNextPressed(null);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
int bottomMargin = 72;
|
|
|
|
syncContactsBox = new CheckBoxCell(context, 2);
|
|
syncContactsBox.setText(LocaleController.getString("SyncContacts", R.string.SyncContacts), "", syncContacts, false);
|
|
addView(syncContactsBox, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 16, 0, 16 + (LocaleController.isRTL && AndroidUtilities.isSmallScreen() ? Build.VERSION.SDK_INT >= 21 ? 56 : 60 : 0), 0));
|
|
bottomMargin -= 24;
|
|
syncContactsBox.setOnClickListener(v -> {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
CheckBoxCell cell = (CheckBoxCell) v;
|
|
syncContacts = !syncContacts;
|
|
cell.setChecked(syncContacts, true);
|
|
if (syncContacts) {
|
|
BulletinFactory.of(slideViewsContainer, null).createSimpleBulletin(R.raw.contacts_sync_on, LocaleController.getString("SyncContactsOn", R.string.SyncContactsOn)).show();
|
|
} else {
|
|
BulletinFactory.of(slideViewsContainer, null).createSimpleBulletin(R.raw.contacts_sync_off, LocaleController.getString("SyncContactsOff", R.string.SyncContactsOff)).show();
|
|
}
|
|
});
|
|
|
|
|
|
if (BuildVars.DEBUG_PRIVATE_VERSION) {
|
|
testBackendCheckBox = new CheckBoxCell(context, 2);
|
|
testBackendCheckBox.setText("Test Backend", "", testBackend, false);
|
|
addView(testBackendCheckBox, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.TOP, 16, 0, 16 + (LocaleController.isRTL && AndroidUtilities.isSmallScreen() ? Build.VERSION.SDK_INT >= 21 ? 56 : 60 : 0), 0));
|
|
bottomMargin -= 24;
|
|
testBackendCheckBox.setOnClickListener(v -> {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
CheckBoxCell cell = (CheckBoxCell) v;
|
|
testBackend = !testBackend;
|
|
cell.setChecked(testBackend, true);
|
|
});
|
|
}
|
|
if (bottomMargin > 0 && !AndroidUtilities.isSmallScreen()) {
|
|
Space bottomSpacer = new Space(context);
|
|
bottomSpacer.setMinimumHeight(AndroidUtilities.dp(bottomMargin));
|
|
addView(bottomSpacer, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT));
|
|
}
|
|
|
|
HashMap<String, String> languageMap = new HashMap<>();
|
|
|
|
try {
|
|
BufferedReader reader = new BufferedReader(new InputStreamReader(getResources().getAssets().open("countries.txt")));
|
|
String line;
|
|
while ((line = reader.readLine()) != null) {
|
|
String[] args = line.split(";");
|
|
CountrySelectActivity.Country countryWithCode = new CountrySelectActivity.Country();
|
|
countryWithCode.name = args[2];
|
|
countryWithCode.code = args[0];
|
|
countryWithCode.shortname = args[1];
|
|
countriesArray.add(0, countryWithCode);
|
|
codesMap.put(args[0], countryWithCode);
|
|
if (args.length > 3) {
|
|
phoneFormatMap.put(args[0], args[3]);
|
|
}
|
|
languageMap.put(args[1], args[2]);
|
|
}
|
|
reader.close();
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
|
|
Collections.sort(countriesArray, Comparator.comparing(o -> o.name));
|
|
|
|
String country = null;
|
|
|
|
// NekoX: Remove TelephonyManager
|
|
// try {
|
|
// TelephonyManager telephonyManager = (TelephonyManager) ApplicationLoader.applicationContext.getSystemService(Context.TELEPHONY_SERVICE);
|
|
// if (telephonyManager != null) {
|
|
// country = null;//telephonyManager.getSimCountryIso().toUpperCase();
|
|
// }
|
|
// } catch (Exception e) {
|
|
// FileLog.e(e);
|
|
// }
|
|
|
|
if (country != null) {
|
|
setCountry(languageMap, country.toUpperCase());
|
|
} else {
|
|
TLRPC.TL_help_getNearestDc req = new TLRPC.TL_help_getNearestDc();
|
|
getAccountInstance().getConnectionsManager().sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (response == null) {
|
|
return;
|
|
}
|
|
TLRPC.TL_nearestDc res = (TLRPC.TL_nearestDc) response;
|
|
if (codeField.length() == 0) {
|
|
setCountry(languageMap, res.country.toUpperCase());
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
}
|
|
if (codeField.length() == 0) {
|
|
setCountryButtonText(null);
|
|
phoneField.setHintText(null);
|
|
countryState = COUNTRY_STATE_EMPTY;
|
|
}
|
|
|
|
if (codeField.length() != 0) {
|
|
phoneField.requestFocus();
|
|
phoneField.setSelection(phoneField.length());
|
|
} else {
|
|
codeField.requestFocus();
|
|
}
|
|
|
|
TLRPC.TL_help_getCountriesList req = new TLRPC.TL_help_getCountriesList();
|
|
req.lang_code = "";
|
|
getConnectionsManager().sendRequest(req, (response, error) -> {
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (error == null) {
|
|
countriesArray.clear();
|
|
codesMap.clear();
|
|
phoneFormatMap.clear();
|
|
TLRPC.TL_help_countriesList help_countriesList = (TLRPC.TL_help_countriesList) response;
|
|
for (int i = 0; i < help_countriesList.countries.size(); i++) {
|
|
TLRPC.TL_help_country c = help_countriesList.countries.get(i);
|
|
for (int k = 0; k < c.country_codes.size(); k++) {
|
|
CountrySelectActivity.Country countryWithCode = new CountrySelectActivity.Country();
|
|
countryWithCode.name = c.default_name;
|
|
countryWithCode.code = c.country_codes.get(k).country_code;
|
|
countryWithCode.shortname = c.iso2;
|
|
|
|
countriesArray.add(countryWithCode);
|
|
codesMap.put(c.country_codes.get(k).country_code, countryWithCode);
|
|
if (c.country_codes.get(k).patterns.size() > 0) {
|
|
phoneFormatMap.put(c.country_codes.get(k).country_code, c.country_codes.get(k).patterns.get(0));
|
|
}
|
|
}
|
|
}
|
|
CountrySelectActivity.Country countryWithCode = new CountrySelectActivity.Country();
|
|
String test_code = "999";
|
|
countryWithCode.name = "Test Number";
|
|
countryWithCode.code = test_code;
|
|
countryWithCode.shortname = "YL";
|
|
|
|
countriesArray.add(countryWithCode);
|
|
codesMap.put(test_code, countryWithCode);
|
|
phoneFormatMap.put(test_code, "XX X XXXX");
|
|
}
|
|
});
|
|
}, ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
titleView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
subtitleView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
for (int i = 0; i < countryButton.getChildCount(); i++) {
|
|
TextView textView = (TextView) countryButton.getChildAt(i);
|
|
textView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
textView.setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
|
|
}
|
|
|
|
chevronRight.setColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
|
|
chevronRight.setBackground(Theme.createSelectorDrawable(getThemedColor(Theme.key_listSelector), 1));
|
|
|
|
plusTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
|
|
codeField.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
codeField.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated));
|
|
|
|
codeDividerView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputField));
|
|
|
|
phoneField.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
phoneField.setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
|
|
phoneField.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated));
|
|
|
|
if (syncContactsBox != null) {
|
|
syncContactsBox.setSquareCheckBoxColor(Theme.key_checkboxSquareUnchecked, Theme.key_checkboxSquareBackground, Theme.key_checkboxSquareCheck);
|
|
syncContactsBox.updateTextColor();
|
|
}
|
|
if (testBackendCheckBox != null) {
|
|
testBackendCheckBox.setSquareCheckBoxColor(Theme.key_checkboxSquareUnchecked, Theme.key_checkboxSquareBackground, Theme.key_checkboxSquareCheck);
|
|
testBackendCheckBox.updateTextColor();
|
|
}
|
|
|
|
phoneOutlineView.updateColor();
|
|
countryOutlineView.updateColor();
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomKeyboard() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
protected void onAttachedToWindow() {
|
|
super.onAttachedToWindow();
|
|
NotificationCenter.getGlobalInstance().addObserver(this, NotificationCenter.emojiLoaded);
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.emojiLoaded);
|
|
}
|
|
|
|
public void selectCountry(CountrySelectActivity.Country country) {
|
|
ignoreOnTextChange = true;
|
|
String code = country.code;
|
|
codeField.setText(code);
|
|
setCountryHint(code, country);
|
|
currentCountry = country;
|
|
countryState = COUNTRY_STATE_NOT_SET_OR_VALID;
|
|
ignoreOnTextChange = false;
|
|
}
|
|
|
|
private void setCountryHint(String code, CountrySelectActivity.Country country) {
|
|
SpannableStringBuilder sb = new SpannableStringBuilder();
|
|
String flag = LocaleController.getLanguageFlag(country.shortname);
|
|
if (flag != null) {
|
|
sb.append(flag).append(" ");
|
|
sb.setSpan(new ReplacementSpan() {
|
|
@Override
|
|
public int getSize(@NonNull Paint paint, CharSequence text, int start, int end, @Nullable Paint.FontMetricsInt fm) {
|
|
return AndroidUtilities.dp(16);
|
|
}
|
|
|
|
@Override
|
|
public void draw(@NonNull Canvas canvas, CharSequence text, int start, int end, float x, int top, int y, int bottom, @NonNull Paint paint) {}
|
|
}, flag.length(), flag.length() + 1, 0);
|
|
}
|
|
sb.append(country.name);
|
|
setCountryButtonText(Emoji.replaceEmoji(sb, countryButton.getCurrentView().getPaint().getFontMetricsInt(), AndroidUtilities.dp(20), false));
|
|
String hint = phoneFormatMap.get(code);
|
|
phoneField.setHintText(hint != null ? hint.replace('X', '0') : null);
|
|
}
|
|
|
|
private void setCountryButtonText(CharSequence cs) {
|
|
Animation anim = AnimationUtils.loadAnimation(ApplicationLoader.applicationContext, countryButton.getCurrentView().getText() != null && cs == null ? R.anim.text_out_down : R.anim.text_out);
|
|
anim.setInterpolator(Easings.easeInOutQuad);
|
|
countryButton.setOutAnimation(anim);
|
|
|
|
CharSequence prevText = countryButton.getCurrentView().getText();
|
|
countryButton.setText(cs, !(TextUtils.isEmpty(cs) && TextUtils.isEmpty(prevText)) && !Objects.equals(prevText, cs));
|
|
countryOutlineView.animateSelection(cs != null ? 1f : 0f);
|
|
}
|
|
|
|
private void setCountry(HashMap<String, String> languageMap, String country) {
|
|
String name = languageMap.get(country);
|
|
if (name != null && countriesArray != null) {
|
|
CountrySelectActivity.Country countryWithCode = null;
|
|
for (int i = 0; i < countriesArray.size(); i++) {
|
|
if (countriesArray.get(i) != null && countriesArray.get(i).name.equals(country)) {
|
|
countryWithCode = countriesArray.get(i);
|
|
break;
|
|
}
|
|
}
|
|
if (countryWithCode != null) {
|
|
codeField.setText(countryWithCode.code);
|
|
countryState = COUNTRY_STATE_NOT_SET_OR_VALID;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
@Override
|
|
public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
|
|
if (ignoreSelection) {
|
|
ignoreSelection = false;
|
|
return;
|
|
}
|
|
ignoreOnTextChange = true;
|
|
CountrySelectActivity.Country countryWithCode = countriesArray.get(i);
|
|
codeField.setText(countryWithCode.code);
|
|
ignoreOnTextChange = false;
|
|
}
|
|
|
|
@Override
|
|
public void onNothingSelected(AdapterView<?> adapterView) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (getParentActivity() == null || nextPressed) {
|
|
return;
|
|
}
|
|
|
|
// TelephonyManager tm = (TelephonyManager) ApplicationLoader.applicationContext.getSystemService(Context.TELEPHONY_SERVICE);
|
|
// if (BuildVars.DEBUG_VERSION) {
|
|
// FileLog.d("sim status = " + tm.getSimState());
|
|
// }
|
|
if (codeField.length() == 0 || phoneField.length() == 0) {
|
|
onFieldError(phoneOutlineView, false);
|
|
return;
|
|
}
|
|
String phoneNumber = "+" + codeField.getText() + " " + phoneField.getText();
|
|
String hintText = phoneField.getHintText();
|
|
int hintLength = hintText != null ? hintText.length() : 0;
|
|
PhoneNumberExclusionRule exclusionRule = phoneNumberExclusionRules.get(codeField.getText().toString());
|
|
if (exclusionRule != null) {
|
|
hintLength = exclusionRule.modifyHintLengthRequirement(hintLength);
|
|
}
|
|
if (hintText != null && phoneField.length() < hintLength) {
|
|
new AlertDialog.Builder(getParentActivity())
|
|
.setTitle(LocaleController.getString(R.string.WrongNumberFormat))
|
|
.setMessage(AndroidUtilities.replaceTags(LocaleController.formatString("ShortNumberInfo", R.string.ShortNumberInfo, currentCountry.name, phoneNumber)))
|
|
.setPositiveButton(LocaleController.getString(R.string.OK), null)
|
|
.setNegativeButton(LocaleController.getString(R.string.SettingsHelp), (dialog, which) -> {
|
|
try {
|
|
getParentActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://telegram.org/faq")));
|
|
} catch (ActivityNotFoundException ignored) {}
|
|
}).show();
|
|
return;
|
|
}
|
|
|
|
if (!confirmedNumber) {
|
|
if (AndroidUtilities.displaySize.x > AndroidUtilities.displaySize.y && !isCustomKeyboardVisible() && sizeNotifierFrameLayout.measureKeyboardHeight() > AndroidUtilities.dp(20)) {
|
|
keyboardHideCallback = () -> postDelayed(()-> onNextPressed(code), 200);
|
|
AndroidUtilities.hideKeyboard(fragmentView);
|
|
return;
|
|
}
|
|
|
|
phoneNumberConfirmView = new PhoneNumberConfirmView(fragmentView.getContext(), (ViewGroup) fragmentView, floatingButtonContainer, phoneNumber, new PhoneNumberConfirmView.IConfirmDialogCallback() {
|
|
@Override
|
|
public void onFabPressed(PhoneNumberConfirmView confirmView, TransformableLoginButtonView fab) {
|
|
onConfirm(confirmView);
|
|
}
|
|
|
|
@Override
|
|
public void onEditPressed(PhoneNumberConfirmView confirmView, TextView editTextView) {
|
|
confirmView.dismiss();
|
|
}
|
|
|
|
@Override
|
|
public void onConfirmPressed(PhoneNumberConfirmView confirmView, TextView confirmTextView) {
|
|
onConfirm(confirmView);
|
|
}
|
|
|
|
@Override
|
|
public void onDismiss(PhoneNumberConfirmView confirmView) {
|
|
phoneNumberConfirmView = null;
|
|
}
|
|
|
|
private void onConfirm(PhoneNumberConfirmView confirmView) {
|
|
confirmedNumber = true;
|
|
currentDoneType = DONE_TYPE_FLOATING;
|
|
needShowProgress(0, false);
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && AndroidUtilities.isSimAvailable()) {
|
|
boolean allowCall = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED;
|
|
boolean allowCancelCall = getParentActivity().checkSelfPermission(Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED;
|
|
boolean allowReadCallLog = Build.VERSION.SDK_INT < Build.VERSION_CODES.P || getParentActivity().checkSelfPermission(Manifest.permission.READ_CALL_LOG) == PackageManager.PERMISSION_GRANTED;
|
|
boolean allowReadPhoneNumbers = Build.VERSION.SDK_INT < Build.VERSION_CODES.O || getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_NUMBERS) == PackageManager.PERMISSION_GRANTED;;
|
|
if (checkPermissions) {
|
|
permissionsItems.clear();
|
|
if (!allowCall) {
|
|
permissionsItems.add(Manifest.permission.READ_PHONE_STATE);
|
|
}
|
|
if (!allowCancelCall) {
|
|
permissionsItems.add(Manifest.permission.CALL_PHONE);
|
|
}
|
|
if (!allowReadCallLog) {
|
|
permissionsItems.add(Manifest.permission.READ_CALL_LOG);
|
|
}
|
|
if (!allowReadPhoneNumbers && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
permissionsItems.add(Manifest.permission.READ_PHONE_NUMBERS);
|
|
}
|
|
if (!permissionsItems.isEmpty()) {
|
|
SharedPreferences preferences = MessagesController.getGlobalMainSettings();
|
|
if (preferences.getBoolean("firstlogin", true) || getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_PHONE_STATE) || getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_CALL_LOG)) {
|
|
preferences.edit().putBoolean("firstlogin", false).commit();
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
|
|
builder.setPositiveButton(LocaleController.getString("Continue", R.string.Continue), null);
|
|
int resId;
|
|
if (!allowCall && (!allowCancelCall || !allowReadCallLog)) {
|
|
builder.setMessage(LocaleController.getString("AllowReadCallAndLog", R.string.AllowReadCallAndLog));
|
|
resId = R.raw.calls_log;
|
|
} else if (!allowCancelCall || !allowReadCallLog) {
|
|
builder.setMessage(LocaleController.getString("AllowReadCallLog", R.string.AllowReadCallLog));
|
|
resId = R.raw.calls_log;
|
|
} else {
|
|
builder.setMessage(LocaleController.getString("AllowReadCall", R.string.AllowReadCall));
|
|
resId = R.raw.incoming_calls;
|
|
}
|
|
builder.setTopAnimation(resId, 46, false, Theme.getColor(Theme.key_dialogTopBackground));
|
|
permissionsDialog = showDialog(builder.create());
|
|
confirmedNumber = true;
|
|
} else {
|
|
try {
|
|
getParentActivity().requestPermissions(permissionsItems.toArray(new String[0]), 6);
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
confirmView.animateProgress(()->{
|
|
confirmView.dismiss();
|
|
AndroidUtilities.runOnUIThread(()-> {
|
|
onNextPressed(code);
|
|
floatingProgressView.sync(confirmView.floatingProgressView);
|
|
}, 150);
|
|
});
|
|
}
|
|
});
|
|
phoneNumberConfirmView.show();
|
|
return;
|
|
} else confirmedNumber = false;
|
|
|
|
if (phoneNumberConfirmView != null) {
|
|
phoneNumberConfirmView.dismiss();
|
|
}
|
|
|
|
boolean simcardAvailable = AndroidUtilities.isSimAvailable();
|
|
boolean allowCall = true;
|
|
boolean allowCancelCall = true;
|
|
boolean allowReadCallLog = true;
|
|
boolean allowReadPhoneNumbers = true;
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && simcardAvailable) {
|
|
allowCall = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED;
|
|
allowCancelCall = getParentActivity().checkSelfPermission(Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED;
|
|
allowReadCallLog = Build.VERSION.SDK_INT < Build.VERSION_CODES.P || getParentActivity().checkSelfPermission(Manifest.permission.READ_CALL_LOG) == PackageManager.PERMISSION_GRANTED;
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
allowReadPhoneNumbers = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_NUMBERS) == PackageManager.PERMISSION_GRANTED;
|
|
}
|
|
if (checkPermissions) {
|
|
permissionsItems.clear();
|
|
if (!allowCall) {
|
|
permissionsItems.add(Manifest.permission.READ_PHONE_STATE);
|
|
}
|
|
if (!allowCancelCall) {
|
|
permissionsItems.add(Manifest.permission.CALL_PHONE);
|
|
}
|
|
if (!allowReadCallLog) {
|
|
permissionsItems.add(Manifest.permission.READ_CALL_LOG);
|
|
}
|
|
if (!allowReadPhoneNumbers && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
permissionsItems.add(Manifest.permission.READ_PHONE_NUMBERS);
|
|
}
|
|
if (!permissionsItems.isEmpty()) {
|
|
SharedPreferences preferences = MessagesController.getGlobalMainSettings();
|
|
if (preferences.getBoolean("firstlogin", true) || getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_PHONE_STATE) || getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_CALL_LOG)) {
|
|
preferences.edit().putBoolean("firstlogin", false).commit();
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
|
|
builder.setPositiveButton(LocaleController.getString("Continue", R.string.Continue), null);
|
|
int resId;
|
|
if (!allowCall && (!allowCancelCall || !allowReadCallLog)) {
|
|
builder.setMessage(LocaleController.getString("AllowReadCallAndLog", R.string.AllowReadCallAndLog));
|
|
resId = R.raw.calls_log;
|
|
} else if (!allowCancelCall || !allowReadCallLog) {
|
|
builder.setMessage(LocaleController.getString("AllowReadCallLog", R.string.AllowReadCallLog));
|
|
resId = R.raw.calls_log;
|
|
} else {
|
|
builder.setMessage(LocaleController.getString("AllowReadCall", R.string.AllowReadCall));
|
|
resId = R.raw.incoming_calls;
|
|
}
|
|
builder.setTopAnimation(resId, 46, false, Theme.getColor(Theme.key_dialogTopBackground));
|
|
permissionsDialog = showDialog(builder.create());
|
|
confirmedNumber = true;
|
|
} else {
|
|
try {
|
|
getParentActivity().requestPermissions(permissionsItems.toArray(new String[0]), 6);
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (countryState == COUNTRY_STATE_EMPTY) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("ChooseCountry", R.string.ChooseCountry));
|
|
needHideProgress(false);
|
|
return;
|
|
} else if (countryState == COUNTRY_STATE_INVALID && !BuildVars.DEBUG_VERSION) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("WrongCountry", R.string.WrongCountry));
|
|
needHideProgress(false);
|
|
return;
|
|
}
|
|
String phone = PhoneFormat.stripExceptNumbers("" + codeField.getText() + phoneField.getText());
|
|
if (!testBackend && "999".equals(codeField.getText().toString())) {
|
|
testBackend = true;
|
|
if (testBackendCheckBox != null) {
|
|
testBackendCheckBox.setChecked(true, true);
|
|
}
|
|
}
|
|
boolean testBackend = /*BuildVars.DEBUG_PRIVATE_VERSION && */getConnectionsManager().isTestBackend();
|
|
if (testBackend != LoginActivity.this.testBackend) {
|
|
getConnectionsManager().switchBackend(false);
|
|
testBackend = LoginActivity.this.testBackend;
|
|
}
|
|
if (getParentActivity() instanceof LaunchActivity) {
|
|
for (int a : SharedConfig.activeAccounts) {
|
|
UserConfig userConfig = UserConfig.getInstance(a);
|
|
if (!userConfig.isClientActivated()) {
|
|
continue;
|
|
}
|
|
String userPhone = userConfig.getCurrentUser().phone;
|
|
if (PhoneNumberUtils.compare(phone, userPhone) && ConnectionsManager.getInstance(a).isTestBackend() == testBackend) {
|
|
final int num = a;
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setTitle(LocaleController.getString(R.string.NekoX));
|
|
builder.setMessage(LocaleController.getString("AccountAlreadyLoggedIn", R.string.AccountAlreadyLoggedIn));
|
|
builder.setPositiveButton(LocaleController.getString("AccountSwitch", R.string.AccountSwitch), (dialog, which) -> {
|
|
if (UserConfig.selectedAccount != num) {
|
|
((LaunchActivity) getParentActivity()).switchToAccount(num, false);
|
|
}
|
|
finishFragment();
|
|
});
|
|
builder.setNegativeButton(LocaleController.getString("OK", R.string.OK), null);
|
|
showDialog(builder.create());
|
|
needHideProgress(false);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
ConnectionsManager.getInstance(currentAccount).cleanup(false);
|
|
final TLRPC.TL_auth_sendCode req = new TLRPC.TL_auth_sendCode();
|
|
req.api_hash = NekoXConfig.currentAppHash();
|
|
req.api_id = NekoXConfig.currentAppId();
|
|
req.phone_number = phone;
|
|
req.settings = new TLRPC.TL_codeSettings();
|
|
req.settings.allow_flashcall = simcardAvailable && allowCall && allowCancelCall && allowReadCallLog;
|
|
req.settings.allow_missed_call = simcardAvailable && allowCall;
|
|
req.settings.allow_app_hash = ApplicationLoader.hasPlayServices;
|
|
ArrayList<TLRPC.TL_auth_loggedOut> tokens = MessagesController.getSavedLogOutTokens();
|
|
if (tokens != null) {
|
|
for (int i = 0; i < tokens.size(); i++) {
|
|
if (req.settings.logout_tokens == null) {
|
|
req.settings.logout_tokens = new ArrayList<>();
|
|
}
|
|
req.settings.logout_tokens.add(tokens.get(i).future_auth_token);
|
|
}
|
|
MessagesController.saveLogOutTokens(tokens);
|
|
}
|
|
if (req.settings.logout_tokens != null) {
|
|
req.settings.flags |= 64;
|
|
}
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("mainconfig", Activity.MODE_PRIVATE);
|
|
if (req.settings.allow_flashcall) {
|
|
try {
|
|
String number = "";
|
|
if (!TextUtils.isEmpty(number)) {
|
|
req.settings.current_number = PhoneNumberUtils.compare(phone, number);
|
|
if (!req.settings.current_number) {
|
|
req.settings.allow_flashcall = false;
|
|
}
|
|
} else {
|
|
if (UserConfig.getActivatedAccountsCount() > 0) {
|
|
req.settings.allow_flashcall = false;
|
|
} else {
|
|
req.settings.current_number = false;
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
req.settings.allow_flashcall = false;
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
final Bundle params = new Bundle();
|
|
params.putString("phone", "+" + codeField.getText() + " " + phoneField.getText());
|
|
try {
|
|
params.putString("ephone", "+" + PhoneFormat.stripExceptNumbers(codeField.getText().toString()) + " " + PhoneFormat.stripExceptNumbers(phoneField.getText().toString()));
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
params.putString("ephone", "+" + phone);
|
|
}
|
|
params.putString("phoneFormated", phone);
|
|
nextPressed = true;
|
|
int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
if (error == null) {
|
|
fillNextCodeParams(params, (TLRPC.TL_auth_sentCode) response);
|
|
if (phone.startsWith("99966")) {
|
|
fillNextCodeParamsSilent(params, (TLRPC.TL_auth_sentCode) response);
|
|
String phoneHash = ((TLRPC.TL_auth_sentCode) response).phone_code_hash;
|
|
String dcId = phone.substring(5, 6);
|
|
final TLRPC.TL_auth_signIn reqI = new TLRPC.TL_auth_signIn();
|
|
reqI.phone_number = phone;
|
|
reqI.phone_code = dcId + dcId + dcId + dcId + dcId;
|
|
reqI.phone_code_hash = phoneHash;
|
|
int reqIdI = ConnectionsManager.getInstance(currentAccount).sendRequest(reqI, (responseI, errorI) -> AndroidUtilities.runOnUIThread(() -> {
|
|
boolean ok = false;
|
|
if (errorI == null) {
|
|
nextPressed = false;
|
|
ok = true;
|
|
showDoneButton(false, true);
|
|
if (responseI instanceof TLRPC.TL_auth_authorizationSignUpRequired) {
|
|
TLRPC.TL_auth_authorizationSignUpRequired authorization = (TLRPC.TL_auth_authorizationSignUpRequired) responseI;
|
|
if (authorization.terms_of_service != null) {
|
|
currentTermsOfService = authorization.terms_of_service;
|
|
}
|
|
Bundle paramsI = new Bundle();
|
|
paramsI.putString("phoneFormated", phone);
|
|
paramsI.putString("phoneHash", phoneHash);
|
|
paramsI.putString("code", reqI.phone_code);
|
|
setPage(VIEW_REGISTER, true, params, false);
|
|
} else {
|
|
onAuthSuccess((TLRPC.TL_auth_authorization) responseI);
|
|
}
|
|
} else {
|
|
if (errorI.text.contains("SESSION_PASSWORD_NEEDED")) {
|
|
ok = true;
|
|
TLRPC.TL_account_getPassword req2 = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req2, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
showDoneButton(false, true);
|
|
if (error1 == null) {
|
|
TLRPC.TL_account_password password = (TLRPC.TL_account_password) response1;
|
|
if (!TwoStepVerificationActivity.canHandleCurrentPassword(password, true)) {
|
|
AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
|
|
return;
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
SerializedData data = new SerializedData(password.getObjectSize());
|
|
password.serializeToStream(data);
|
|
bundle.putString("password", Utilities.bytesToHex(data.toByteArray()));
|
|
bundle.putString("phoneFormated", phone);
|
|
bundle.putString("phoneHash", phoneHash);
|
|
bundle.putString("code", reqI.phone_code);
|
|
setPage(6, true, bundle, false);
|
|
} else {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), error1.text);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else {
|
|
nextPressed = false;
|
|
showDoneButton(false, true);
|
|
|
|
if (errorI.text.contains("PHONE_NUMBER_INVALID")) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("InvalidPhoneNumber", R.string.InvalidPhoneNumber));
|
|
} else if (errorI.text.contains("PHONE_CODE_EMPTY") || errorI.text.contains("PHONE_CODE_INVALID")) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("InvalidCode", R.string.InvalidCode));
|
|
} else if (errorI.text.contains("PHONE_CODE_EXPIRED")) {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("CodeExpired", R.string.CodeExpired));
|
|
} else if (errorI.text.startsWith("FLOOD_WAIT")) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("ErrorOccurred", R.string.ErrorOccurred) + "\n" + errorI.text);
|
|
}
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
needShowProgress(reqIdI, false);
|
|
showDoneButton(true, true);
|
|
return;
|
|
}
|
|
} else {
|
|
if (error.text != null) {
|
|
if (error.text.contains("SESSION_PASSWORD_NEEDED")) {
|
|
TLRPC.TL_account_getPassword req2 = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req2, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
showDoneButton(false, true);
|
|
if (error1 == null) {
|
|
TLRPC.TL_account_password password = (TLRPC.TL_account_password) response1;
|
|
if (!TwoStepVerificationActivity.canHandleCurrentPassword(password, true)) {
|
|
AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
|
|
return;
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
SerializedData data = new SerializedData(password.getObjectSize());
|
|
password.serializeToStream(data);
|
|
bundle.putString("password", Utilities.bytesToHex(data.toByteArray()));
|
|
bundle.putString("phoneFormated", phone);
|
|
setPage(VIEW_PASSWORD, true, bundle, false);
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error1.text);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else if (error.text.contains("PHONE_NUMBER_INVALID")) {
|
|
needShowInvalidAlert(LoginActivity.this, req.phone_number, false);
|
|
} else if (error.text.contains("PHONE_PASSWORD_FLOOD")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else if (error.text.contains("PHONE_NUMBER_FLOOD")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("PhoneNumberFlood", R.string.PhoneNumberFlood));
|
|
} else if (error.text.contains("PHONE_NUMBER_BANNED")) {
|
|
needShowInvalidAlert(LoginActivity.this, req.phone_number, true);
|
|
} else if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidCode", R.string.InvalidCode));
|
|
} else if (error.text.contains("PHONE_CODE_EXPIRED")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("CodeExpired", R.string.CodeExpired));
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else if (error.code != -1000) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}
|
|
needHideProgress(false);
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagTryDifferentDc | ConnectionsManager.RequestFlagEnableUnauthorized);
|
|
needShowProgress(reqId);
|
|
}
|
|
|
|
private boolean numberFilled;
|
|
public void fillNumber() {
|
|
if (numberFilled) {
|
|
return;
|
|
}
|
|
try {
|
|
// TelephonyManager tm = (TelephonyManager) ApplicationLoader.applicationContext.getSystemService(Context.TELEPHONY_SERVICE);
|
|
if (AndroidUtilities.isSimAvailable()) {
|
|
boolean allowCall = true;
|
|
boolean allowReadPhoneNumbers = true;
|
|
if (Build.VERSION.SDK_INT >= 23) {
|
|
allowCall = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED;
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
allowReadPhoneNumbers = getParentActivity().checkSelfPermission(Manifest.permission.READ_PHONE_NUMBERS) == PackageManager.PERMISSION_GRANTED;
|
|
}
|
|
if (checkShowPermissions && (!allowCall || !allowReadPhoneNumbers)) {
|
|
permissionsShowItems.clear();
|
|
if (!allowCall) {
|
|
permissionsShowItems.add(Manifest.permission.READ_PHONE_STATE);
|
|
}
|
|
if (!allowReadPhoneNumbers && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
permissionsShowItems.add(Manifest.permission.READ_PHONE_NUMBERS);
|
|
}
|
|
if (!permissionsShowItems.isEmpty()) {
|
|
List<String> callbackPermissionItems = new ArrayList<>(permissionsShowItems);
|
|
Runnable r = () -> {
|
|
SharedPreferences preferences = MessagesController.getGlobalMainSettings();
|
|
if (preferences.getBoolean("firstloginshow", true) || getParentActivity().shouldShowRequestPermissionRationale(Manifest.permission.READ_PHONE_STATE)) {
|
|
preferences.edit().putBoolean("firstloginshow", false).commit();
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
|
|
builder.setTopAnimation(R.raw.incoming_calls, 46, false, Theme.getColor(Theme.key_dialogTopBackground));
|
|
builder.setPositiveButton(LocaleController.getString("Continue", R.string.Continue), null);
|
|
builder.setMessage(LocaleController.getString("AllowFillNumber", R.string.AllowFillNumber));
|
|
permissionsShowDialog = showDialog(builder.create(), true, null);
|
|
needRequestPermissions = true;
|
|
} else {
|
|
getParentActivity().requestPermissions(callbackPermissionItems.toArray(new String[0]), BasePermissionsActivity.REQUEST_CODE_CALLS);
|
|
}
|
|
};
|
|
if (isAnimatingIntro) {
|
|
animationFinishCallback = r;
|
|
} else {
|
|
r.run();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
numberFilled = true;
|
|
if (!newAccount && allowCall && allowReadPhoneNumbers) {
|
|
codeField.setAlpha(0);
|
|
phoneField.setAlpha(0);
|
|
|
|
String number = "";
|
|
String textToSet = null;
|
|
boolean ok = false;
|
|
if (!TextUtils.isEmpty(number)) {
|
|
if (number.length() > 4) {
|
|
for (int a = 4; a >= 1; a--) {
|
|
String sub = number.substring(0, a);
|
|
CountrySelectActivity.Country country = codesMap.get(sub);
|
|
if (country != null) {
|
|
ok = true;
|
|
textToSet = number.substring(a);
|
|
codeField.setText(sub);
|
|
break;
|
|
}
|
|
}
|
|
if (!ok) {
|
|
textToSet = number.substring(1);
|
|
codeField.setText(number.substring(0, 1));
|
|
}
|
|
}
|
|
if (textToSet != null) {
|
|
phoneField.requestFocus();
|
|
phoneField.setText(textToSet);
|
|
phoneField.setSelection(phoneField.length());
|
|
}
|
|
}
|
|
|
|
if (phoneField.length() > 0) {
|
|
AnimatorSet set = new AnimatorSet().setDuration(300);
|
|
set.playTogether(ObjectAnimator.ofFloat(codeField, View.ALPHA, 1f),
|
|
ObjectAnimator.ofFloat(phoneField, View.ALPHA, 1f));
|
|
set.start();
|
|
|
|
confirmedNumber = true;
|
|
} else {
|
|
codeField.setAlpha(1);
|
|
phoneField.setAlpha(1);
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
fillNumber();
|
|
if (syncContactsBox != null) {
|
|
syncContactsBox.setChecked(syncContacts, false);
|
|
}
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (phoneField != null) {
|
|
if (needRequestPermissions) {
|
|
codeField.clearFocus();
|
|
phoneField.clearFocus();
|
|
} else {
|
|
if (codeField.length() != 0) {
|
|
phoneField.requestFocus();
|
|
if (!numberFilled) {
|
|
phoneField.setSelection(phoneField.length());
|
|
}
|
|
showKeyboard(phoneField);
|
|
} else {
|
|
codeField.requestFocus();
|
|
showKeyboard(codeField);
|
|
}
|
|
}
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("YourPhone", R.string.YourPhone);
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
String code = codeField.getText().toString();
|
|
if (code.length() != 0) {
|
|
bundle.putString("phoneview_code", code);
|
|
}
|
|
String phone = phoneField.getText().toString();
|
|
if (phone.length() != 0) {
|
|
bundle.putString("phoneview_phone", phone);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
String code = bundle.getString("phoneview_code");
|
|
if (code != null) {
|
|
codeField.setText(code);
|
|
}
|
|
String phone = bundle.getString("phoneview_phone");
|
|
if (phone != null) {
|
|
phoneField.setText(phone);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void didReceivedNotification(int id, int account, Object... args) {
|
|
if (id == NotificationCenter.emojiLoaded) {
|
|
countryButton.getCurrentView().invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivitySmsView extends SlideView implements NotificationCenter.NotificationCenterDelegate {
|
|
/* package */ RLottieDrawable hintDrawable;
|
|
|
|
private String phone;
|
|
private String phoneHash;
|
|
private String requestPhone;
|
|
private String emailPhone;
|
|
private CodeFieldContainer codeFieldContainer;
|
|
private TextView confirmTextView;
|
|
private TextView titleTextView;
|
|
private ImageView blackImageView;
|
|
private RLottieImageView blueImageView;
|
|
private TextView timeText;
|
|
|
|
private FrameLayout bottomContainer;
|
|
private ViewSwitcher errorViewSwitcher;
|
|
private TextView problemText;
|
|
private FrameLayout problemFrame;
|
|
private TextView wrongCode;
|
|
|
|
private Bundle currentParams;
|
|
private ProgressView progressView;
|
|
private TextView prefixTextView;
|
|
|
|
private TextView missedCallDescriptionSubtitle;
|
|
private ImageView missedCallArrowIcon, missedCallPhoneIcon;
|
|
|
|
private RLottieDrawable starsToDotsDrawable;
|
|
private RLottieDrawable dotsDrawable;
|
|
private RLottieDrawable dotsToStarsDrawable;
|
|
private boolean isDotsAnimationVisible;
|
|
|
|
private Timer timeTimer;
|
|
private Timer codeTimer;
|
|
private int openTime;
|
|
private final Object timerSync = new Object();
|
|
private int time = 60000;
|
|
private int codeTime = 15000;
|
|
private double lastCurrentTime;
|
|
private double lastCodeTime;
|
|
private boolean ignoreOnTextChange;
|
|
private boolean waitingForEvent;
|
|
private boolean nextPressed;
|
|
private String lastError = "";
|
|
|
|
@AuthType
|
|
private int currentType;
|
|
@AuthType
|
|
private int nextType;
|
|
|
|
private String pattern = "*";
|
|
private String prefix = "";
|
|
private String catchedPhone;
|
|
private int length;
|
|
|
|
private boolean postedErrorColorTimeout;
|
|
private Runnable errorColorTimeout = () -> {
|
|
postedErrorColorTimeout = false;
|
|
for (int i = 0; i < codeFieldContainer.codeField.length; i++) {
|
|
codeFieldContainer.codeField[i].animateErrorProgress(0);
|
|
}
|
|
|
|
if (errorViewSwitcher.getCurrentView() != problemFrame) {
|
|
errorViewSwitcher.showNext();
|
|
}
|
|
};
|
|
|
|
public LoginActivitySmsView(Context context, @AuthType int type) {
|
|
super(context);
|
|
|
|
currentType = type;
|
|
setOrientation(VERTICAL);
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
|
|
titleTextView = new TextView(context);
|
|
titleTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleTextView.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
|
|
titleTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
titleTextView.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
|
|
|
|
String overrideTitle = cancelAccountDeletionMode ? LocaleController.getString(R.string.CancelAccountReset) : null;
|
|
FrameLayout centerContainer = null;
|
|
if (currentType == AUTH_TYPE_MISSED_CALL) {
|
|
titleTextView.setText(overrideTitle != null ? overrideTitle : LocaleController.getString("MissedCallDescriptionTitle", R.string.MissedCallDescriptionTitle));
|
|
|
|
FrameLayout frameLayout = new FrameLayout(context);
|
|
missedCallArrowIcon = new ImageView(context);
|
|
missedCallPhoneIcon = new ImageView(context);
|
|
frameLayout.addView(missedCallArrowIcon);
|
|
frameLayout.addView(missedCallPhoneIcon);
|
|
|
|
missedCallArrowIcon.setImageResource(R.drawable.login_arrow1);
|
|
missedCallPhoneIcon.setImageResource(R.drawable.login_phone1);
|
|
|
|
addView(frameLayout, LayoutHelper.createLinear(64, 64, Gravity.CENTER_HORIZONTAL, 0, 16, 0, 0));
|
|
addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 8, 0, 0));
|
|
|
|
missedCallDescriptionSubtitle = new TextView(context);
|
|
missedCallDescriptionSubtitle.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
missedCallDescriptionSubtitle.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
missedCallDescriptionSubtitle.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
missedCallDescriptionSubtitle.setText(AndroidUtilities.replaceTags(LocaleController.getString("MissedCallDescriptionSubtitle", R.string.MissedCallDescriptionSubtitle)));
|
|
|
|
addView(missedCallDescriptionSubtitle, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 36, 16, 36, 0));
|
|
|
|
codeFieldContainer = new CodeFieldContainer(context) {
|
|
@Override
|
|
protected void processNextPressed() {
|
|
onNextPressed(null);
|
|
}
|
|
};
|
|
|
|
LinearLayout linearLayout = new LinearLayout(context);
|
|
linearLayout.setOrientation(LinearLayout.HORIZONTAL);
|
|
prefixTextView = new TextView(context);
|
|
prefixTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 20);
|
|
prefixTextView.setMaxLines(1);
|
|
prefixTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
prefixTextView.setPadding(0, 0, 0, 0);
|
|
prefixTextView.setGravity(Gravity.CENTER_VERTICAL);
|
|
|
|
linearLayout.addView(prefixTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.MATCH_PARENT, Gravity.CENTER_VERTICAL, 0, 0, 4, 0));
|
|
linearLayout.addView(codeFieldContainer, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
addView(linearLayout, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 34, Gravity.CENTER_HORIZONTAL, 0, 28, 0, 0));
|
|
|
|
missedCallDescriptionSubtitle = new TextView(context);
|
|
missedCallDescriptionSubtitle.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
missedCallDescriptionSubtitle.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
missedCallDescriptionSubtitle.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
missedCallDescriptionSubtitle.setText(AndroidUtilities.replaceTags(LocaleController.getString("MissedCallDescriptionSubtitle2", R.string.MissedCallDescriptionSubtitle2)));
|
|
|
|
addView(missedCallDescriptionSubtitle, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 36, 28, 36, 12));
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
confirmTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
centerContainer = new FrameLayout(context);
|
|
addView(centerContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 0, 1f));
|
|
|
|
LinearLayout innerLinearLayout = new LinearLayout(context);
|
|
innerLinearLayout.setOrientation(VERTICAL);
|
|
innerLinearLayout.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
centerContainer.addView(innerLinearLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER));
|
|
FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) innerLinearLayout.getLayoutParams();
|
|
layoutParams.bottomMargin = AndroidUtilities.isTablet() ? 0 : AndroidUtilities.statusBarHeight;
|
|
|
|
FrameLayout frameLayout = new FrameLayout(context);
|
|
innerLinearLayout.addView(frameLayout, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL));
|
|
|
|
blueImageView = new RLottieImageView(context);
|
|
hintDrawable = new RLottieDrawable(R.raw.phone_flash_call, String.valueOf(R.raw.phone_flash_call), AndroidUtilities.dp(64), AndroidUtilities.dp(64), true, null);
|
|
blueImageView.setAnimation(hintDrawable);
|
|
frameLayout.addView(blueImageView, LayoutHelper.createFrame(64, 64));
|
|
|
|
titleTextView.setText(overrideTitle != null ? overrideTitle : LocaleController.getString(R.string.YourCode));
|
|
innerLinearLayout.addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 0, 16, 0, 0));
|
|
innerLinearLayout.addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 0, 8, 0, 0));
|
|
} else {
|
|
confirmTextView.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
|
|
|
|
FrameLayout frameLayout = new FrameLayout(context);
|
|
addView(frameLayout, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL, 0, 16, 0, 0));
|
|
|
|
int size = currentType == AUTH_TYPE_MESSAGE ? 128 : 64;
|
|
if (currentType == AUTH_TYPE_MESSAGE) {
|
|
hintDrawable = new RLottieDrawable(R.raw.code_laptop, String.valueOf(R.raw.code_laptop), AndroidUtilities.dp(size), AndroidUtilities.dp(size), true, null);
|
|
} else {
|
|
hintDrawable = new RLottieDrawable(R.raw.sms_incoming_info, String.valueOf(R.raw.sms_incoming_info), AndroidUtilities.dp(size), AndroidUtilities.dp(size), true, null);
|
|
|
|
starsToDotsDrawable = new RLottieDrawable(R.raw.phone_stars_to_dots, String.valueOf(R.raw.phone_stars_to_dots), AndroidUtilities.dp(size), AndroidUtilities.dp(size), true, null);
|
|
dotsDrawable = new RLottieDrawable(R.raw.phone_dots, String.valueOf(R.raw.phone_dots), AndroidUtilities.dp(size), AndroidUtilities.dp(size), true, null);
|
|
dotsToStarsDrawable = new RLottieDrawable(R.raw.phone_dots_to_stars, String.valueOf(R.raw.phone_dots_to_stars), AndroidUtilities.dp(size), AndroidUtilities.dp(size), true, null);
|
|
}
|
|
blueImageView = new RLottieImageView(context);
|
|
blueImageView.setAnimation(hintDrawable);
|
|
if (currentType == AUTH_TYPE_MESSAGE && !AndroidUtilities.isSmallScreen()) {
|
|
blueImageView.setTranslationY(-AndroidUtilities.dp(24));
|
|
}
|
|
frameLayout.addView(blueImageView, LayoutHelper.createFrame(size, size, Gravity.LEFT | Gravity.TOP, 0, 0, 0, currentType == AUTH_TYPE_MESSAGE && !AndroidUtilities.isSmallScreen() ? -AndroidUtilities.dp(16) : 0));
|
|
titleTextView.setText(overrideTitle != null ? overrideTitle : LocaleController.getString(currentType == AUTH_TYPE_MESSAGE ? R.string.SentAppCodeTitle : R.string.SentSmsCodeTitle));
|
|
addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 18, 0, 0));
|
|
addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, 17, 0, 0));
|
|
}
|
|
if (currentType != AUTH_TYPE_MISSED_CALL) {
|
|
codeFieldContainer = new CodeFieldContainer(context) {
|
|
@Override
|
|
protected void processNextPressed() {
|
|
onNextPressed(null);
|
|
}
|
|
};
|
|
|
|
addView(codeFieldContainer, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 42, Gravity.CENTER_HORIZONTAL, 0, 32, 0, 0));
|
|
}
|
|
if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
codeFieldContainer.setVisibility(GONE);
|
|
}
|
|
|
|
problemFrame = new FrameLayout(context);
|
|
|
|
timeText = new TextView(context);
|
|
timeText.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
timeText.setPadding(0, AndroidUtilities.dp(2), 0, AndroidUtilities.dp(10));
|
|
timeText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
timeText.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
|
|
timeText.setOnClickListener(v-> {
|
|
if (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_SMS || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
timeText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
if (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
timeText.setText(LocaleController.getString("Calling", R.string.Calling));
|
|
} else {
|
|
timeText.setText(LocaleController.getString("SendingSms", R.string.SendingSms));
|
|
}
|
|
createCodeTimer();
|
|
TLRPC.TL_auth_resendCode req = new TLRPC.TL_auth_resendCode();
|
|
req.phone_number = requestPhone;
|
|
req.phone_code_hash = phoneHash;
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> {
|
|
if (error != null && error.text != null) {
|
|
AndroidUtilities.runOnUIThread(() -> lastError = error.text);
|
|
}
|
|
}, ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else if (nextType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForSms(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(LoginActivitySmsView.this, NotificationCenter.didReceiveSmsCode);
|
|
waitingForEvent = false;
|
|
destroyCodeTimer();
|
|
resendCode();
|
|
}
|
|
});
|
|
problemFrame.addView(timeText, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL));
|
|
|
|
errorViewSwitcher = new ViewSwitcher(context) {
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(100), MeasureSpec.AT_MOST));
|
|
}
|
|
};
|
|
Animation anim = AnimationUtils.loadAnimation(context, R.anim.text_in);
|
|
anim.setInterpolator(Easings.easeInOutQuad);
|
|
errorViewSwitcher.setInAnimation(anim);
|
|
|
|
anim = AnimationUtils.loadAnimation(context, R.anim.text_out);
|
|
anim.setInterpolator(Easings.easeInOutQuad);
|
|
errorViewSwitcher.setOutAnimation(anim);
|
|
|
|
problemText = new TextView(context);
|
|
problemText.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
problemText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
problemText.setGravity(Gravity.CENTER_HORIZONTAL | Gravity.TOP);
|
|
problemText.setPadding(0, AndroidUtilities.dp(4), 0, AndroidUtilities.dp(4));
|
|
problemFrame.addView(problemText, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER));
|
|
errorViewSwitcher.addView(problemFrame);
|
|
|
|
wrongCode = new TextView(context);
|
|
wrongCode.setText(LocaleController.getString("WrongCode", R.string.WrongCode));
|
|
wrongCode.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
wrongCode.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
wrongCode.setGravity(Gravity.CENTER_HORIZONTAL | Gravity.TOP);
|
|
wrongCode.setPadding(0, AndroidUtilities.dp(4), 0, AndroidUtilities.dp(4));
|
|
errorViewSwitcher.addView(wrongCode);
|
|
|
|
if (currentType == AUTH_TYPE_MESSAGE) {
|
|
if (nextType == AUTH_TYPE_FLASH_CALL || nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
problemText.setText(LocaleController.getString("DidNotGetTheCodePhone", R.string.DidNotGetTheCodePhone));
|
|
} else {
|
|
problemText.setText(LocaleController.getString("DidNotGetTheCodeSms", R.string.DidNotGetTheCodeSms));
|
|
}
|
|
} else {
|
|
problemText.setText(LocaleController.getString("DidNotGetTheCode", R.string.DidNotGetTheCode));
|
|
}
|
|
if (centerContainer == null) {
|
|
bottomContainer = new FrameLayout(context);
|
|
bottomContainer.addView(errorViewSwitcher, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM, 0, 0, 0, 32));
|
|
addView(bottomContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 0, 1f));
|
|
} else {
|
|
centerContainer.addView(errorViewSwitcher, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM, 0, 0, 0, 32));
|
|
}
|
|
VerticalPositionAutoAnimator.attach(errorViewSwitcher);
|
|
|
|
problemText.setOnClickListener(v -> {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
boolean email = nextType == AUTH_TYPE_CALL && currentType == AUTH_TYPE_SMS || nextType == 0;
|
|
if (!email) {
|
|
if (radialProgressView.getTag() != null) {
|
|
return;
|
|
}
|
|
resendCode();
|
|
} else {
|
|
new AlertDialog.Builder(context)
|
|
.setTitle(LocaleController.getString(R.string.RestorePasswordNoEmailTitle))
|
|
.setMessage(AndroidUtilities.replaceTags(LocaleController.formatString("DidNotGetTheCodeInfo", R.string.DidNotGetTheCodeInfo, phone)))
|
|
.setNeutralButton(LocaleController.getString(R.string.DidNotGetTheCodeHelpButton), (dialog, which)->{
|
|
try {
|
|
PackageInfo pInfo = ApplicationLoader.applicationContext.getPackageManager().getPackageInfo(ApplicationLoader.applicationContext.getPackageName(), 0);
|
|
String version = String.format(Locale.US, "%s (%d)", pInfo.versionName, pInfo.versionCode);
|
|
|
|
Intent mailer = new Intent(Intent.ACTION_SENDTO);
|
|
mailer.setData(Uri.parse("mailto:"));
|
|
mailer.putExtra(Intent.EXTRA_EMAIL, new String[]{"sms@telegram.org"});
|
|
mailer.putExtra(Intent.EXTRA_SUBJECT, "Android registration/login issue " + version + " " + emailPhone);
|
|
mailer.putExtra(Intent.EXTRA_TEXT, "Phone: " + requestPhone + "\nApp version: " + version + "\nOS version: SDK " + Build.VERSION.SDK_INT + "\nDevice Name: " + Build.MANUFACTURER + Build.MODEL + "\nLocale: " + Locale.getDefault() + "\nError: " + lastError);
|
|
getContext().startActivity(Intent.createChooser(mailer, "Send email..."));
|
|
} catch (Exception e) {
|
|
needShowAlert(LocaleController.getString(R.string.NekoX), LocaleController.getString("NoMailInstalled", R.string.NoMailInstalled));
|
|
}
|
|
})
|
|
.setPositiveButton(LocaleController.getString(R.string.Close), null)
|
|
.setNegativeButton(LocaleController.getString(R.string.DidNotGetTheCodeEditNumberButton), (dialog, which)-> setPage(VIEW_PHONE_INPUT, true, null, true))
|
|
.show();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
confirmTextView.setTextColor(Theme.getColor(cancelAccountDeletionMode ? Theme.key_windowBackgroundWhiteBlackText : Theme.key_windowBackgroundWhiteGrayText6));
|
|
confirmTextView.setLinkTextColor(Theme.getColor(Theme.key_chats_actionBackground));
|
|
titleTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
|
|
if (currentType == AUTH_TYPE_MISSED_CALL) {
|
|
missedCallDescriptionSubtitle.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText));
|
|
missedCallArrowIcon.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), PorterDuff.Mode.SRC_IN));
|
|
missedCallPhoneIcon.setColorFilter(new PorterDuffColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText), PorterDuff.Mode.SRC_IN));
|
|
prefixTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
}
|
|
|
|
applyLottieColors(hintDrawable);
|
|
applyLottieColors(starsToDotsDrawable);
|
|
applyLottieColors(dotsDrawable);
|
|
applyLottieColors(dotsToStarsDrawable);
|
|
|
|
if (codeFieldContainer != null) {
|
|
codeFieldContainer.invalidate();
|
|
}
|
|
|
|
String timeTextColorTag = (String) timeText.getTag();
|
|
if (timeTextColorTag == null) timeTextColorTag = Theme.key_windowBackgroundWhiteGrayText6;
|
|
timeText.setTextColor(Theme.getColor(timeTextColorTag));
|
|
|
|
problemText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
|
|
wrongCode.setTextColor(Theme.getColor(Theme.key_dialogTextRed));
|
|
}
|
|
|
|
private void applyLottieColors(RLottieDrawable drawable) {
|
|
if (drawable != null) {
|
|
drawable.setLayerColor("Bubble.**", Theme.getColor(Theme.key_chats_actionBackground));
|
|
drawable.setLayerColor("Phone.**", Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
drawable.setLayerColor("Note.**", Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomKeyboard() {
|
|
return currentType != AUTH_TYPE_FLASH_CALL;
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
private void resendCode() {
|
|
final Bundle params = new Bundle();
|
|
params.putString("phone", phone);
|
|
params.putString("ephone", emailPhone);
|
|
params.putString("phoneFormated", requestPhone);
|
|
|
|
nextPressed = true;
|
|
|
|
TLRPC.TL_auth_resendCode req = new TLRPC.TL_auth_resendCode();
|
|
req.phone_number = requestPhone;
|
|
req.phone_code_hash = phoneHash;
|
|
int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
if (error == null) {
|
|
fillNextCodeParams(params, (TLRPC.TL_auth_sentCode) response);
|
|
} else {
|
|
if (error.text != null) {
|
|
if (error.text.contains("PHONE_NUMBER_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidPhoneNumber", R.string.InvalidPhoneNumber));
|
|
} else if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidCode", R.string.InvalidCode));
|
|
} else if (error.text.contains("PHONE_CODE_EXPIRED")) {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("CodeExpired", R.string.CodeExpired));
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else if (error.code != -1000) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("ErrorOccurred", R.string.ErrorOccurred) + "\n" + error.text);
|
|
}
|
|
}
|
|
}
|
|
tryHideProgress(false);
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
tryShowProgress(reqId);
|
|
}
|
|
|
|
private void tryShowProgress(int reqId) {
|
|
tryShowProgress(reqId, true);
|
|
}
|
|
|
|
private void tryShowProgress(int reqId, boolean animate) {
|
|
if (starsToDotsDrawable != null) {
|
|
if (isDotsAnimationVisible) {
|
|
return;
|
|
}
|
|
isDotsAnimationVisible = true;
|
|
if (hintDrawable.getCurrentFrame() != hintDrawable.getFramesCount() - 1) {
|
|
hintDrawable.setOnAnimationEndListener(()-> AndroidUtilities.runOnUIThread(()-> tryShowProgress(reqId, animate)));
|
|
return;
|
|
}
|
|
|
|
starsToDotsDrawable.setOnAnimationEndListener(()-> AndroidUtilities.runOnUIThread(()->{
|
|
blueImageView.setAutoRepeat(true);
|
|
dotsDrawable.setCurrentFrame(0, false);
|
|
dotsDrawable.setAutoRepeat(1);
|
|
blueImageView.setAnimation(dotsDrawable);
|
|
blueImageView.playAnimation();
|
|
}));
|
|
blueImageView.setAutoRepeat(false);
|
|
starsToDotsDrawable.setCurrentFrame(0, false);
|
|
blueImageView.setAnimation(starsToDotsDrawable);
|
|
blueImageView.playAnimation();
|
|
return;
|
|
}
|
|
needShowProgress(reqId, animate);
|
|
}
|
|
|
|
private void tryHideProgress(boolean cancel) {
|
|
tryHideProgress(cancel, true);
|
|
}
|
|
|
|
private void tryHideProgress(boolean cancel, boolean animate) {
|
|
if (starsToDotsDrawable != null) {
|
|
if (!isDotsAnimationVisible) {
|
|
return;
|
|
}
|
|
isDotsAnimationVisible = false;
|
|
blueImageView.setAutoRepeat(false);
|
|
dotsDrawable.setAutoRepeat(0);
|
|
dotsDrawable.setOnFinishCallback(()-> AndroidUtilities.runOnUIThread(()->{
|
|
dotsToStarsDrawable.setOnAnimationEndListener(()-> AndroidUtilities.runOnUIThread(()->{
|
|
blueImageView.setAutoRepeat(false);
|
|
blueImageView.setAnimation(hintDrawable);
|
|
}));
|
|
|
|
blueImageView.setAutoRepeat(false);
|
|
dotsToStarsDrawable.setCurrentFrame(0, false);
|
|
blueImageView.setAnimation(dotsToStarsDrawable);
|
|
blueImageView.playAnimation();
|
|
}), dotsDrawable.getFramesCount() - 1);
|
|
return;
|
|
}
|
|
needHideProgress(cancel, animate);
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
if (currentType == AUTH_TYPE_FLASH_CALL || currentType == AUTH_TYPE_MISSED_CALL) {
|
|
return phone;
|
|
} else {
|
|
return LocaleController.getString("YourCode", R.string.YourCode);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
waitingForEvent = true;
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(this, NotificationCenter.didReceiveCall);
|
|
}
|
|
|
|
currentParams = params;
|
|
phone = params.getString("phone");
|
|
emailPhone = params.getString("ephone");
|
|
requestPhone = params.getString("phoneFormated");
|
|
phoneHash = params.getString("phoneHash");
|
|
time = params.getInt("timeout");
|
|
openTime = (int) (System.currentTimeMillis() / 1000);
|
|
nextType = params.getInt("nextType");
|
|
pattern = params.getString("pattern");
|
|
prefix = params.getString("prefix");
|
|
length = params.getInt("length");
|
|
if (length == 0) {
|
|
length = 5;
|
|
}
|
|
|
|
codeFieldContainer.setNumbersCount(length, currentType);
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
|
|
f.setShowSoftInputOnFocusCompat(!(hasCustomKeyboard() && !isCustomKeyboardForceDisabled()));
|
|
}
|
|
f.addTextChangedListener(new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
if (postedErrorColorTimeout) {
|
|
removeCallbacks(errorColorTimeout);
|
|
errorColorTimeout.run();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {}
|
|
});
|
|
|
|
f.setOnFocusChangeListener((v, hasFocus) -> {
|
|
if (hasFocus) {
|
|
keyboardView.setEditText((EditText) v);
|
|
keyboardView.setDispatchBackWhenEmpty(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (progressView != null) {
|
|
progressView.setVisibility(nextType != 0 ? VISIBLE : GONE);
|
|
}
|
|
|
|
if (phone == null) {
|
|
return;
|
|
}
|
|
|
|
String number = PhoneFormat.getInstance().format(phone);
|
|
CharSequence str = "";
|
|
if (cancelAccountDeletionMode) {
|
|
SpannableStringBuilder spanned = new SpannableStringBuilder(AndroidUtilities.replaceTags(LocaleController.formatString("CancelAccountResetInfo2", R.string.CancelAccountResetInfo2, PhoneFormat.getInstance().format("+" + number))));
|
|
|
|
int startIndex = TextUtils.indexOf(spanned, '*');
|
|
int lastIndex = TextUtils.lastIndexOf(spanned, '*');
|
|
if (startIndex != -1 && lastIndex != -1 && startIndex != lastIndex) {
|
|
confirmTextView.setMovementMethod(new AndroidUtilities.LinkMovementMethodMy());
|
|
spanned.replace(lastIndex, lastIndex + 1, "");
|
|
spanned.replace(startIndex, startIndex + 1, "");
|
|
spanned.setSpan(new URLSpanNoUnderline("tg://settings/change_number"), startIndex, lastIndex - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
}
|
|
str = spanned;
|
|
} else {
|
|
if (currentType == AUTH_TYPE_MESSAGE) {
|
|
str = AndroidUtilities.replaceTags(LocaleController.formatString("SentAppCodeWithPhone", R.string.SentAppCodeWithPhone, LocaleController.addNbsp(number)));
|
|
} else if (currentType == AUTH_TYPE_SMS) {
|
|
str = AndroidUtilities.replaceTags(LocaleController.formatString("SentSmsCode", R.string.SentSmsCode, LocaleController.addNbsp(number)));
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
str = AndroidUtilities.replaceTags(LocaleController.formatString("SentCallCode", R.string.SentCallCode, LocaleController.addNbsp(number)));
|
|
} else if (currentType == AUTH_TYPE_CALL) {
|
|
str = AndroidUtilities.replaceTags(LocaleController.formatString("SentCallOnly", R.string.SentCallOnly, LocaleController.addNbsp(number)));
|
|
}
|
|
}
|
|
confirmTextView.setText(str);
|
|
|
|
if (currentType != AUTH_TYPE_FLASH_CALL) {
|
|
showKeyboard(codeFieldContainer.codeField[0]);
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
} else {
|
|
AndroidUtilities.hideKeyboard(codeFieldContainer.codeField[0]);
|
|
}
|
|
|
|
destroyTimer();
|
|
destroyCodeTimer();
|
|
|
|
lastCurrentTime = System.currentTimeMillis();
|
|
if (currentType == AUTH_TYPE_MESSAGE) {
|
|
setProblemTextVisible(true);
|
|
timeText.setVisibility(GONE);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL && (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_SMS)) {
|
|
setProblemTextVisible(false);
|
|
timeText.setVisibility(VISIBLE);
|
|
if (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
timeText.setText(LocaleController.formatString("CallAvailableIn", R.string.CallAvailableIn, 1, 0));
|
|
} else if (nextType == AUTH_TYPE_SMS) {
|
|
timeText.setText(LocaleController.formatString("SmsAvailableIn", R.string.SmsAvailableIn, 1, 0));
|
|
}
|
|
String callLogNumber = restore ? AndroidUtilities.obtainLoginPhoneCall(pattern) : null;
|
|
if (callLogNumber != null) {
|
|
onNextPressed(callLogNumber);
|
|
} else if (catchedPhone != null) {
|
|
onNextPressed(catchedPhone);
|
|
} else {
|
|
createTimer();
|
|
}
|
|
} else if (currentType == AUTH_TYPE_SMS && (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_FLASH_CALL)) {
|
|
timeText.setText(LocaleController.formatString("CallAvailableIn", R.string.CallAvailableIn, 2, 0));
|
|
setProblemTextVisible(time < 1000);
|
|
timeText.setVisibility(time < 1000 ? GONE : VISIBLE);
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("mainconfig", Activity.MODE_PRIVATE);
|
|
String hash = preferences.getString("sms_hash", null);
|
|
String savedCode = null;
|
|
if (!TextUtils.isEmpty(hash)) {
|
|
savedCode = preferences.getString("sms_hash_code", null);
|
|
if (savedCode != null && savedCode.contains(hash + "|")) {
|
|
savedCode = savedCode.substring(savedCode.indexOf('|') + 1);
|
|
} else {
|
|
savedCode = null;
|
|
}
|
|
}
|
|
if (savedCode != null) {
|
|
codeFieldContainer.setCode(savedCode);
|
|
onNextPressed(null);
|
|
} else {
|
|
createTimer();
|
|
}
|
|
} else if (currentType == AUTH_TYPE_CALL && nextType == AUTH_TYPE_SMS) {
|
|
timeText.setText(LocaleController.formatString("SmsAvailableIn", R.string.SmsAvailableIn, 2, 0));
|
|
setProblemTextVisible(time < 1000);
|
|
timeText.setVisibility(time < 1000 ? GONE : VISIBLE);
|
|
createTimer();
|
|
} else {
|
|
timeText.setVisibility(GONE);
|
|
setProblemTextVisible(false);
|
|
createCodeTimer();
|
|
}
|
|
|
|
if (currentType == AUTH_TYPE_MISSED_CALL) {
|
|
String pref = prefix;
|
|
for (int i = 0; i < length; i++) {
|
|
pref += "0";
|
|
}
|
|
pref = PhoneFormat.getInstance().format("+" + pref);
|
|
for (int i = 0; i < length; i++) {
|
|
int index = pref.lastIndexOf("0");
|
|
if (index >= 0) {
|
|
pref = pref.substring(0, index);
|
|
}
|
|
}
|
|
pref = pref.replaceAll("\\)", "");
|
|
pref = pref.replaceAll("\\(", "");
|
|
prefixTextView.setText(pref);
|
|
}
|
|
}
|
|
|
|
private void setProblemTextVisible(boolean visible) {
|
|
float newAlpha = visible ? 1f : 0f;
|
|
if (problemText.getAlpha() != newAlpha) {
|
|
problemText.animate().cancel();
|
|
problemText.animate().alpha(newAlpha).setDuration(150).start();
|
|
}
|
|
}
|
|
|
|
private void createCodeTimer() {
|
|
if (codeTimer != null) {
|
|
return;
|
|
}
|
|
codeTime = 15000;
|
|
codeTimer = new Timer();
|
|
lastCodeTime = System.currentTimeMillis();
|
|
codeTimer.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
double currentTime = System.currentTimeMillis();
|
|
double diff = currentTime - lastCodeTime;
|
|
lastCodeTime = currentTime;
|
|
codeTime -= diff;
|
|
if (codeTime <= 1000) {
|
|
setProblemTextVisible(true);
|
|
timeText.setVisibility(GONE);
|
|
destroyCodeTimer();
|
|
}
|
|
});
|
|
}
|
|
}, 0, 1000);
|
|
}
|
|
|
|
private void destroyCodeTimer() {
|
|
try {
|
|
synchronized (timerSync) {
|
|
if (codeTimer != null) {
|
|
codeTimer.cancel();
|
|
codeTimer = null;
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
|
|
private void createTimer() {
|
|
if (timeTimer != null) {
|
|
return;
|
|
}
|
|
timeText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
timeText.setTag(R.id.color_key_tag, Theme.key_windowBackgroundWhiteGrayText6);
|
|
if (progressView != null) {
|
|
progressView.resetProgressAnimation();
|
|
}
|
|
timeTimer = new Timer();
|
|
timeTimer.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
if (timeTimer == null) {
|
|
return;
|
|
}
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
double currentTime = System.currentTimeMillis();
|
|
double diff = currentTime - lastCurrentTime;
|
|
lastCurrentTime = currentTime;
|
|
time -= diff;
|
|
if (time >= 1000) {
|
|
int minutes = time / 1000 / 60;
|
|
int seconds = time / 1000 - minutes * 60;
|
|
if (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_FLASH_CALL || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
timeText.setText(LocaleController.formatString("CallAvailableIn", R.string.CallAvailableIn, minutes, seconds));
|
|
} else if (nextType == AUTH_TYPE_SMS) {
|
|
timeText.setText(LocaleController.formatString("SmsAvailableIn", R.string.SmsAvailableIn, minutes, seconds));
|
|
}
|
|
if (progressView != null && !progressView.isProgressAnimationRunning()) {
|
|
progressView.startProgressAnimation(time - 1000L);
|
|
}
|
|
} else {
|
|
destroyTimer();
|
|
if (nextType == AUTH_TYPE_FLASH_CALL || nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_SMS || nextType == AUTH_TYPE_MISSED_CALL) {
|
|
if (nextType == AUTH_TYPE_CALL) {
|
|
timeText.setText(LocaleController.getString("RequestCallButton", R.string.RequestCallButton));
|
|
} else if (nextType == AUTH_TYPE_MISSED_CALL || nextType == AUTH_TYPE_FLASH_CALL) {
|
|
timeText.setText(LocaleController.getString("RequestMissedCall", R.string.RequestMissedCall));
|
|
} else {
|
|
timeText.setText(LocaleController.getString("RequestSmsButton", R.string.RequestSmsButton));
|
|
}
|
|
timeText.setTextColor(Theme.getColor(Theme.key_chats_actionBackground));
|
|
timeText.setTag(R.id.color_key_tag, Theme.key_chats_actionBackground);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, 0, 1000);
|
|
}
|
|
|
|
private void destroyTimer() {
|
|
timeText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
timeText.setTag(R.id.color_key_tag, Theme.key_windowBackgroundWhiteGrayText6);
|
|
try {
|
|
synchronized (timerSync) {
|
|
if (timeTimer != null) {
|
|
timeTimer.cancel();
|
|
timeTimer = null;
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (currentViewNum == AUTH_TYPE_MISSED_CALL) {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
} else {
|
|
if (nextPressed || currentViewNum < VIEW_CODE_MESSAGE || currentViewNum > VIEW_CODE_CALL) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (code == null) {
|
|
code = codeFieldContainer.getCode();
|
|
}
|
|
if (TextUtils.isEmpty(code)) {
|
|
onFieldError(codeFieldContainer, false);
|
|
return;
|
|
}
|
|
|
|
if (currentViewNum >= VIEW_CODE_MESSAGE && currentViewNum <= VIEW_CODE_CALL && codeFieldContainer.isFocusSuppressed) {
|
|
return;
|
|
}
|
|
|
|
nextPressed = true;
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
|
|
}
|
|
waitingForEvent = false;
|
|
|
|
if (cancelAccountDeletionMode) {
|
|
requestPhone = cancelDeletionPhone;
|
|
final TLRPC.TL_account_confirmPhone req = new TLRPC.TL_account_confirmPhone();
|
|
req.phone_code = code;
|
|
req.phone_code_hash = phoneHash;
|
|
destroyTimer();
|
|
|
|
codeFieldContainer.isFocusSuppressed = true;
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.animateFocusedProgress(0);
|
|
}
|
|
|
|
int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
tryHideProgress(false);
|
|
nextPressed = false;
|
|
if (error == null) {
|
|
animateSuccess(()-> new AlertDialog.Builder(getParentActivity())
|
|
.setTitle(LocaleController.getString(R.string.CancelLinkSuccessTitle))
|
|
.setMessage(LocaleController.formatString("CancelLinkSuccess", R.string.CancelLinkSuccess, PhoneFormat.getInstance().format("+" + phone)))
|
|
.setPositiveButton(LocaleController.getString(R.string.Close), null)
|
|
.setOnDismissListener(dialog -> finishFragment())
|
|
.show());
|
|
} else {
|
|
lastError = error.text;
|
|
if (currentType == AUTH_TYPE_FLASH_CALL && (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_SMS) || currentType == AUTH_TYPE_SMS &&
|
|
(nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_FLASH_CALL) || currentType == AUTH_TYPE_CALL && nextType == AUTH_TYPE_SMS) {
|
|
createTimer();
|
|
}
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(LoginActivitySmsView.this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(LoginActivitySmsView.this, NotificationCenter.didReceiveCall);
|
|
}
|
|
waitingForEvent = true;
|
|
if (currentType != AUTH_TYPE_FLASH_CALL) {
|
|
AlertsCreator.processError(currentAccount, error, LoginActivity.this, req);
|
|
}
|
|
if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
|
|
shakeWrongCode();
|
|
} else if (error.text.contains("PHONE_CODE_EXPIRED")) {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
tryShowProgress(reqId);
|
|
} else {
|
|
final TLRPC.TL_auth_signIn req = new TLRPC.TL_auth_signIn();
|
|
req.phone_number = requestPhone;
|
|
req.phone_code = code;
|
|
req.phone_code_hash = phoneHash;
|
|
destroyTimer();
|
|
|
|
codeFieldContainer.isFocusSuppressed = true;
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.animateFocusedProgress(0);
|
|
}
|
|
|
|
int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
tryHideProgress(false, true);
|
|
|
|
boolean ok = false;
|
|
|
|
if (error == null) {
|
|
nextPressed = false;
|
|
ok = true;
|
|
showDoneButton(false, true);
|
|
destroyTimer();
|
|
destroyCodeTimer();
|
|
if (response instanceof TLRPC.TL_auth_authorizationSignUpRequired) {
|
|
TLRPC.TL_auth_authorizationSignUpRequired authorization = (TLRPC.TL_auth_authorizationSignUpRequired) response;
|
|
if (authorization.terms_of_service != null) {
|
|
currentTermsOfService = authorization.terms_of_service;
|
|
}
|
|
Bundle params = new Bundle();
|
|
params.putString("phoneFormated", requestPhone);
|
|
params.putString("phoneHash", phoneHash);
|
|
params.putString("code", req.phone_code);
|
|
|
|
animateSuccess(() -> setPage(VIEW_REGISTER, true, params, false));
|
|
} else {
|
|
animateSuccess(() -> onAuthSuccess((TLRPC.TL_auth_authorization) response));
|
|
}
|
|
} else {
|
|
lastError = error.text;
|
|
if (error.text.contains("SESSION_PASSWORD_NEEDED")) {
|
|
ok = true;
|
|
TLRPC.TL_account_getPassword req2 = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req2, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
showDoneButton(false, true);
|
|
if (error1 == null) {
|
|
TLRPC.TL_account_password password = (TLRPC.TL_account_password) response1;
|
|
if (!TwoStepVerificationActivity.canHandleCurrentPassword(password, true)) {
|
|
AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
|
|
return;
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
SerializedData data = new SerializedData(password.getObjectSize());
|
|
password.serializeToStream(data);
|
|
bundle.putString("password", Utilities.bytesToHex(data.toByteArray()));
|
|
bundle.putString("phoneFormated", requestPhone);
|
|
bundle.putString("phoneHash", phoneHash);
|
|
bundle.putString("code", req.phone_code);
|
|
|
|
animateSuccess(() -> setPage(VIEW_PASSWORD, true, bundle, false));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error1.text);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
destroyTimer();
|
|
destroyCodeTimer();
|
|
} else {
|
|
nextPressed = false;
|
|
showDoneButton(false, true);
|
|
if (currentType == AUTH_TYPE_FLASH_CALL && (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_SMS) || currentType == AUTH_TYPE_SMS && (nextType == AUTH_TYPE_CALL || nextType == AUTH_TYPE_FLASH_CALL) || currentType == AUTH_TYPE_CALL && nextType == AUTH_TYPE_SMS) {
|
|
createTimer();
|
|
}
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(LoginActivitySmsView.this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(true);
|
|
NotificationCenter.getGlobalInstance().addObserver(LoginActivitySmsView.this, NotificationCenter.didReceiveCall);
|
|
}
|
|
waitingForEvent = true;
|
|
if (currentType != AUTH_TYPE_FLASH_CALL) {
|
|
boolean isWrongCode = false;
|
|
if (error.text.contains("PHONE_NUMBER_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidPhoneNumber", R.string.InvalidPhoneNumber));
|
|
} else if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
|
|
shakeWrongCode();
|
|
isWrongCode = true;
|
|
} else if (error.text.contains("PHONE_CODE_EXPIRED")) {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("CodeExpired", R.string.CodeExpired));
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("ErrorOccurred", R.string.ErrorOccurred) + "\n" + error.text);
|
|
}
|
|
|
|
if (!isWrongCode) {
|
|
for (int a = 0; a < codeFieldContainer.codeField.length; a++) {
|
|
codeFieldContainer.codeField[a].setText("");
|
|
}
|
|
|
|
codeFieldContainer.isFocusSuppressed = false;
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (ok) {
|
|
if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.endIncomingCall();
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
tryShowProgress(reqId, true);
|
|
showDoneButton(true, true);
|
|
}
|
|
}
|
|
|
|
private void animateSuccess(Runnable callback) {
|
|
for (int i = 0; i < codeFieldContainer.codeField.length; i++) {
|
|
int finalI = i;
|
|
codeFieldContainer.postDelayed(()-> codeFieldContainer.codeField[finalI].animateSuccessProgress(1f), i * 75L);
|
|
}
|
|
codeFieldContainer.postDelayed(()->{
|
|
for (int i = 0; i < codeFieldContainer.codeField.length; i++) {
|
|
codeFieldContainer.codeField[i].animateSuccessProgress(0f);
|
|
}
|
|
callback.run();
|
|
codeFieldContainer.isFocusSuppressed = false;
|
|
}, codeFieldContainer.codeField.length * 75L + 400L);
|
|
}
|
|
|
|
private void shakeWrongCode() {
|
|
try {
|
|
codeFieldContainer.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
|
|
} catch (Exception ignore) {}
|
|
|
|
for (int a = 0; a < codeFieldContainer.codeField.length; a++) {
|
|
codeFieldContainer.codeField[a].setText("");
|
|
codeFieldContainer.codeField[a].animateErrorProgress(1f);
|
|
}
|
|
if (errorViewSwitcher.getCurrentView() == problemFrame) {
|
|
errorViewSwitcher.showNext();
|
|
}
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
AndroidUtilities.shakeViewSpring(codeFieldContainer, currentType == AUTH_TYPE_MISSED_CALL ? 3.5f : 10f, () -> {
|
|
postDelayed(()-> {
|
|
codeFieldContainer.isFocusSuppressed = false;
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
|
|
for (int a = 0; a < codeFieldContainer.codeField.length; a++) {
|
|
codeFieldContainer.codeField[a].animateErrorProgress(0f);
|
|
}
|
|
}, 150);
|
|
});
|
|
removeCallbacks(errorColorTimeout);
|
|
postDelayed(errorColorTimeout, 5000);
|
|
postedErrorColorTimeout = true;
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
removeCallbacks(errorColorTimeout);
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
if (cancelAccountDeletionMode) {
|
|
finishFragment();
|
|
return false;
|
|
}
|
|
|
|
if (!force) {
|
|
showDialog(new AlertDialog.Builder(getParentActivity())
|
|
.setTitle(LocaleController.getString(R.string.EditNumber))
|
|
.setMessage(AndroidUtilities.replaceTags(LocaleController.formatString("EditNumberInfo", R.string.EditNumberInfo, phone)))
|
|
.setPositiveButton(LocaleController.getString(R.string.Close), null)
|
|
.setNegativeButton(LocaleController.getString(R.string.Edit), (dialogInterface, i) -> {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
})
|
|
.create());
|
|
return false;
|
|
}
|
|
nextPressed = false;
|
|
tryHideProgress(true);
|
|
TLRPC.TL_auth_cancelCode req = new TLRPC.TL_auth_cancelCode();
|
|
req.phone_number = requestPhone;
|
|
req.phone_code_hash = phoneHash;
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> {
|
|
|
|
}, ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
|
|
destroyTimer();
|
|
destroyCodeTimer();
|
|
currentParams = null;
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
|
|
}
|
|
waitingForEvent = false;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyActivity() {
|
|
super.onDestroyActivity();
|
|
if (currentType == AUTH_TYPE_SMS) {
|
|
AndroidUtilities.setWaitingForSms(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveSmsCode);
|
|
} else if (currentType == AUTH_TYPE_FLASH_CALL) {
|
|
AndroidUtilities.setWaitingForCall(false);
|
|
NotificationCenter.getGlobalInstance().removeObserver(this, NotificationCenter.didReceiveCall);
|
|
}
|
|
waitingForEvent = false;
|
|
destroyTimer();
|
|
destroyCodeTimer();
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
if (hintDrawable != null) {
|
|
hintDrawable.setCurrentFrame(0);
|
|
}
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (currentType != AUTH_TYPE_FLASH_CALL && codeFieldContainer.codeField != null) {
|
|
for (int a = codeFieldContainer.codeField.length - 1; a >= 0; a--) {
|
|
if (a == 0 || codeFieldContainer.codeField[a].length() != 0) {
|
|
codeFieldContainer.codeField[a].requestFocus();
|
|
codeFieldContainer.codeField[a].setSelection(codeFieldContainer.codeField[a].length());
|
|
showKeyboard(codeFieldContainer.codeField[a]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (hintDrawable != null) {
|
|
hintDrawable.start();
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public void didReceivedNotification(int id, int account, Object... args) {
|
|
if (!waitingForEvent || codeFieldContainer.codeField == null) {
|
|
return;
|
|
}
|
|
if (id == NotificationCenter.didReceiveSmsCode) {
|
|
codeFieldContainer.setText("" + args[0]);
|
|
onNextPressed(null);
|
|
} else if (id == NotificationCenter.didReceiveCall) {
|
|
String num = "" + args[0];
|
|
if (!AndroidUtilities.checkPhonePattern(pattern, num)) {
|
|
return;
|
|
}
|
|
if (!pattern.equals("*")) {
|
|
catchedPhone = num;
|
|
AndroidUtilities.endIncomingCall();
|
|
}
|
|
onNextPressed(num);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
String code = codeFieldContainer.getCode();
|
|
if (code.length() != 0) {
|
|
bundle.putString("smsview_code_" + currentType, code);
|
|
}
|
|
if (catchedPhone != null) {
|
|
bundle.putString("catchedPhone", catchedPhone);
|
|
}
|
|
if (currentParams != null) {
|
|
bundle.putBundle("smsview_params_" + currentType, currentParams);
|
|
}
|
|
if (time != 0) {
|
|
bundle.putInt("time", time);
|
|
}
|
|
if (openTime != 0) {
|
|
bundle.putInt("open", openTime);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("smsview_params_" + currentType);
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
String catched = bundle.getString("catchedPhone");
|
|
if (catched != null) {
|
|
catchedPhone = catched;
|
|
}
|
|
String code = bundle.getString("smsview_code_" + currentType);
|
|
if (code != null && codeFieldContainer.codeField != null) {
|
|
codeFieldContainer.setText(code);
|
|
}
|
|
int t = bundle.getInt("time");
|
|
if (t != 0) {
|
|
time = t;
|
|
}
|
|
int t2 = bundle.getInt("open");
|
|
if (t2 != 0) {
|
|
openTime = t2;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivityPasswordView extends SlideView {
|
|
|
|
private EditTextBoldCursor codeField;
|
|
private TextView confirmTextView;
|
|
private TextView cancelButton;
|
|
private TextView titleView;
|
|
private RLottieImageView lockImageView;
|
|
|
|
private Bundle currentParams;
|
|
private boolean nextPressed;
|
|
private TLRPC.TL_account_password currentPassword;
|
|
private String passwordString;
|
|
private String requestPhone;
|
|
private String phoneHash;
|
|
private String phoneCode;
|
|
|
|
private OutlineTextContainerView outlineCodeField;
|
|
|
|
public LoginActivityPasswordView(Context context) {
|
|
super(context);
|
|
|
|
setOrientation(VERTICAL);
|
|
|
|
FrameLayout lockFrameLayout = new FrameLayout(context);
|
|
lockImageView = new RLottieImageView(context);
|
|
lockImageView.setAnimation(R.raw.tsv_setup_intro, 120, 120);
|
|
lockImageView.setAutoRepeat(false);
|
|
lockFrameLayout.addView(lockImageView, LayoutHelper.createFrame(120, 120, Gravity.CENTER_HORIZONTAL));
|
|
lockFrameLayout.setVisibility(AndroidUtilities.isSmallScreen() || (AndroidUtilities.displaySize.x > AndroidUtilities.displaySize.y && !AndroidUtilities.isTablet()) ? GONE : VISIBLE);
|
|
addView(lockFrameLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL));
|
|
|
|
titleView = new TextView(context);
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleView.setText(LocaleController.getString(R.string.YourPasswordHeader));
|
|
titleView.setGravity(Gravity.CENTER);
|
|
titleView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(titleView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 32, 16, 32, 0));
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
confirmTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
confirmTextView.setText(LocaleController.getString(R.string.LoginPasswordTextShort));
|
|
addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 12, 8, 12, 0));
|
|
|
|
outlineCodeField = new OutlineTextContainerView(context);
|
|
outlineCodeField.setText(LocaleController.getString(R.string.EnterPassword));
|
|
codeField = new EditTextAutoFill(context);
|
|
codeField.setCursorSize(AndroidUtilities.dp(20));
|
|
codeField.setCursorWidth(1.5f);
|
|
codeField.setBackground(null);
|
|
codeField.setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
codeField.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
codeField.setMaxLines(1);
|
|
int padding = AndroidUtilities.dp(16);
|
|
codeField.setPadding(padding, padding, padding, padding);
|
|
codeField.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
|
|
codeField.setTransformationMethod(PasswordTransformationMethod.getInstance());
|
|
codeField.setTypeface(Typeface.DEFAULT);
|
|
codeField.setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
|
|
codeField.setOnFocusChangeListener((v, hasFocus) -> outlineCodeField.animateSelection(hasFocus ? 1f : 0f));
|
|
outlineCodeField.attachEditText(codeField);
|
|
outlineCodeField.addView(codeField, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP));
|
|
codeField.setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (i == EditorInfo.IME_ACTION_NEXT) {
|
|
onNextPressed(null);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
addView(outlineCodeField, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 16, 32, 16, 0));
|
|
|
|
cancelButton = new TextView(context);
|
|
cancelButton.setGravity(Gravity.CENTER | Gravity.LEFT);
|
|
cancelButton.setText(LocaleController.getString("ForgotPassword", R.string.ForgotPassword));
|
|
cancelButton.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
cancelButton.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
cancelButton.setPadding(AndroidUtilities.dp(16), 0, AndroidUtilities.dp(16), 0);
|
|
|
|
FrameLayout bottomContainer = new FrameLayout(context);
|
|
bottomContainer.addView(cancelButton, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, (Build.VERSION.SDK_INT >= 21 ? 56 : 60), Gravity.BOTTOM, 0, 0, 0, 32));
|
|
addView(bottomContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.BOTTOM));
|
|
VerticalPositionAutoAnimator.attach(cancelButton);
|
|
|
|
cancelButton.setOnClickListener(view -> {
|
|
if (radialProgressView.getTag() != null) {
|
|
return;
|
|
}
|
|
if (currentPassword.has_recovery) {
|
|
needShowProgress(0);
|
|
TLRPC.TL_auth_requestPasswordRecovery req = new TLRPC.TL_auth_requestPasswordRecovery();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
needHideProgress(false);
|
|
if (error == null) {
|
|
final TLRPC.TL_auth_passwordRecovery res = (TLRPC.TL_auth_passwordRecovery) response;
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
|
|
String rawPattern = res.email_pattern;
|
|
SpannableStringBuilder emailPattern = SpannableStringBuilder.valueOf(rawPattern);
|
|
int startIndex = rawPattern.indexOf('*'), endIndex = rawPattern.lastIndexOf('*');
|
|
if (startIndex != endIndex && startIndex != -1 && endIndex != -1) {
|
|
TextStyleSpan.TextStyleRun run = new TextStyleSpan.TextStyleRun();
|
|
run.flags |= TextStyleSpan.FLAG_STYLE_SPOILER;
|
|
run.start = startIndex;
|
|
run.end = endIndex + 1;
|
|
emailPattern.setSpan(new TextStyleSpan(run), startIndex, endIndex + 1, 0);
|
|
}
|
|
builder.setMessage(AndroidUtilities.formatSpannable(LocaleController.getString(R.string.RestoreEmailSent), emailPattern));
|
|
builder.setTitle(LocaleController.getString("RestoreEmailSentTitle", R.string.RestoreEmailSentTitle));
|
|
builder.setPositiveButton(LocaleController.getString(R.string.Continue), (dialogInterface, i) -> {
|
|
Bundle bundle = new Bundle();
|
|
bundle.putString("email_unconfirmed_pattern", res.email_pattern);
|
|
bundle.putString("password", passwordString);
|
|
bundle.putString("requestPhone", requestPhone);
|
|
bundle.putString("phoneHash", phoneHash);
|
|
bundle.putString("phoneCode", phoneCode);
|
|
setPage(VIEW_RECOVER, true, bundle, false);
|
|
});
|
|
Dialog dialog = showDialog(builder.create());
|
|
if (dialog != null) {
|
|
dialog.setCanceledOnTouchOutside(false);
|
|
dialog.setCancelable(false);
|
|
}
|
|
} else {
|
|
if (error.text.startsWith("FLOOD_WAIT")) {
|
|
int time = Utilities.parseInt(error.text);
|
|
String timeString;
|
|
if (time < 60) {
|
|
timeString = LocaleController.formatPluralString("Seconds", time);
|
|
} else {
|
|
timeString = LocaleController.formatPluralString("Minutes", time / 60);
|
|
}
|
|
needShowAlert(LocaleController.getString(R.string.WrongCodeTitle), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else {
|
|
AndroidUtilities.hideKeyboard(codeField);
|
|
new AlertDialog.Builder(context)
|
|
.setTitle(LocaleController.getString(R.string.RestorePasswordNoEmailTitle))
|
|
.setMessage(LocaleController.getString(R.string.RestorePasswordNoEmailText))
|
|
.setPositiveButton(LocaleController.getString(R.string.Close), null)
|
|
.setNegativeButton(LocaleController.getString(R.string.ResetAccount), (dialog, which) -> tryResetAccount(requestPhone, phoneHash, phoneCode))
|
|
.show();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
titleView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
confirmTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
codeField.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
codeField.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
codeField.setHintTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteHintText));
|
|
cancelButton.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
|
|
outlineCodeField.updateColor();
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("LoginPassword", R.string.LoginPassword);
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
if (params.isEmpty()) {
|
|
AndroidUtilities.hideKeyboard(codeField);
|
|
return;
|
|
}
|
|
codeField.setText("");
|
|
currentParams = params;
|
|
passwordString = currentParams.getString("password");
|
|
if (passwordString != null) {
|
|
SerializedData data = new SerializedData(Utilities.hexToBytes(passwordString));
|
|
currentPassword = TLRPC.TL_account_password.TLdeserialize(data, data.readInt32(false), false);
|
|
}
|
|
|
|
requestPhone = params.getString("phoneFormated");
|
|
phoneHash = params.getString("phoneHash");
|
|
phoneCode = params.getString("code");
|
|
|
|
if (currentPassword != null && !TextUtils.isEmpty(currentPassword.hint)) {
|
|
codeField.setHint(currentPassword.hint);
|
|
} else {
|
|
codeField.setHint(null);
|
|
}
|
|
}
|
|
|
|
private void onPasscodeError(boolean clear) {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
if (clear) {
|
|
codeField.setText("");
|
|
}
|
|
onFieldError(outlineCodeField, true);
|
|
}
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
|
|
String oldPassword = codeField.getText().toString();
|
|
if (oldPassword.length() == 0) {
|
|
onPasscodeError(false);
|
|
return;
|
|
}
|
|
nextPressed = true;
|
|
needShowProgress(0);
|
|
|
|
Utilities.globalQueue.postRunnable(() -> {
|
|
final byte[] x_bytes;
|
|
|
|
TLRPC.PasswordKdfAlgo current_algo = currentPassword.current_algo;
|
|
if (current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
|
|
byte[] passwordBytes = AndroidUtilities.getStringBytes(oldPassword);
|
|
TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) current_algo;
|
|
x_bytes = SRPHelper.getX(passwordBytes, algo);
|
|
} else {
|
|
x_bytes = null;
|
|
}
|
|
|
|
|
|
final TLRPC.TL_auth_checkPassword req = new TLRPC.TL_auth_checkPassword();
|
|
|
|
RequestDelegate requestDelegate = (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
if (error != null && "SRP_ID_INVALID".equals(error.text)) {
|
|
TLRPC.TL_account_getPassword getPasswordReq = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(getPasswordReq, (response2, error2) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (error2 == null) {
|
|
currentPassword = (TLRPC.TL_account_password) response2;
|
|
onNextPressed(null);
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin);
|
|
return;
|
|
}
|
|
|
|
if (response instanceof TLRPC.TL_auth_authorization) {
|
|
showDoneButton(false, true);
|
|
postDelayed(() -> {
|
|
needHideProgress(false, false);
|
|
AndroidUtilities.hideKeyboard(codeField);
|
|
onAuthSuccess((TLRPC.TL_auth_authorization) response);
|
|
}, 150);
|
|
} else {
|
|
needHideProgress(false);
|
|
if (error.text.equals("PASSWORD_HASH_INVALID")) {
|
|
onPasscodeError(true);
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
int time = Utilities.parseInt(error.text);
|
|
String timeString;
|
|
if (time < 60) {
|
|
timeString = LocaleController.formatPluralString("Seconds", time);
|
|
} else {
|
|
timeString = LocaleController.formatPluralString("Minutes", time / 60);
|
|
}
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (current_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
|
|
req.password = SRPHelper.startCheck(x_bytes, currentPassword.srp_id, currentPassword.srp_B, (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) current_algo);
|
|
if (req.password == null) {
|
|
TLRPC.TL_error error = new TLRPC.TL_error();
|
|
error.text = "PASSWORD_HASH_INVALID";
|
|
requestDelegate.run(null, error);
|
|
return;
|
|
}
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, requestDelegate, ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
nextPressed = false;
|
|
needHideProgress(true);
|
|
currentParams = null;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (codeField != null) {
|
|
codeField.requestFocus();
|
|
codeField.setSelection(codeField.length());
|
|
showKeyboard(codeField);
|
|
lockImageView.getAnimatedDrawable().setCurrentFrame(0, false);
|
|
lockImageView.playAnimation();
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
String code = codeField.getText().toString();
|
|
if (code.length() != 0) {
|
|
bundle.putString("passview_code", code);
|
|
}
|
|
if (currentParams != null) {
|
|
bundle.putBundle("passview_params", currentParams);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("passview_params");
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
String code = bundle.getString("passview_code");
|
|
if (code != null) {
|
|
codeField.setText(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivityResetWaitView extends SlideView {
|
|
|
|
private RLottieImageView waitImageView;
|
|
private TextView titleView;
|
|
private TextView confirmTextView;
|
|
private TextView resetAccountButton;
|
|
private TextView resetAccountTime;
|
|
private TextView resetAccountText;
|
|
private Runnable timeRunnable;
|
|
|
|
private Bundle currentParams;
|
|
private String requestPhone;
|
|
private String phoneHash;
|
|
private String phoneCode;
|
|
private int startTime;
|
|
private int waitTime;
|
|
|
|
private Boolean wasResetButtonActive;
|
|
|
|
public LoginActivityResetWaitView(Context context) {
|
|
super(context);
|
|
|
|
setOrientation(VERTICAL);
|
|
|
|
LinearLayout innerLinearLayout = new LinearLayout(context);
|
|
innerLinearLayout.setOrientation(VERTICAL);
|
|
innerLinearLayout.setGravity(Gravity.CENTER);
|
|
|
|
FrameLayout waitFrameLayout = new FrameLayout(context);
|
|
waitImageView = new RLottieImageView(context);
|
|
waitImageView.setAutoRepeat(true);
|
|
waitImageView.setAnimation(R.raw.sandclock, 120, 120);
|
|
waitFrameLayout.addView(waitImageView, LayoutHelper.createFrame(120, 120, Gravity.CENTER_HORIZONTAL));
|
|
waitFrameLayout.setVisibility(AndroidUtilities.displaySize.x > AndroidUtilities.displaySize.y && !AndroidUtilities.isTablet() ? GONE : VISIBLE);
|
|
innerLinearLayout.addView(waitFrameLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL));
|
|
|
|
titleView = new TextView(context);
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleView.setText(LocaleController.getString(R.string.ResetAccount));
|
|
titleView.setGravity(Gravity.CENTER);
|
|
titleView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
innerLinearLayout.addView(titleView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 32, 16, 32, 0));
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
confirmTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
innerLinearLayout.addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 12, 8, 12, 0));
|
|
|
|
addView(innerLinearLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 0, 1f));
|
|
|
|
resetAccountText = new TextView(context);
|
|
resetAccountText.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
resetAccountText.setText(LocaleController.getString("ResetAccountStatus", R.string.ResetAccountStatus));
|
|
resetAccountText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
resetAccountText.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(resetAccountText, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | Gravity.CENTER_HORIZONTAL, 0, 24, 0, 0));
|
|
|
|
resetAccountTime = new TextView(context);
|
|
resetAccountTime.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
resetAccountTime.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 20);
|
|
resetAccountTime.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
resetAccountTime.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(resetAccountTime, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 0, 8, 0, 0));
|
|
|
|
resetAccountButton = new TextView(context);
|
|
resetAccountButton.setGravity(Gravity.CENTER);
|
|
resetAccountButton.setText(LocaleController.getString(R.string.ResetAccount));
|
|
resetAccountButton.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
resetAccountButton.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
resetAccountButton.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
resetAccountButton.setPadding(AndroidUtilities.dp(34), 0, AndroidUtilities.dp(34), 0);
|
|
resetAccountButton.setTextColor(Color.WHITE);
|
|
addView(resetAccountButton, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 50, Gravity.CENTER_HORIZONTAL, 16, 32, 16, 48));
|
|
resetAccountButton.setOnClickListener(view -> {
|
|
if (radialProgressView.getTag() != null) {
|
|
return;
|
|
}
|
|
showDialog(new AlertDialog.Builder(getParentActivity())
|
|
.setTitle(LocaleController.getString("ResetMyAccountWarning", R.string.ResetMyAccountWarning))
|
|
.setMessage(LocaleController.getString("ResetMyAccountWarningText", R.string.ResetMyAccountWarningText))
|
|
.setPositiveButton(LocaleController.getString("ResetMyAccountWarningReset", R.string.ResetMyAccountWarningReset), (dialogInterface, i) -> {
|
|
needShowProgress(0);
|
|
TLRPC.TL_account_deleteAccount req = new TLRPC.TL_account_deleteAccount();
|
|
req.reason = "Forgot password";
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
needHideProgress(false);
|
|
if (error == null) {
|
|
if (requestPhone == null || phoneHash == null || phoneCode == null) {
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
return;
|
|
}
|
|
|
|
Bundle params = new Bundle();
|
|
params.putString("phoneFormated", requestPhone);
|
|
params.putString("phoneHash", phoneHash);
|
|
params.putString("code", phoneCode);
|
|
setPage(VIEW_REGISTER, true, params, false);
|
|
} else {
|
|
if (error.text.equals("2FA_RECENT_CONFIRM")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("ResetAccountCancelledAlert", R.string.ResetAccountCancelledAlert));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
})
|
|
.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null).create());
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
titleView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
confirmTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
resetAccountText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
resetAccountTime.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
resetAccountButton.setBackground(Theme.createSimpleSelectorRoundRectDrawable(AndroidUtilities.dp(6), Theme.getColor(Theme.key_changephoneinfo_image2), Theme.getColor(Theme.key_chats_actionPressedBackground)));
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("ResetAccount", R.string.ResetAccount);
|
|
}
|
|
|
|
private void updateTimeText() {
|
|
int timeLeft = Math.max(0, waitTime - (ConnectionsManager.getInstance(currentAccount).getCurrentTime() - startTime));
|
|
int days = timeLeft / 86400;
|
|
int daysRounded = (int) Math.round(timeLeft / (float) 86400);
|
|
int hours = timeLeft / 3600;
|
|
int minutes = (timeLeft / 60) % 60;
|
|
int seconds = timeLeft % 60;
|
|
if (days >= 2) {
|
|
resetAccountTime.setText(LocaleController.formatPluralString("Days", daysRounded));
|
|
} else {
|
|
resetAccountTime.setText(String.format(Locale.getDefault(), "%02d:%02d:%02d", hours, minutes, seconds));
|
|
}
|
|
|
|
boolean isResetButtonActive = timeLeft == 0;
|
|
if (wasResetButtonActive == null || wasResetButtonActive != isResetButtonActive) {
|
|
if (!isResetButtonActive) {
|
|
waitImageView.setAutoRepeat(true);
|
|
if (!waitImageView.isPlaying()) {
|
|
waitImageView.playAnimation();
|
|
}
|
|
} else {
|
|
waitImageView.getAnimatedDrawable().setAutoRepeat(0);
|
|
}
|
|
|
|
resetAccountTime.setVisibility(isResetButtonActive ? INVISIBLE : VISIBLE);
|
|
resetAccountText.setVisibility(isResetButtonActive ? INVISIBLE : VISIBLE);
|
|
resetAccountButton.setVisibility(isResetButtonActive ? VISIBLE : INVISIBLE);
|
|
|
|
wasResetButtonActive = isResetButtonActive;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
currentParams = params;
|
|
requestPhone = params.getString("phoneFormated");
|
|
phoneHash = params.getString("phoneHash");
|
|
phoneCode = params.getString("code");
|
|
startTime = params.getInt("startTime");
|
|
waitTime = params.getInt("waitTime");
|
|
confirmTextView.setText(AndroidUtilities.replaceTags(LocaleController.formatString("ResetAccountInfo", R.string.ResetAccountInfo, LocaleController.addNbsp(PhoneFormat.getInstance().format("+" + requestPhone)))));
|
|
updateTimeText();
|
|
timeRunnable = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (timeRunnable != this) {
|
|
return;
|
|
}
|
|
updateTimeText();
|
|
AndroidUtilities.runOnUIThread(timeRunnable, 1000);
|
|
}
|
|
};
|
|
AndroidUtilities.runOnUIThread(timeRunnable, 1000);
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
needHideProgress(true);
|
|
AndroidUtilities.cancelRunOnUIThread(timeRunnable);
|
|
timeRunnable = null;
|
|
currentParams = null;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
if (currentParams != null) {
|
|
bundle.putBundle("resetview_params", currentParams);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("resetview_params");
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivityRecoverView extends SlideView {
|
|
|
|
private CodeFieldContainer codeFieldContainer;
|
|
private TextView titleView;
|
|
private TextView confirmTextView;
|
|
private TextView troubleButton;
|
|
private RLottieImageView inboxImageView;
|
|
|
|
private Bundle currentParams;
|
|
private String passwordString;
|
|
private boolean nextPressed;
|
|
|
|
private String requestPhone, phoneHash, phoneCode;
|
|
|
|
private boolean postedErrorColorTimeout;
|
|
private Runnable errorColorTimeout = () -> {
|
|
postedErrorColorTimeout = false;
|
|
for (int i = 0; i < codeFieldContainer.codeField.length; i++) {
|
|
codeFieldContainer.codeField[i].animateErrorProgress(0);
|
|
}
|
|
};
|
|
|
|
public LoginActivityRecoverView(Context context) {
|
|
super(context);
|
|
|
|
setOrientation(VERTICAL);
|
|
|
|
FrameLayout inboxFrameLayout = new FrameLayout(context);
|
|
inboxImageView = new RLottieImageView(context);
|
|
inboxImageView.setAnimation(R.raw.tsv_setup_mail, 120, 120);
|
|
inboxImageView.setAutoRepeat(false);
|
|
inboxFrameLayout.addView(inboxImageView, LayoutHelper.createFrame(120, 120, Gravity.CENTER_HORIZONTAL));
|
|
inboxFrameLayout.setVisibility(AndroidUtilities.isSmallScreen() || (AndroidUtilities.displaySize.x > AndroidUtilities.displaySize.y && !AndroidUtilities.isTablet()) ? GONE : VISIBLE);
|
|
addView(inboxFrameLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL));
|
|
|
|
titleView = new TextView(context);
|
|
titleView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleView.setText(LocaleController.getString(R.string.EnterCode));
|
|
titleView.setGravity(Gravity.CENTER);
|
|
titleView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(titleView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 32, 16, 32, 0));
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
confirmTextView.setGravity(Gravity.CENTER);
|
|
confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
confirmTextView.setText(LocaleController.getString(R.string.RestoreEmailSentInfo));
|
|
addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 12, 8, 12, 0));
|
|
|
|
codeFieldContainer = new CodeFieldContainer(context) {
|
|
@Override
|
|
protected void processNextPressed() {
|
|
onNextPressed(null);
|
|
}
|
|
};
|
|
codeFieldContainer.setNumbersCount(6, AUTH_TYPE_MESSAGE);
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.setShowSoftInputOnFocusCompat(!(hasCustomKeyboard() && !isCustomKeyboardForceDisabled()));
|
|
f.addTextChangedListener(new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
if (postedErrorColorTimeout) {
|
|
removeCallbacks(errorColorTimeout);
|
|
errorColorTimeout.run();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {}
|
|
});
|
|
f.setOnFocusChangeListener((v, hasFocus) -> {
|
|
if (hasFocus) {
|
|
keyboardView.setEditText((EditText) v);
|
|
keyboardView.setDispatchBackWhenEmpty(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
addView(codeFieldContainer, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, 42, Gravity.CENTER_HORIZONTAL, 0, 32, 0, 0));
|
|
|
|
troubleButton = new SpoilersTextView(context);
|
|
troubleButton.setGravity(Gravity.CENTER);
|
|
troubleButton.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
troubleButton.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
troubleButton.setPadding(AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16));
|
|
troubleButton.setMaxLines(2);
|
|
|
|
troubleButton.setOnClickListener(view -> {
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity())
|
|
.setTitle(LocaleController.getString("RestorePasswordNoEmailTitle", R.string.RestorePasswordNoEmailTitle))
|
|
.setMessage(LocaleController.getString("RestoreEmailTroubleText", R.string.RestoreEmailTroubleText))
|
|
.setPositiveButton(LocaleController.getString(R.string.OK), (dialogInterface, i) -> setPage(VIEW_PASSWORD, true, new Bundle(), true))
|
|
.setNegativeButton(LocaleController.getString(R.string.ResetAccount), (dialog, which) -> tryResetAccount(requestPhone, phoneHash, phoneCode));
|
|
Dialog dialog = showDialog(builder.create());
|
|
if (dialog != null) {
|
|
dialog.setCanceledOnTouchOutside(false);
|
|
dialog.setCancelable(false);
|
|
}
|
|
});
|
|
|
|
FrameLayout bottomContainer = new FrameLayout(context);
|
|
bottomContainer.addView(troubleButton, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.BOTTOM, 0, 0, 0, 32));
|
|
addView(bottomContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, 0, 1f));
|
|
VerticalPositionAutoAnimator.attach(troubleButton);
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
titleView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
confirmTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
troubleButton.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
|
|
|
|
codeFieldContainer.invalidate();
|
|
}
|
|
|
|
@Override
|
|
protected void onDetachedFromWindow() {
|
|
super.onDetachedFromWindow();
|
|
removeCallbacks(errorColorTimeout);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomKeyboard() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("LoginPassword", R.string.LoginPassword);
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
codeFieldContainer.setText("");
|
|
currentParams = params;
|
|
passwordString = currentParams.getString("password");
|
|
requestPhone = currentParams.getString("requestPhone");
|
|
phoneHash = currentParams.getString("phoneHash");
|
|
phoneCode = currentParams.getString("phoneCode");
|
|
String rawPattern = currentParams.getString("email_unconfirmed_pattern");
|
|
SpannableStringBuilder unconfirmedPattern = SpannableStringBuilder.valueOf(rawPattern);
|
|
int startIndex = rawPattern.indexOf('*'), endIndex = rawPattern.lastIndexOf('*');
|
|
if (startIndex != endIndex && startIndex != -1 && endIndex != -1) {
|
|
TextStyleSpan.TextStyleRun run = new TextStyleSpan.TextStyleRun();
|
|
run.flags |= TextStyleSpan.FLAG_STYLE_SPOILER;
|
|
run.start = startIndex;
|
|
run.end = endIndex + 1;
|
|
unconfirmedPattern.setSpan(new TextStyleSpan(run), startIndex, endIndex + 1, 0);
|
|
}
|
|
troubleButton.setText(AndroidUtilities.formatSpannable(LocaleController.getString(R.string.RestoreEmailNoAccess), unconfirmedPattern));
|
|
|
|
showKeyboard(codeFieldContainer);
|
|
codeFieldContainer.requestFocus();
|
|
}
|
|
|
|
private void onPasscodeError(boolean clear) {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
try {
|
|
codeFieldContainer.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
|
|
} catch (Exception ignore) {}
|
|
if (clear) {
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.setText("");
|
|
}
|
|
}
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.animateErrorProgress(1f);
|
|
}
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
AndroidUtilities.shakeViewSpring(codeFieldContainer, () -> {
|
|
postDelayed(()-> {
|
|
codeFieldContainer.isFocusSuppressed = false;
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
|
|
for (int a = 0; a < codeFieldContainer.codeField.length; a++) {
|
|
codeFieldContainer.codeField[a].animateErrorProgress(0f);
|
|
}
|
|
}, 150);
|
|
|
|
removeCallbacks(errorColorTimeout);
|
|
postDelayed(errorColorTimeout, 3000);
|
|
postedErrorColorTimeout = true;
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
|
|
codeFieldContainer.isFocusSuppressed = true;
|
|
for (CodeNumberField f : codeFieldContainer.codeField) {
|
|
f.animateFocusedProgress(0);
|
|
}
|
|
|
|
code = codeFieldContainer.getCode();
|
|
if (code.length() == 0) {
|
|
onPasscodeError(false);
|
|
return;
|
|
}
|
|
nextPressed = true;
|
|
needShowProgress(0);
|
|
TLRPC.TL_auth_checkRecoveryPassword req = new TLRPC.TL_auth_checkRecoveryPassword();
|
|
req.code = code;
|
|
String finalCode = code;
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
needHideProgress(false);
|
|
nextPressed = false;
|
|
if (response instanceof TLRPC.TL_boolTrue) {
|
|
Bundle params = new Bundle();
|
|
params.putString("emailCode", finalCode);
|
|
params.putString("password", passwordString);
|
|
setPage(VIEW_NEW_PASSWORD_STAGE_1, true, params, false);
|
|
} else {
|
|
if (error == null || error.text.startsWith("CODE_INVALID")) {
|
|
onPasscodeError(true);
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
int time = Utilities.parseInt(error.text);
|
|
String timeString;
|
|
if (time < 60) {
|
|
timeString = LocaleController.formatPluralString("Seconds", time);
|
|
} else {
|
|
timeString = LocaleController.formatPluralString("Minutes", time / 60);
|
|
}
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
needHideProgress(true);
|
|
currentParams = null;
|
|
nextPressed = false;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
inboxImageView.getAnimatedDrawable().setCurrentFrame(0, false);
|
|
inboxImageView.playAnimation();
|
|
if (codeFieldContainer != null) {
|
|
codeFieldContainer.codeField[0].requestFocus();
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
String code = codeFieldContainer.getCode();
|
|
if (code != null && code.length() != 0) {
|
|
bundle.putString("recoveryview_code", code);
|
|
}
|
|
if (currentParams != null) {
|
|
bundle.putBundle("recoveryview_params", currentParams);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("recoveryview_params");
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
String code = bundle.getString("recoveryview_code");
|
|
if (code != null) {
|
|
codeFieldContainer.setText(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivityNewPasswordView extends SlideView {
|
|
|
|
private OutlineTextContainerView[] outlineFields;
|
|
private EditTextBoldCursor[] codeField;
|
|
private TextView titleTextView;
|
|
private TextView confirmTextView;
|
|
private TextView cancelButton;
|
|
private ImageView passwordButton;
|
|
|
|
private String emailCode;
|
|
private String newPassword;
|
|
private String passwordString;
|
|
private TLRPC.TL_account_password currentPassword;
|
|
private Bundle currentParams;
|
|
private boolean nextPressed;
|
|
private int currentStage;
|
|
|
|
private boolean isPasswordVisible;
|
|
|
|
public LoginActivityNewPasswordView(Context context, int stage) {
|
|
super(context);
|
|
currentStage = stage;
|
|
|
|
setOrientation(VERTICAL);
|
|
|
|
codeField = new EditTextBoldCursor[stage == 1 ? 1 : 2];
|
|
outlineFields = new OutlineTextContainerView[codeField.length];
|
|
|
|
titleTextView = new TextView(context);
|
|
titleTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
titleTextView.setGravity(Gravity.TOP | Gravity.CENTER_HORIZONTAL);
|
|
titleTextView.setText(LocaleController.getString(R.string.SetNewPassword));
|
|
addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 8, AndroidUtilities.isSmallScreen() ? 16 : 72, 8, 0));
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
confirmTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
confirmTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(confirmTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 8, 6, 8, 16));
|
|
|
|
for (int a = 0; a < codeField.length; a++) {
|
|
OutlineTextContainerView outlineField = new OutlineTextContainerView(context);
|
|
outlineFields[a] = outlineField;
|
|
outlineField.setText(LocaleController.getString(stage == 0 ? a == 0 ? R.string.PleaseEnterNewFirstPasswordHint : R.string.PleaseEnterNewSecondPasswordHint : R.string.PasswordHintPlaceholder));
|
|
|
|
codeField[a] = new EditTextBoldCursor(context);
|
|
codeField[a].setCursorSize(AndroidUtilities.dp(20));
|
|
codeField[a].setCursorWidth(1.5f);
|
|
codeField[a].setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
codeField[a].setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
codeField[a].setMaxLines(1);
|
|
codeField[a].setBackground(null);
|
|
|
|
int padding = AndroidUtilities.dp(16);
|
|
codeField[a].setPadding(padding, padding, padding, padding);
|
|
if (stage == 0) {
|
|
codeField[a].setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
|
|
}
|
|
codeField[a].setTransformationMethod(PasswordTransformationMethod.getInstance());
|
|
codeField[a].setTypeface(Typeface.DEFAULT);
|
|
codeField[a].setGravity(LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT);
|
|
|
|
EditText field = codeField[a];
|
|
boolean showPasswordButton = a == 0 && stage == 0;
|
|
field.addTextChangedListener(new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {
|
|
if (showPasswordButton) {
|
|
if (passwordButton.getVisibility() != VISIBLE && !TextUtils.isEmpty(s)) {
|
|
if (isPasswordVisible) {
|
|
passwordButton.callOnClick();
|
|
}
|
|
AndroidUtilities.updateViewVisibilityAnimated(passwordButton, true, 0.1f, true);
|
|
} else if (passwordButton.getVisibility() != GONE && TextUtils.isEmpty(s)) {
|
|
AndroidUtilities.updateViewVisibilityAnimated(passwordButton, false, 0.1f, true);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
codeField[a].setOnFocusChangeListener((v, hasFocus) -> outlineField.animateSelection(hasFocus ? 1f : 0f));
|
|
|
|
if (showPasswordButton) {
|
|
LinearLayout linearLayout = new LinearLayout(context);
|
|
linearLayout.setOrientation(HORIZONTAL);
|
|
linearLayout.setGravity(Gravity.CENTER_VERTICAL);
|
|
linearLayout.addView(codeField[a], LayoutHelper.createLinear(0, LayoutHelper.WRAP_CONTENT, 1f));
|
|
|
|
passwordButton = new ImageView(context);
|
|
passwordButton.setImageResource(R.drawable.msg_message);
|
|
AndroidUtilities.updateViewVisibilityAnimated(passwordButton, true, 0.1f, false);
|
|
passwordButton.setOnClickListener(v -> {
|
|
isPasswordVisible = !isPasswordVisible;
|
|
|
|
for (int i = 0; i < codeField.length; i++) {
|
|
int selectionStart = codeField[i].getSelectionStart(), selectionEnd = codeField[i].getSelectionEnd();
|
|
codeField[i].setInputType(InputType.TYPE_CLASS_TEXT | (isPasswordVisible ? InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD : InputType.TYPE_TEXT_VARIATION_PASSWORD));
|
|
codeField[i].setSelection(selectionStart, selectionEnd);
|
|
}
|
|
|
|
passwordButton.setTag(isPasswordVisible);
|
|
passwordButton.setColorFilter(Theme.getColor(isPasswordVisible ? Theme.key_windowBackgroundWhiteInputFieldActivated : Theme.key_windowBackgroundWhiteHintText));
|
|
});
|
|
linearLayout.addView(passwordButton, LayoutHelper.createLinearRelatively(24, 24, 0, 0, 0, 14, 0));
|
|
|
|
outlineField.addView(linearLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
|
|
} else {
|
|
outlineField.addView(codeField[a], LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT));
|
|
}
|
|
outlineField.attachEditText(codeField[a]);
|
|
addView(outlineField, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 16, 16, 16, 0));
|
|
int num = a;
|
|
codeField[a].setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (num == 0 && codeField.length == 2) {
|
|
codeField[1].requestFocus();
|
|
return true;
|
|
} else if (i == EditorInfo.IME_ACTION_NEXT) {
|
|
onNextPressed(null);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
if (stage == 0) {
|
|
confirmTextView.setText(LocaleController.getString("PleaseEnterNewFirstPasswordLogin", R.string.PleaseEnterNewFirstPasswordLogin));
|
|
} else {
|
|
confirmTextView.setText(LocaleController.getString("PasswordHintTextLogin", R.string.PasswordHintTextLogin));
|
|
}
|
|
|
|
cancelButton = new TextView(context);
|
|
cancelButton.setGravity(Gravity.CENTER | Gravity.LEFT);
|
|
cancelButton.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 15);
|
|
cancelButton.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
cancelButton.setPadding(AndroidUtilities.dp(16), 0, AndroidUtilities.dp(16), 0);
|
|
cancelButton.setText(LocaleController.getString(R.string.YourEmailSkip));
|
|
|
|
FrameLayout bottomContainer = new FrameLayout(context);
|
|
bottomContainer.addView(cancelButton, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, (Build.VERSION.SDK_INT >= 21 ? 56 : 60), Gravity.BOTTOM, 0, 0, 0, 32));
|
|
addView(bottomContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.BOTTOM));
|
|
VerticalPositionAutoAnimator.attach(cancelButton);
|
|
|
|
cancelButton.setOnClickListener(view -> {
|
|
if (currentStage == 0) {
|
|
recoverPassword(null, null);
|
|
} else {
|
|
recoverPassword(newPassword, null);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
titleTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
confirmTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
for (EditTextBoldCursor editText : codeField) {
|
|
editText.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
editText.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated));
|
|
}
|
|
for (OutlineTextContainerView outlineField : outlineFields) {
|
|
outlineField.updateColor();
|
|
}
|
|
cancelButton.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
|
|
if (passwordButton != null) {
|
|
passwordButton.setColorFilter(Theme.getColor(isPasswordVisible ? Theme.key_windowBackgroundWhiteInputFieldActivated : Theme.key_windowBackgroundWhiteHintText));
|
|
passwordButton.setBackground(Theme.createSelectorDrawable(getThemedColor(Theme.key_listSelector), 1));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("NewPassword", R.string.NewPassword);
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
for (int a = 0; a < codeField.length; a++) {
|
|
codeField[a].setText("");
|
|
}
|
|
currentParams = params;
|
|
emailCode = currentParams.getString("emailCode");
|
|
passwordString = currentParams.getString("password");
|
|
if (passwordString != null) {
|
|
SerializedData data = new SerializedData(Utilities.hexToBytes(passwordString));
|
|
currentPassword = TLRPC.TL_account_password.TLdeserialize(data, data.readInt32(false), false);
|
|
TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
|
|
}
|
|
newPassword = currentParams.getString("new_password");
|
|
|
|
showKeyboard(codeField[0]);
|
|
codeField[0].requestFocus();
|
|
}
|
|
|
|
private void onPasscodeError(boolean clear, int num) {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
try {
|
|
codeField[num].performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP, HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
|
|
} catch (Exception ignore) {}
|
|
AndroidUtilities.shakeView(codeField[num], 2, 0);
|
|
}
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
|
|
code = codeField[0].getText().toString();
|
|
if (code.length() == 0) {
|
|
onPasscodeError(false, 0);
|
|
return;
|
|
}
|
|
if (currentStage == 0) {
|
|
if (!code.equals(codeField[1].getText().toString())) {
|
|
onPasscodeError(false, 1);
|
|
return;
|
|
}
|
|
Bundle params = new Bundle();
|
|
params.putString("emailCode", emailCode);
|
|
params.putString("new_password", code);
|
|
params.putString("password", passwordString);
|
|
setPage(VIEW_NEW_PASSWORD_STAGE_2, true, params, false);
|
|
} else {
|
|
nextPressed = true;
|
|
needShowProgress(0);
|
|
recoverPassword(newPassword, code);
|
|
}
|
|
}
|
|
|
|
private void recoverPassword(String password, String hint) {
|
|
TLRPC.TL_auth_recoverPassword req = new TLRPC.TL_auth_recoverPassword();
|
|
req.code = emailCode;
|
|
if (!TextUtils.isEmpty(password)) {
|
|
req.flags |= 1;
|
|
req.new_settings = new TLRPC.TL_account_passwordInputSettings();
|
|
req.new_settings.flags |= 1;
|
|
req.new_settings.hint = hint != null ? hint : "";
|
|
req.new_settings.new_algo = currentPassword.new_algo;
|
|
}
|
|
Utilities.globalQueue.postRunnable(() -> {
|
|
byte[] newPasswordBytes;
|
|
if (password != null) {
|
|
newPasswordBytes = AndroidUtilities.getStringBytes(password);
|
|
} else {
|
|
newPasswordBytes = null;
|
|
}
|
|
|
|
RequestDelegate requestDelegate = (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (error != null && ("SRP_ID_INVALID".equals(error.text) || "NEW_SALT_INVALID".equals(error.text))) {
|
|
TLRPC.TL_account_getPassword getPasswordReq = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(getPasswordReq, (response2, error2) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (error2 == null) {
|
|
currentPassword = (TLRPC.TL_account_password) response2;
|
|
TwoStepVerificationActivity.initPasswordNewAlgo(currentPassword);
|
|
recoverPassword(password, hint);
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin);
|
|
return;
|
|
}
|
|
needHideProgress(false);
|
|
if (response instanceof TLRPC.auth_Authorization) {
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setPositiveButton(LocaleController.getString(R.string.Continue), (dialogInterface, i) -> onAuthSuccess((TLRPC.TL_auth_authorization) response));
|
|
if (TextUtils.isEmpty(password)) {
|
|
builder.setMessage(LocaleController.getString(R.string.YourPasswordReset));
|
|
} else {
|
|
builder.setMessage(LocaleController.getString(R.string.YourPasswordChangedSuccessText));
|
|
}
|
|
builder.setTitle(LocaleController.getString(R.string.TwoStepVerificationTitle));
|
|
Dialog dialog = showDialog(builder.create());
|
|
if (dialog != null) {
|
|
dialog.setCanceledOnTouchOutside(false);
|
|
dialog.setCancelable(false);
|
|
}
|
|
} else if (error != null) {
|
|
nextPressed = false;
|
|
if (error.text.startsWith("FLOOD_WAIT")) {
|
|
int time = Utilities.parseInt(error.text);
|
|
String timeString;
|
|
if (time < 60) {
|
|
timeString = LocaleController.formatPluralString("Seconds", time);
|
|
} else {
|
|
timeString = LocaleController.formatPluralString("Minutes", time / 60);
|
|
}
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.formatString("FloodWaitTime", R.string.FloodWaitTime, timeString));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (currentPassword.new_algo instanceof TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
|
|
if (password != null) {
|
|
TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow algo = (TLRPC.TL_passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) currentPassword.new_algo;
|
|
req.new_settings.new_password_hash = SRPHelper.getVBytes(newPasswordBytes, algo);
|
|
if (req.new_settings.new_password_hash == null) {
|
|
TLRPC.TL_error error = new TLRPC.TL_error();
|
|
error.text = "ALGO_INVALID";
|
|
requestDelegate.run(null, error);
|
|
}
|
|
}
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, requestDelegate, ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else {
|
|
TLRPC.TL_error error = new TLRPC.TL_error();
|
|
error.text = "PASSWORD_HASH_INVALID";
|
|
requestDelegate.run(null, error);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
needHideProgress(true);
|
|
currentParams = null;
|
|
nextPressed = false;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (codeField != null) {
|
|
codeField[0].requestFocus();
|
|
codeField[0].setSelection(codeField[0].length());
|
|
AndroidUtilities.showKeyboard(codeField[0]);
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
if (currentParams != null) {
|
|
bundle.putBundle("recoveryview_params" + currentStage, currentParams);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("recoveryview_params" + currentStage);
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LoginActivityRegisterView extends SlideView implements ImageUpdater.ImageUpdaterDelegate {
|
|
private OutlineTextContainerView firstNameOutlineView, lastNameOutlineView;
|
|
|
|
private EditTextBoldCursor firstNameField;
|
|
private EditTextBoldCursor lastNameField;
|
|
private BackupImageView avatarImage;
|
|
private AvatarDrawable avatarDrawable;
|
|
private View avatarOverlay;
|
|
private RLottieImageView avatarEditor;
|
|
private RadialProgressView avatarProgressView;
|
|
private AnimatorSet avatarAnimation;
|
|
private TextView descriptionTextView;
|
|
private TextView wrongNumber;
|
|
private TextView privacyView;
|
|
private TextView titleTextView;
|
|
private FrameLayout editTextContainer;
|
|
private String requestPhone;
|
|
private String phoneHash;
|
|
private Bundle currentParams;
|
|
private boolean nextPressed = false;
|
|
|
|
private RLottieDrawable cameraDrawable;
|
|
private RLottieDrawable cameraWaitDrawable;
|
|
private boolean isCameraWaitAnimationAllowed = true;
|
|
|
|
private ImageUpdater imageUpdater;
|
|
|
|
private TLRPC.FileLocation avatar;
|
|
private TLRPC.FileLocation avatarBig;
|
|
|
|
private boolean createAfterUpload;
|
|
|
|
public class LinkSpan extends ClickableSpan {
|
|
@Override
|
|
public void updateDrawState(TextPaint ds) {
|
|
super.updateDrawState(ds);
|
|
ds.setUnderlineText(false);
|
|
}
|
|
|
|
@Override
|
|
public void onClick(View widget) {
|
|
showTermsOfService(false);
|
|
}
|
|
}
|
|
|
|
private void showTermsOfService(boolean needAccept) {
|
|
if (currentTermsOfService == null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setTitle(LocaleController.getString("TermsOfService", R.string.TermsOfService));
|
|
|
|
if (needAccept) {
|
|
builder.setPositiveButton(LocaleController.getString("Accept", R.string.Accept), (dialog, which) -> {
|
|
currentTermsOfService.popup = false;
|
|
onNextPressed(null);
|
|
});
|
|
builder.setNegativeButton(LocaleController.getString("Decline", R.string.Decline), (dialog, which) -> {
|
|
AlertDialog.Builder builder1 = new AlertDialog.Builder(getParentActivity());
|
|
builder1.setTitle(LocaleController.getString("TermsOfService", R.string.TermsOfService));
|
|
builder1.setMessage(LocaleController.getString("TosDecline", R.string.TosDecline));
|
|
builder1.setPositiveButton(LocaleController.getString("SignUp", R.string.SignUp), (dialog1, which1) -> {
|
|
currentTermsOfService.popup = false;
|
|
onNextPressed(null);
|
|
});
|
|
builder1.setNegativeButton(LocaleController.getString("Decline", R.string.Decline), (dialog12, which12) -> {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
});
|
|
showDialog(builder1.create());
|
|
});
|
|
} else {
|
|
builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
|
|
}
|
|
|
|
SpannableStringBuilder text = new SpannableStringBuilder(currentTermsOfService.text);
|
|
MessageObject.addEntitiesToText(text, currentTermsOfService.entities, false, false, false, false);
|
|
builder.setMessage(text);
|
|
|
|
showDialog(builder.create());
|
|
}
|
|
|
|
public LoginActivityRegisterView(Context context) {
|
|
super(context);
|
|
|
|
setOrientation(VERTICAL);
|
|
|
|
imageUpdater = new ImageUpdater(false);
|
|
imageUpdater.setOpenWithFrontfaceCamera(true);
|
|
imageUpdater.setSearchAvailable(false);
|
|
imageUpdater.setUploadAfterSelect(false);
|
|
imageUpdater.parentFragment = LoginActivity.this;
|
|
imageUpdater.setDelegate(this);
|
|
|
|
FrameLayout avatarContainer = new FrameLayout(context);
|
|
addView(avatarContainer, LayoutHelper.createLinear(78, 78, Gravity.CENTER_HORIZONTAL));
|
|
|
|
avatarDrawable = new AvatarDrawable();
|
|
|
|
avatarImage = new BackupImageView(context) {
|
|
@Override
|
|
public void invalidate() {
|
|
if (avatarOverlay != null) {
|
|
avatarOverlay.invalidate();
|
|
}
|
|
super.invalidate();
|
|
}
|
|
|
|
@Override
|
|
public void invalidate(int l, int t, int r, int b) {
|
|
if (avatarOverlay != null) {
|
|
avatarOverlay.invalidate();
|
|
}
|
|
super.invalidate(l, t, r, b);
|
|
}
|
|
};
|
|
avatarImage.setRoundRadius(AndroidUtilities.dp(64));
|
|
avatarDrawable.setAvatarType(AvatarDrawable.AVATAR_TYPE_REGISTER);
|
|
avatarDrawable.setInfo(5, null, null);
|
|
avatarImage.setImageDrawable(avatarDrawable);
|
|
avatarContainer.addView(avatarImage, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
paint.setColor(0x55000000);
|
|
|
|
avatarOverlay = new View(context) {
|
|
@Override
|
|
protected void onDraw(Canvas canvas) {
|
|
if (avatarImage != null && avatarProgressView.getVisibility() == VISIBLE) {
|
|
paint.setAlpha((int) (0x55 * avatarImage.getImageReceiver().getCurrentAlpha() * avatarProgressView.getAlpha()));
|
|
canvas.drawCircle(getMeasuredWidth() / 2.0f, getMeasuredHeight() / 2.0f, getMeasuredWidth() / 2.0f, paint);
|
|
}
|
|
}
|
|
};
|
|
avatarContainer.addView(avatarOverlay, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
avatarOverlay.setOnClickListener(view -> {
|
|
imageUpdater.openMenu(avatar != null, () -> {
|
|
avatar = null;
|
|
avatarBig = null;
|
|
showAvatarProgress(false, true);
|
|
avatarImage.setImage(null, null, avatarDrawable, null);
|
|
avatarEditor.setImageResource(R.drawable.actions_setphoto);
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
cameraDrawable.setCurrentFrame(0);
|
|
isCameraWaitAnimationAllowed = true;
|
|
}, dialog -> {
|
|
if (!imageUpdater.isUploadingImage()) {
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
cameraDrawable.setCustomEndFrame(86);
|
|
avatarEditor.setOnAnimationEndListener(() -> isCameraWaitAnimationAllowed = true);
|
|
avatarEditor.playAnimation();
|
|
} else {
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
cameraDrawable.setCurrentFrame(0, false);
|
|
isCameraWaitAnimationAllowed = true;
|
|
}
|
|
});
|
|
isCameraWaitAnimationAllowed = false;
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
cameraDrawable.setCurrentFrame(0);
|
|
cameraDrawable.setCustomEndFrame(43);
|
|
avatarEditor.playAnimation();
|
|
});
|
|
|
|
cameraDrawable = new RLottieDrawable(R.raw.camera, String.valueOf(R.raw.camera), AndroidUtilities.dp(70), AndroidUtilities.dp(70), false, null);
|
|
cameraWaitDrawable = new RLottieDrawable(R.raw.camera_wait, String.valueOf(R.raw.camera_wait), AndroidUtilities.dp(70), AndroidUtilities.dp(70), false, null);
|
|
|
|
avatarEditor = new RLottieImageView(context) {
|
|
@Override
|
|
public void invalidate(int l, int t, int r, int b) {
|
|
super.invalidate(l, t, r, b);
|
|
avatarOverlay.invalidate();
|
|
}
|
|
|
|
@Override
|
|
public void invalidate() {
|
|
super.invalidate();
|
|
avatarOverlay.invalidate();
|
|
}
|
|
};
|
|
avatarEditor.setScaleType(ImageView.ScaleType.CENTER);
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
avatarEditor.setEnabled(false);
|
|
avatarEditor.setClickable(false);
|
|
avatarContainer.addView(avatarEditor, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
avatarEditor.addOnAttachStateChangeListener(new OnAttachStateChangeListener() {
|
|
private long lastRun = System.currentTimeMillis();
|
|
private boolean isAttached;
|
|
private Runnable cameraWaitCallback = () -> {
|
|
if (isAttached) {
|
|
if (isCameraWaitAnimationAllowed && System.currentTimeMillis() - lastRun >= 10000) {
|
|
avatarEditor.setAnimation(cameraWaitDrawable);
|
|
cameraWaitDrawable.setCurrentFrame(0, false);
|
|
cameraWaitDrawable.setOnAnimationEndListener(() -> AndroidUtilities.runOnUIThread(()->{
|
|
cameraDrawable.setCurrentFrame(0, false);
|
|
avatarEditor.setAnimation(cameraDrawable);
|
|
}));
|
|
avatarEditor.playAnimation();
|
|
lastRun = System.currentTimeMillis();
|
|
}
|
|
|
|
avatarEditor.postDelayed(this.cameraWaitCallback, 1000);
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public void onViewAttachedToWindow(View v) {
|
|
isAttached = true;
|
|
v.post(cameraWaitCallback);
|
|
}
|
|
|
|
@Override
|
|
public void onViewDetachedFromWindow(View v) {
|
|
isAttached = false;
|
|
v.removeCallbacks(cameraWaitCallback);
|
|
}
|
|
});
|
|
|
|
avatarProgressView = new RadialProgressView(context) {
|
|
@Override
|
|
public void setAlpha(float alpha) {
|
|
super.setAlpha(alpha);
|
|
avatarOverlay.invalidate();
|
|
}
|
|
};
|
|
avatarProgressView.setSize(AndroidUtilities.dp(30));
|
|
avatarProgressView.setProgressColor(0xffffffff);
|
|
avatarContainer.addView(avatarProgressView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
showAvatarProgress(false, false);
|
|
|
|
titleTextView = new TextView(context);
|
|
titleTextView.setText(LocaleController.getString(R.string.RegistrationProfileInfo));
|
|
titleTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
titleTextView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
titleTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
titleTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
addView(titleTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 8, 12, 8, 0));
|
|
|
|
descriptionTextView = new TextView(context);
|
|
descriptionTextView.setText(LocaleController.getString("RegisterText2", R.string.RegisterText2));
|
|
descriptionTextView.setGravity(Gravity.CENTER_HORIZONTAL);
|
|
descriptionTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
descriptionTextView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
addView(descriptionTextView, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL, 8, 6, 8, 0));
|
|
|
|
editTextContainer = new FrameLayout(context);
|
|
addView(editTextContainer, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, 8, 21, 8, 0));
|
|
|
|
firstNameOutlineView = new OutlineTextContainerView(context);
|
|
firstNameOutlineView.setText(LocaleController.getString(R.string.FirstName));
|
|
|
|
firstNameField = new EditTextBoldCursor(context);
|
|
firstNameField.setCursorSize(AndroidUtilities.dp(20));
|
|
firstNameField.setCursorWidth(1.5f);
|
|
firstNameField.setImeOptions(EditorInfo.IME_ACTION_NEXT | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
firstNameField.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 17);
|
|
firstNameField.setMaxLines(1);
|
|
firstNameField.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS);
|
|
firstNameField.setOnFocusChangeListener((v, hasFocus) -> firstNameOutlineView.animateSelection(hasFocus ? 1f : 0f));
|
|
firstNameField.setBackground(null);
|
|
firstNameField.setPadding(AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16));
|
|
|
|
firstNameOutlineView.attachEditText(firstNameField);
|
|
firstNameOutlineView.addView(firstNameField, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP));
|
|
|
|
firstNameField.setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (i == EditorInfo.IME_ACTION_NEXT) {
|
|
lastNameField.requestFocus();
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
lastNameOutlineView = new OutlineTextContainerView(context);
|
|
lastNameOutlineView.setText(LocaleController.getString(R.string.LastName));
|
|
|
|
lastNameField = new EditTextBoldCursor(context);
|
|
lastNameField.setCursorSize(AndroidUtilities.dp(20));
|
|
lastNameField.setCursorWidth(1.5f);
|
|
lastNameField.setImeOptions(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_EXTRACT_UI);
|
|
lastNameField.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 17);
|
|
lastNameField.setMaxLines(1);
|
|
lastNameField.setInputType(InputType.TYPE_TEXT_FLAG_CAP_WORDS);
|
|
lastNameField.setOnFocusChangeListener((v, hasFocus) -> lastNameOutlineView.animateSelection(hasFocus ? 1f : 0f));
|
|
lastNameField.setBackground(null);
|
|
lastNameField.setPadding(AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16), AndroidUtilities.dp(16));
|
|
|
|
lastNameOutlineView.attachEditText(lastNameField);
|
|
lastNameOutlineView.addView(lastNameField, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP));
|
|
|
|
lastNameField.setOnEditorActionListener((textView, i, keyEvent) -> {
|
|
if (i == EditorInfo.IME_ACTION_DONE || i == EditorInfo.IME_ACTION_NEXT) {
|
|
onNextPressed(null);
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
buildEditTextLayout(AndroidUtilities.isSmallScreen());
|
|
|
|
wrongNumber = new TextView(context);
|
|
wrongNumber.setText(LocaleController.getString("CancelRegistration", R.string.CancelRegistration));
|
|
wrongNumber.setGravity((LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT) | Gravity.CENTER_HORIZONTAL);
|
|
wrongNumber.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
wrongNumber.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
wrongNumber.setPadding(0, AndroidUtilities.dp(24), 0, 0);
|
|
wrongNumber.setVisibility(GONE);
|
|
addView(wrongNumber, LayoutHelper.createLinear(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP | (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT), 0, 20, 0, 0));
|
|
wrongNumber.setOnClickListener(view -> {
|
|
if (radialProgressView.getTag() != null) {
|
|
return;
|
|
}
|
|
onBackPressed(false);
|
|
});
|
|
|
|
FrameLayout privacyLayout = new FrameLayout(context);
|
|
addView(privacyLayout, LayoutHelper.createLinear(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT, Gravity.LEFT | Gravity.BOTTOM));
|
|
|
|
privacyView = new TextView(context);
|
|
privacyView.setMovementMethod(new AndroidUtilities.LinkMovementMethodMy());
|
|
privacyView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, AndroidUtilities.isSmallScreen() ? 13 : 14);
|
|
privacyView.setLineSpacing(AndroidUtilities.dp(2), 1.0f);
|
|
privacyView.setGravity(Gravity.CENTER_VERTICAL);
|
|
privacyLayout.addView(privacyView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ? 56 : 60, Gravity.LEFT | Gravity.BOTTOM, 14, 0, 70, 32));
|
|
VerticalPositionAutoAnimator.attach(privacyView);
|
|
|
|
String str = LocaleController.getString("TermsOfServiceLogin", R.string.TermsOfServiceLogin);
|
|
SpannableStringBuilder text = new SpannableStringBuilder(str);
|
|
int index1 = str.indexOf('*');
|
|
int index2 = str.lastIndexOf('*');
|
|
if (index1 != -1 && index2 != -1 && index1 != index2) {
|
|
text.replace(index2, index2 + 1, "");
|
|
text.replace(index1, index1 + 1, "");
|
|
text.setSpan(new LinkSpan(), index1, index2 - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
}
|
|
privacyView.setText(text);
|
|
}
|
|
|
|
@Override
|
|
public void updateColors() {
|
|
avatarDrawable.invalidateSelf();
|
|
titleTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
descriptionTextView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
firstNameField.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
firstNameField.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated));
|
|
lastNameField.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
lastNameField.setCursorColor(Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated));
|
|
wrongNumber.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueText4));
|
|
privacyView.setTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteGrayText6));
|
|
privacyView.setLinkTextColor(Theme.getColor(Theme.key_windowBackgroundWhiteLinkText));
|
|
|
|
firstNameOutlineView.updateColor();
|
|
lastNameOutlineView.updateColor();
|
|
}
|
|
|
|
private void buildEditTextLayout(boolean small) {
|
|
boolean firstHasFocus = firstNameField.hasFocus(), lastHasFocus = lastNameField.hasFocus();
|
|
editTextContainer.removeAllViews();
|
|
|
|
if (small) {
|
|
LinearLayout linearLayout = new LinearLayout(getParentActivity());
|
|
linearLayout.setOrientation(HORIZONTAL);
|
|
|
|
firstNameOutlineView.setText(LocaleController.getString(R.string.FirstNameSmall));
|
|
lastNameOutlineView.setText(LocaleController.getString(R.string.LastNameSmall));
|
|
|
|
linearLayout.addView(firstNameOutlineView, LayoutHelper.createLinear(0, LayoutHelper.WRAP_CONTENT, 1f, 0, 0, 8, 0));
|
|
linearLayout.addView(lastNameOutlineView, LayoutHelper.createLinear(0, LayoutHelper.WRAP_CONTENT, 1f, 8, 0, 0, 0));
|
|
|
|
editTextContainer.addView(linearLayout);
|
|
|
|
if (firstHasFocus) {
|
|
firstNameField.requestFocus();
|
|
AndroidUtilities.showKeyboard(firstNameField);
|
|
} else if (lastHasFocus) {
|
|
lastNameField.requestFocus();
|
|
AndroidUtilities.showKeyboard(lastNameField);
|
|
}
|
|
} else {
|
|
firstNameOutlineView.setText(LocaleController.getString(R.string.FirstName));
|
|
lastNameOutlineView.setText(LocaleController.getString(R.string.LastName));
|
|
|
|
editTextContainer.addView(firstNameOutlineView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP, 8, 0, 8, 0));
|
|
editTextContainer.addView(lastNameOutlineView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, Gravity.TOP, 8, 82, 8, 0));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void didUploadPhoto(final TLRPC.InputFile photo, final TLRPC.InputFile video, double videoStartTimestamp, String videoPath, final TLRPC.PhotoSize bigSize, final TLRPC.PhotoSize smallSize) {
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
avatar = smallSize.location;
|
|
avatarBig = bigSize.location;
|
|
avatarImage.setImage(ImageLocation.getForLocal(avatar), "50_50", avatarDrawable, null);
|
|
});
|
|
}
|
|
|
|
private void showAvatarProgress(boolean show, boolean animated) {
|
|
if (avatarEditor == null) {
|
|
return;
|
|
}
|
|
if (avatarAnimation != null) {
|
|
avatarAnimation.cancel();
|
|
avatarAnimation = null;
|
|
}
|
|
if (animated) {
|
|
avatarAnimation = new AnimatorSet();
|
|
if (show) {
|
|
avatarProgressView.setVisibility(View.VISIBLE);
|
|
|
|
avatarAnimation.playTogether(ObjectAnimator.ofFloat(avatarEditor, View.ALPHA, 0.0f),
|
|
ObjectAnimator.ofFloat(avatarProgressView, View.ALPHA, 1.0f));
|
|
} else {
|
|
avatarEditor.setVisibility(View.VISIBLE);
|
|
|
|
avatarAnimation.playTogether(ObjectAnimator.ofFloat(avatarEditor, View.ALPHA, 1.0f),
|
|
ObjectAnimator.ofFloat(avatarProgressView, View.ALPHA, 0.0f));
|
|
}
|
|
avatarAnimation.setDuration(180);
|
|
avatarAnimation.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (avatarAnimation == null || avatarEditor == null) {
|
|
return;
|
|
}
|
|
if (show) {
|
|
avatarEditor.setVisibility(View.INVISIBLE);
|
|
} else {
|
|
avatarProgressView.setVisibility(View.INVISIBLE);
|
|
}
|
|
avatarAnimation = null;
|
|
}
|
|
|
|
@Override
|
|
public void onAnimationCancel(Animator animation) {
|
|
avatarAnimation = null;
|
|
}
|
|
});
|
|
avatarAnimation.start();
|
|
} else {
|
|
if (show) {
|
|
avatarEditor.setAlpha(1.0f);
|
|
avatarEditor.setVisibility(View.INVISIBLE);
|
|
avatarProgressView.setAlpha(1.0f);
|
|
avatarProgressView.setVisibility(View.VISIBLE);
|
|
} else {
|
|
avatarEditor.setAlpha(1.0f);
|
|
avatarEditor.setVisibility(View.VISIBLE);
|
|
avatarProgressView.setAlpha(0.0f);
|
|
avatarProgressView.setVisibility(View.INVISIBLE);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onBackPressed(boolean force) {
|
|
if (!force) {
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setTitle(LocaleController.getString(R.string.Warning));
|
|
builder.setMessage(LocaleController.getString("AreYouSureRegistration", R.string.AreYouSureRegistration));
|
|
builder.setNegativeButton(LocaleController.getString("Stop", R.string.Stop), (dialogInterface, i) -> {
|
|
onBackPressed(true);
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
hidePrivacyView();
|
|
});
|
|
builder.setPositiveButton(LocaleController.getString("Continue", R.string.Continue), null);
|
|
showDialog(builder.create());
|
|
return false;
|
|
}
|
|
needHideProgress(true);
|
|
nextPressed = false;
|
|
currentParams = null;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String getHeaderName() {
|
|
return LocaleController.getString("YourName", R.string.YourName);
|
|
}
|
|
|
|
@Override
|
|
public void onCancelPressed() {
|
|
nextPressed = false;
|
|
}
|
|
|
|
@Override
|
|
public boolean needBackButton() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onShow() {
|
|
super.onShow();
|
|
if (privacyView != null) {
|
|
if (restoringState) {
|
|
privacyView.setAlpha(1f);
|
|
} else {
|
|
privacyView.setAlpha(0f);
|
|
privacyView.animate().alpha(1f).setDuration(200).setStartDelay(300).setInterpolator(AndroidUtilities.decelerateInterpolator).start();
|
|
}
|
|
}
|
|
if (firstNameField != null) {
|
|
firstNameField.requestFocus();
|
|
firstNameField.setSelection(firstNameField.length());
|
|
AndroidUtilities.showKeyboard(firstNameField);
|
|
}
|
|
AndroidUtilities.runOnUIThread(() -> {
|
|
if (firstNameField != null) {
|
|
firstNameField.requestFocus();
|
|
firstNameField.setSelection(firstNameField.length());
|
|
AndroidUtilities.showKeyboard(firstNameField);
|
|
}
|
|
}, SHOW_DELAY);
|
|
}
|
|
|
|
@Override
|
|
public void setParams(Bundle params, boolean restore) {
|
|
if (params == null) {
|
|
return;
|
|
}
|
|
firstNameField.setText("");
|
|
lastNameField.setText("");
|
|
requestPhone = params.getString("phoneFormated");
|
|
phoneHash = params.getString("phoneHash");
|
|
currentParams = params;
|
|
}
|
|
|
|
@Override
|
|
public void onNextPressed(String code) {
|
|
if (nextPressed) {
|
|
return;
|
|
}
|
|
if (currentTermsOfService != null && currentTermsOfService.popup) {
|
|
showTermsOfService(true);
|
|
return;
|
|
}
|
|
if (firstNameField.length() == 0) {
|
|
onFieldError(firstNameOutlineView, true);
|
|
return;
|
|
}
|
|
nextPressed = true;
|
|
TLRPC.TL_auth_signUp req = new TLRPC.TL_auth_signUp();
|
|
req.phone_code_hash = phoneHash;
|
|
req.phone_number = requestPhone;
|
|
req.first_name = firstNameField.getText().toString();
|
|
req.last_name = lastNameField.getText().toString();
|
|
needShowProgress(0);
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
nextPressed = false;
|
|
if (response instanceof TLRPC.TL_auth_authorization) {
|
|
hidePrivacyView();
|
|
showDoneButton(false, true);
|
|
postDelayed(() -> {
|
|
needHideProgress(false, false);
|
|
AndroidUtilities.hideKeyboard(fragmentView.findFocus());
|
|
onAuthSuccess((TLRPC.TL_auth_authorization) response, true);
|
|
if (avatarBig != null) {
|
|
TLRPC.FileLocation avatar = avatarBig;
|
|
Utilities.cacheClearQueue.postRunnable(()-> MessagesController.getInstance(currentAccount).uploadAndApplyUserAvatar(avatar));
|
|
}
|
|
}, 150);
|
|
} else {
|
|
needHideProgress(false);
|
|
if (error.text.contains("PHONE_NUMBER_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidPhoneNumber", R.string.InvalidPhoneNumber));
|
|
} else if (error.text.contains("PHONE_CODE_EMPTY") || error.text.contains("PHONE_CODE_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidCode", R.string.InvalidCode));
|
|
} else if (error.text.contains("PHONE_CODE_EXPIRED")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("CodeExpired", R.string.CodeExpired));
|
|
} else if (error.text.contains("FIRSTNAME_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidFirstName", R.string.InvalidFirstName));
|
|
} else if (error.text.contains("LASTNAME_INVALID")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("InvalidLastName", R.string.InvalidLastName));
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
}
|
|
|
|
@Override
|
|
public void saveStateParams(Bundle bundle) {
|
|
String first = firstNameField.getText().toString();
|
|
if (first.length() != 0) {
|
|
bundle.putString("registerview_first", first);
|
|
}
|
|
String last = lastNameField.getText().toString();
|
|
if (last.length() != 0) {
|
|
bundle.putString("registerview_last", last);
|
|
}
|
|
if (currentTermsOfService != null) {
|
|
SerializedData data = new SerializedData(currentTermsOfService.getObjectSize());
|
|
currentTermsOfService.serializeToStream(data);
|
|
String str = Base64.encodeToString(data.toByteArray(), Base64.DEFAULT);
|
|
bundle.putString("terms", str);
|
|
data.cleanup();
|
|
}
|
|
if (currentParams != null) {
|
|
bundle.putBundle("registerview_params", currentParams);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void restoreStateParams(Bundle bundle) {
|
|
currentParams = bundle.getBundle("registerview_params");
|
|
if (currentParams != null) {
|
|
setParams(currentParams, true);
|
|
}
|
|
|
|
try {
|
|
String terms = bundle.getString("terms");
|
|
if (terms != null) {
|
|
byte[] arr = Base64.decode(terms, Base64.DEFAULT);
|
|
if (arr != null) {
|
|
SerializedData data = new SerializedData(arr);
|
|
currentTermsOfService = TLRPC.TL_help_termsOfService.TLdeserialize(data, data.readInt32(false), false);
|
|
data.cleanup();
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
FileLog.e(e);
|
|
}
|
|
|
|
String first = bundle.getString("registerview_first");
|
|
if (first != null) {
|
|
firstNameField.setText(first);
|
|
}
|
|
String last = bundle.getString("registerview_last");
|
|
if (last != null) {
|
|
lastNameField.setText(last);
|
|
}
|
|
}
|
|
|
|
private void hidePrivacyView() {
|
|
privacyView.animate().alpha(0f).setDuration(150).setStartDelay(0).setInterpolator(AndroidUtilities.accelerateInterpolator).start();
|
|
}
|
|
}
|
|
|
|
private boolean showKeyboard(View editText) {
|
|
if (!isCustomKeyboardVisible()) {
|
|
return AndroidUtilities.showKeyboard(editText);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public LoginActivity setIntroView(View intro, TextView startButton) {
|
|
introView = intro;
|
|
startMessagingButton = startButton;
|
|
isAnimatingIntro = true;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
protected AnimatorSet onCustomTransitionAnimation(boolean isOpen, Runnable callback) {
|
|
if (isOpen && introView != null) {
|
|
TransformableLoginButtonView transformButton = new TransformableLoginButtonView(fragmentView.getContext());
|
|
transformButton.setButtonText(startMessagingButton.getPaint(), startMessagingButton.getText().toString());
|
|
|
|
int oldTransformWidth = startMessagingButton.getWidth(), oldTransformHeight = startMessagingButton.getHeight();
|
|
int newTransformSize = floatingButtonIcon.getLayoutParams().width;
|
|
ViewGroup.MarginLayoutParams transformParams = new FrameLayout.LayoutParams(oldTransformWidth, oldTransformHeight);
|
|
transformButton.setLayoutParams(transformParams);
|
|
|
|
int[] loc = new int[2];
|
|
fragmentView.getLocationInWindow(loc);
|
|
int fragmentX = loc[0], fragmentY = loc[1];
|
|
|
|
startMessagingButton.getLocationInWindow(loc);
|
|
float fromX = loc[0] - fragmentX, fromY = loc[1] - fragmentY;
|
|
transformButton.setTranslationX(fromX);
|
|
transformButton.setTranslationY(fromY);
|
|
|
|
int toX = getParentLayout().getWidth() - floatingButtonIcon.getLayoutParams().width - ((ViewGroup.MarginLayoutParams)floatingButtonContainer.getLayoutParams()).rightMargin - getParentLayout().getPaddingLeft() - getParentLayout().getPaddingRight(),
|
|
toY = getParentLayout().getHeight() - floatingButtonIcon.getLayoutParams().height - ((ViewGroup.MarginLayoutParams)floatingButtonContainer.getLayoutParams()).bottomMargin -
|
|
(isCustomKeyboardVisible() ? AndroidUtilities.dp(CustomPhoneKeyboardView.KEYBOARD_HEIGHT_DP) : 0) - getParentLayout().getPaddingTop() - getParentLayout().getPaddingBottom();
|
|
|
|
ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
|
|
animator.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationStart(Animator animation) {
|
|
floatingButtonContainer.setVisibility(View.INVISIBLE);
|
|
keyboardLinearLayout.setAlpha(0);
|
|
fragmentView.setBackgroundColor(Color.TRANSPARENT);
|
|
startMessagingButton.setVisibility(View.INVISIBLE);
|
|
|
|
FrameLayout frameLayout = (FrameLayout) fragmentView;
|
|
frameLayout.addView(transformButton);
|
|
}
|
|
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
keyboardLinearLayout.setAlpha(1);
|
|
startMessagingButton.setVisibility(View.VISIBLE);
|
|
fragmentView.setBackgroundColor(Theme.getColor(Theme.key_windowBackgroundWhite));
|
|
floatingButtonContainer.setVisibility(View.VISIBLE);
|
|
|
|
FrameLayout frameLayout = (FrameLayout) fragmentView;
|
|
frameLayout.removeView(transformButton);
|
|
|
|
if (animationFinishCallback != null) {
|
|
AndroidUtilities.runOnUIThread(animationFinishCallback);
|
|
animationFinishCallback = null;
|
|
}
|
|
isAnimatingIntro = false;
|
|
|
|
callback.run();
|
|
}
|
|
});
|
|
int bgColor = Theme.getColor(Theme.key_windowBackgroundWhite);
|
|
int initialAlpha = Color.alpha(bgColor);
|
|
animator.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
keyboardLinearLayout.setAlpha(val);
|
|
fragmentView.setBackgroundColor(ColorUtils.setAlphaComponent(bgColor, (int) (initialAlpha * val)));
|
|
|
|
float inverted = 1f - val;
|
|
slideViewsContainer.setTranslationY(AndroidUtilities.dp(20) * inverted);
|
|
if (!isCustomKeyboardForceDisabled()) {
|
|
keyboardView.setTranslationY(keyboardView.getLayoutParams().height * inverted);
|
|
floatingButtonContainer.setTranslationY(keyboardView.getLayoutParams().height * inverted);
|
|
}
|
|
|
|
introView.setTranslationY(-AndroidUtilities.dp(20) * val);
|
|
float sc = 0.95f + 0.05f * inverted;
|
|
introView.setScaleX(sc);
|
|
introView.setScaleY(sc);
|
|
|
|
transformParams.width = (int) (oldTransformWidth + (newTransformSize - oldTransformWidth) * val);
|
|
transformParams.height = (int) (oldTransformHeight + (newTransformSize - oldTransformHeight) * val);
|
|
transformButton.requestLayout();
|
|
|
|
transformButton.setProgress(val);
|
|
transformButton.setTranslationX(fromX + (toX - fromX) * val);
|
|
transformButton.setTranslationY(fromY + (toY - fromY) * val);
|
|
});
|
|
animator.setInterpolator(CubicBezierInterpolator.DEFAULT);
|
|
|
|
AnimatorSet set = new AnimatorSet();
|
|
set.setDuration(300);
|
|
set.playTogether(animator);
|
|
set.start();
|
|
return set;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void updateColors() {
|
|
Context context = getParentActivity();
|
|
Drawable drawable = Theme.createSimpleSelectorCircleDrawable(AndroidUtilities.dp(56), Theme.getColor(Theme.key_chats_actionBackground), Theme.getColor(Theme.key_chats_actionPressedBackground));
|
|
if (Build.VERSION.SDK_INT < 21) {
|
|
Drawable shadowDrawable = context.getResources().getDrawable(R.drawable.floating_shadow).mutate();
|
|
shadowDrawable.setColorFilter(new PorterDuffColorFilter(0xff000000, PorterDuff.Mode.MULTIPLY));
|
|
CombinedDrawable combinedDrawable = new CombinedDrawable(shadowDrawable, drawable, 0, 0);
|
|
combinedDrawable.setIconSize(AndroidUtilities.dp(56), AndroidUtilities.dp(56));
|
|
drawable = combinedDrawable;
|
|
}
|
|
floatingButtonContainer.setBackground(drawable);
|
|
|
|
backButtonView.setColorFilter(Theme.getColor(Theme.key_windowBackgroundWhiteBlackText));
|
|
backButtonView.setBackground(Theme.createSelectorDrawable(Theme.getColor(Theme.key_listSelector)));
|
|
|
|
radialProgressView.setProgressColor(Theme.getColor(Theme.key_chats_actionBackground));
|
|
|
|
floatingButtonIcon.setColor(Theme.getColor(Theme.key_chats_actionIcon));
|
|
floatingButtonIcon.setBackgroundColor(Theme.getColor(Theme.key_chats_actionBackground));
|
|
|
|
floatingProgressView.setProgressColor(Theme.getColor(Theme.key_chats_actionIcon));
|
|
|
|
for (SlideView slideView : views) {
|
|
slideView.updateColors();
|
|
}
|
|
|
|
keyboardView.updateColors();
|
|
if (phoneNumberConfirmView != null) {
|
|
phoneNumberConfirmView.updateColors();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ArrayList<ThemeDescription> getThemeDescriptions() {
|
|
return SimpleThemeDescription.createThemeDescriptions(this::updateColors, Theme.key_windowBackgroundWhiteBlackText, Theme.key_windowBackgroundWhiteGrayText6,
|
|
Theme.key_windowBackgroundWhiteHintText, Theme.key_listSelector, Theme.key_chats_actionBackground, Theme.key_chats_actionIcon,
|
|
Theme.key_windowBackgroundWhiteInputField, Theme.key_windowBackgroundWhiteInputFieldActivated, Theme.key_windowBackgroundWhiteValueText,
|
|
Theme.key_dialogTextRed, Theme.key_windowBackgroundWhiteGrayText, Theme.key_checkbox, Theme.key_windowBackgroundWhiteBlueText4,
|
|
Theme.key_changephoneinfo_image2, Theme.key_chats_actionPressedBackground, Theme.key_windowBackgroundWhiteRedText2, Theme.key_windowBackgroundWhiteLinkText,
|
|
Theme.key_checkboxSquareUnchecked, Theme.key_checkboxSquareBackground, Theme.key_checkboxSquareCheck, Theme.key_dialogBackground, Theme.key_dialogTextGray2,
|
|
Theme.key_dialogTextBlack);
|
|
}
|
|
|
|
private void tryResetAccount(String requestPhone, String phoneHash, String phoneCode) {
|
|
if (radialProgressView.getTag() != null) {
|
|
return;
|
|
}
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(getParentActivity());
|
|
builder.setMessage(LocaleController.getString("ResetMyAccountWarningText", R.string.ResetMyAccountWarningText));
|
|
builder.setTitle(LocaleController.getString("ResetMyAccountWarning", R.string.ResetMyAccountWarning));
|
|
builder.setPositiveButton(LocaleController.getString("ResetMyAccountWarningReset", R.string.ResetMyAccountWarningReset), (dialogInterface, i) -> {
|
|
needShowProgress(0);
|
|
TLRPC.TL_account_deleteAccount req = new TLRPC.TL_account_deleteAccount();
|
|
req.reason = "Forgot password";
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
needHideProgress(false);
|
|
if (error == null) {
|
|
if (requestPhone == null || phoneHash == null || phoneCode == null) {
|
|
setPage(VIEW_PHONE_INPUT, true, null, true);
|
|
return;
|
|
}
|
|
Bundle params = new Bundle();
|
|
params.putString("phoneFormated", requestPhone);
|
|
params.putString("phoneHash", phoneHash);
|
|
params.putString("code", phoneCode);
|
|
setPage(VIEW_REGISTER, true, params, false);
|
|
} else {
|
|
if (error.text.equals("2FA_RECENT_CONFIRM")) {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), LocaleController.getString("ResetAccountCancelledAlert", R.string.ResetAccountCancelledAlert));
|
|
} else if (error.text.startsWith("2FA_CONFIRM_WAIT_")) {
|
|
Bundle params = new Bundle();
|
|
params.putString("phoneFormated", requestPhone);
|
|
params.putString("phoneHash", phoneHash);
|
|
params.putString("code", phoneCode);
|
|
params.putInt("startTime", ConnectionsManager.getInstance(currentAccount).getCurrentTime());
|
|
params.putInt("waitTime", Utilities.parseInt(error.text.replace("2FA_CONFIRM_WAIT_", "")));
|
|
setPage(VIEW_RESET_WAIT, true, params, false);
|
|
} else {
|
|
needShowAlert(LocaleController.getString(R.string.RestorePasswordNoEmailTitle), error.text);
|
|
}
|
|
}
|
|
}), ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagFailOnServerErrors);
|
|
});
|
|
builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
|
|
showDialog(builder.create());
|
|
}
|
|
|
|
private final static class PhoneNumberConfirmView extends FrameLayout {
|
|
private IConfirmDialogCallback callback;
|
|
private ViewGroup fragmentView;
|
|
private View fabContainer;
|
|
|
|
private View blurredView;
|
|
private View dimmView;
|
|
private TransformableLoginButtonView fabTransform;
|
|
private RadialProgressView floatingProgressView;
|
|
private FrameLayout popupFabContainer;
|
|
|
|
private TextView confirmMessageView;
|
|
private TextView numberView;
|
|
private TextView editTextView;
|
|
private TextView confirmTextView;
|
|
|
|
private FrameLayout popupLayout;
|
|
|
|
private boolean dismissed;
|
|
|
|
private PhoneNumberConfirmView(@NonNull Context context, ViewGroup fragmentView, View fabContainer, String numberText, IConfirmDialogCallback callback) {
|
|
super(context);
|
|
|
|
this.fragmentView = fragmentView;
|
|
this.fabContainer = fabContainer;
|
|
this.callback = callback;
|
|
|
|
blurredView = new View(getContext());
|
|
blurredView.setOnClickListener(v -> dismiss());
|
|
addView(blurredView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
dimmView = new View(getContext());
|
|
dimmView.setBackgroundColor(0x40000000);
|
|
dimmView.setAlpha(0);
|
|
addView(dimmView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
fabTransform = new TransformableLoginButtonView(getContext());
|
|
fabTransform.setTransformType(TransformableLoginButtonView.TRANSFORM_ARROW_CHECK);
|
|
fabTransform.setDrawBackground(false);
|
|
|
|
popupFabContainer = new FrameLayout(context);
|
|
popupFabContainer.addView(fabTransform, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
popupFabContainer.setOnClickListener(v -> callback.onFabPressed(this, fabTransform));
|
|
|
|
floatingProgressView = new RadialProgressView(context);
|
|
floatingProgressView.setSize(AndroidUtilities.dp(22));
|
|
floatingProgressView.setAlpha(0.0f);
|
|
floatingProgressView.setScaleX(0.1f);
|
|
floatingProgressView.setScaleY(0.1f);
|
|
popupFabContainer.addView(floatingProgressView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
|
|
|
|
popupFabContainer.setContentDescription(LocaleController.getString(R.string.Done));
|
|
addView(popupFabContainer, LayoutHelper.createFrame(Build.VERSION.SDK_INT >= 21 ? 56 : 60, Build.VERSION.SDK_INT >= 21 ? 56 : 60));
|
|
|
|
popupLayout = new FrameLayout(context);
|
|
|
|
addView(popupLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, 140, Gravity.TOP | Gravity.CENTER_HORIZONTAL, 24, 0, 24, 0));
|
|
|
|
confirmMessageView = new TextView(context);
|
|
confirmMessageView.setText(LocaleController.getString(R.string.ConfirmCorrectNumber));
|
|
confirmMessageView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 14);
|
|
confirmMessageView.setSingleLine();
|
|
popupLayout.addView(confirmMessageView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT, 24, 20, 24, 0));
|
|
|
|
numberView = new TextView(context);
|
|
numberView.setText(numberText);
|
|
numberView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
numberView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
|
|
numberView.setSingleLine();
|
|
popupLayout.addView(numberView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.WRAP_CONTENT, LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT, 24, 48, 24, 0));
|
|
|
|
int buttonPadding = AndroidUtilities.dp(16);
|
|
int buttonMargin = 8;
|
|
|
|
editTextView = new TextView(context);
|
|
editTextView.setText(LocaleController.getString(R.string.Edit));
|
|
editTextView.setSingleLine();
|
|
editTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
editTextView.setBackground(Theme.getRoundRectSelectorDrawable(AndroidUtilities.dp(6), Theme.getColor(Theme.key_changephoneinfo_image2)));
|
|
editTextView.setOnClickListener(v -> callback.onEditPressed(this, editTextView));
|
|
editTextView.setTypeface(Typeface.DEFAULT_BOLD);
|
|
editTextView.setPadding(buttonPadding, buttonPadding / 2, buttonPadding, buttonPadding / 2);
|
|
popupLayout.addView(editTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.BOTTOM | (LocaleController.isRTL ? Gravity.RIGHT : Gravity.LEFT), buttonMargin, buttonMargin, buttonMargin, buttonMargin));
|
|
|
|
confirmTextView = new TextView(context);
|
|
confirmTextView.setText(LocaleController.getString(R.string.CheckPhoneNumberYes));
|
|
confirmTextView.setSingleLine();
|
|
confirmTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16);
|
|
confirmTextView.setBackground(Theme.getRoundRectSelectorDrawable(AndroidUtilities.dp(6), Theme.getColor(Theme.key_changephoneinfo_image2)));
|
|
confirmTextView.setOnClickListener(v -> callback.onConfirmPressed(this, confirmTextView));
|
|
confirmTextView.setTypeface(Typeface.DEFAULT_BOLD);
|
|
confirmTextView.setPadding(buttonPadding, buttonPadding / 2, buttonPadding, buttonPadding / 2);
|
|
popupLayout.addView(confirmTextView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, LayoutHelper.WRAP_CONTENT, Gravity.BOTTOM | (LocaleController.isRTL ? Gravity.LEFT : Gravity.RIGHT), buttonMargin, buttonMargin, buttonMargin, buttonMargin));
|
|
|
|
updateFabPosition();
|
|
updateColors();
|
|
}
|
|
|
|
private void updateFabPosition() {
|
|
int[] loc = new int[2];
|
|
fragmentView.getLocationInWindow(loc);
|
|
int fragmentX = loc[0], fragmentY = loc[1];
|
|
|
|
fabContainer.getLocationInWindow(loc);
|
|
popupFabContainer.setTranslationX(loc[0] - fragmentX);
|
|
popupFabContainer.setTranslationY(loc[1] - fragmentY);
|
|
requestLayout();
|
|
}
|
|
|
|
private void updateColors() {
|
|
fabTransform.setColor(Theme.getColor(Theme.key_chats_actionIcon));
|
|
fabTransform.setBackgroundColor(Theme.getColor(Theme.key_chats_actionBackground));
|
|
popupLayout.setBackground(Theme.createRoundRectDrawable(AndroidUtilities.dp(12), Theme.getColor(Theme.key_dialogBackground)));
|
|
confirmMessageView.setTextColor(Theme.getColor(Theme.key_dialogTextGray2));
|
|
numberView.setTextColor(Theme.getColor(Theme.key_dialogTextBlack));
|
|
editTextView.setTextColor(Theme.getColor(Theme.key_changephoneinfo_image2));
|
|
confirmTextView.setTextColor(Theme.getColor(Theme.key_changephoneinfo_image2));
|
|
popupFabContainer.setBackground(Theme.createSimpleSelectorCircleDrawable(AndroidUtilities.dp(56), Theme.getColor(Theme.key_chats_actionBackground), Theme.getColor(Theme.key_chats_actionPressedBackground)));
|
|
floatingProgressView.setProgressColor(Theme.getColor(Theme.key_chats_actionIcon));
|
|
}
|
|
|
|
@Override
|
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
|
super.onLayout(changed, left, top, right, bottom);
|
|
|
|
int height = popupLayout.getMeasuredHeight();
|
|
int popupBottom = (int) (popupFabContainer.getTranslationY() - AndroidUtilities.dp(32));
|
|
popupLayout.layout(popupLayout.getLeft(), popupBottom - height, popupLayout.getRight(), popupBottom);
|
|
}
|
|
|
|
private void show() {
|
|
ValueAnimator anim = ValueAnimator.ofFloat(0, 1).setDuration(250);
|
|
anim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationStart(Animator animation) {
|
|
fabContainer.setVisibility(GONE);
|
|
|
|
// TODO: Generify this code, currently it's a clone
|
|
float scaleFactor = 10;
|
|
int w = (int) (fragmentView.getMeasuredWidth() / scaleFactor);
|
|
int h = (int) (fragmentView.getMeasuredHeight() / scaleFactor);
|
|
Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
|
|
Canvas canvas = new Canvas(bitmap);
|
|
canvas.scale(1.0f / scaleFactor, 1.0f / scaleFactor);
|
|
fragmentView.draw(canvas);
|
|
Utilities.stackBlurBitmap(bitmap, Math.max(8, Math.max(w, h) / 150));
|
|
blurredView.setBackground(new BitmapDrawable(getContext().getResources(), bitmap));
|
|
blurredView.setAlpha(0.0f);
|
|
blurredView.setVisibility(View.VISIBLE);
|
|
|
|
fragmentView.addView(PhoneNumberConfirmView.this);
|
|
}
|
|
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (AndroidUtilities.isAccessibilityTouchExplorationEnabled()) {
|
|
popupFabContainer.requestFocus();
|
|
}
|
|
}
|
|
});
|
|
anim.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
fabTransform.setProgress(val);
|
|
blurredView.setAlpha(val);
|
|
dimmView.setAlpha(val);
|
|
|
|
popupLayout.setAlpha(val);
|
|
float scale = 0.5f + val * 0.5f;
|
|
popupLayout.setScaleX(scale);
|
|
popupLayout.setScaleY(scale);
|
|
});
|
|
anim.setInterpolator(CubicBezierInterpolator.DEFAULT);
|
|
anim.start();
|
|
}
|
|
|
|
private void animateProgress(Runnable callback) {
|
|
ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
|
|
animator.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
callback.run();
|
|
}
|
|
});
|
|
animator.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
|
|
float scale = 0.1f + 0.9f * (1f - val);
|
|
fabTransform.setScaleX(scale);
|
|
fabTransform.setScaleY(scale);
|
|
fabTransform.setAlpha(1f - val);
|
|
|
|
scale = 0.1f + 0.9f * val;
|
|
floatingProgressView.setScaleX(scale);
|
|
floatingProgressView.setScaleY(scale);
|
|
floatingProgressView.setAlpha(val);
|
|
});
|
|
animator.setDuration(150);
|
|
animator.start();
|
|
}
|
|
|
|
private void dismiss() {
|
|
if (dismissed) return;
|
|
dismissed = true;
|
|
|
|
callback.onDismiss(this);
|
|
|
|
ValueAnimator anim = ValueAnimator.ofFloat(1, 0).setDuration(250);
|
|
anim.addListener(new AnimatorListenerAdapter() {
|
|
@Override
|
|
public void onAnimationEnd(Animator animation) {
|
|
if (getParent() instanceof ViewGroup) {
|
|
((ViewGroup) getParent()).removeView(PhoneNumberConfirmView.this);
|
|
}
|
|
fabContainer.setVisibility(VISIBLE);
|
|
}
|
|
});
|
|
anim.addUpdateListener(animation -> {
|
|
float val = (float) animation.getAnimatedValue();
|
|
blurredView.setAlpha(val);
|
|
dimmView.setAlpha(val);
|
|
fabTransform.setProgress(val);
|
|
popupLayout.setAlpha(val);
|
|
|
|
float scale = 0.5f + val * 0.5f;
|
|
popupLayout.setScaleX(scale);
|
|
popupLayout.setScaleY(scale);
|
|
});
|
|
anim.setInterpolator(CubicBezierInterpolator.DEFAULT);
|
|
anim.start();
|
|
}
|
|
|
|
private interface IConfirmDialogCallback {
|
|
void onFabPressed(PhoneNumberConfirmView confirmView, TransformableLoginButtonView fab);
|
|
void onEditPressed(PhoneNumberConfirmView confirmView, TextView editTextView);
|
|
void onConfirmPressed(PhoneNumberConfirmView confirmView, TextView confirmTextView);
|
|
void onDismiss(PhoneNumberConfirmView confirmView);
|
|
}
|
|
}
|
|
|
|
private interface PhoneNumberExclusionRule {
|
|
int modifyHintLengthRequirement(int lengthFrom);
|
|
}
|
|
|
|
@Override
|
|
public boolean isLightStatusBar() {
|
|
int color = Theme.getColor(Theme.key_windowBackgroundWhite, null, true);
|
|
return ColorUtils.calculateLuminance(color) > 0.7f;
|
|
}
|
|
|
|
|
|
// NekoX Changes
|
|
|
|
@Override
|
|
public void didReceivedNotification(int id, int account, Object... args) {
|
|
if (id == NotificationCenter.updateLoginToken) {
|
|
regenerateLoginToken(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onFragmentCreate() {
|
|
SharedConfig.loginingAccount = currentAccount;
|
|
ApplicationLoader.loadAccount(currentAccount);
|
|
return true;
|
|
}
|
|
|
|
private void fillNextCodeParamsSilent(Bundle params, TLRPC.TL_auth_sentCode res) {
|
|
params.putString("phoneHash", res.phone_code_hash);
|
|
if (res.next_type instanceof TLRPC.TL_auth_codeTypeCall) {
|
|
params.putInt("nextType", 4);
|
|
} else if (res.next_type instanceof TLRPC.TL_auth_codeTypeFlashCall) {
|
|
params.putInt("nextType", 3);
|
|
} else if (res.next_type instanceof TLRPC.TL_auth_codeTypeSms) {
|
|
params.putInt("nextType", 2);
|
|
}
|
|
if (res.type instanceof TLRPC.TL_auth_sentCodeTypeApp) {
|
|
params.putInt("type", 1);
|
|
params.putInt("length", res.type.length);
|
|
} else {
|
|
if (res.timeout == 0) {
|
|
res.timeout = 60;
|
|
}
|
|
params.putInt("timeout", res.timeout * 1000);
|
|
if (res.type instanceof TLRPC.TL_auth_sentCodeTypeCall) {
|
|
params.putInt("type", 4);
|
|
params.putInt("length", res.type.length);
|
|
} else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeFlashCall) {
|
|
params.putInt("type", 3);
|
|
params.putString("pattern", res.type.pattern);
|
|
} else if (res.type instanceof TLRPC.TL_auth_sentCodeTypeSms) {
|
|
params.putInt("type", 2);
|
|
params.putInt("length", res.type.length);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void doBotLogin(Context context) {
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(context);
|
|
builder.setTitle(LocaleController.getString("BotLogin", R.string.BotLogin));
|
|
|
|
final EditTextBoldCursor editText = new EditTextBoldCursor(context) {
|
|
@Override
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(64), MeasureSpec.EXACTLY));
|
|
}
|
|
};
|
|
editText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 18);
|
|
editText.setTextColor(Theme.getColor(Theme.key_dialogTextBlack));
|
|
editText.setHintText(LocaleController.getString("BotToken", R.string.BotToken));
|
|
editText.setHeaderHintColor(Theme.getColor(Theme.key_windowBackgroundWhiteBlueHeader));
|
|
editText.setSingleLine(true);
|
|
editText.setFocusable(true);
|
|
editText.setTransformHintToHeader(true);
|
|
editText.setLineColors(Theme.getColor(Theme.key_windowBackgroundWhiteInputField), Theme.getColor(Theme.key_windowBackgroundWhiteInputFieldActivated), Theme.getColor(Theme.key_windowBackgroundWhiteRedText3));
|
|
editText.setImeOptions(EditorInfo.IME_ACTION_DONE);
|
|
editText.setBackgroundDrawable(null);
|
|
editText.requestFocus();
|
|
editText.setPadding(0, 0, 0, 0);
|
|
ViewGroup.MarginLayoutParams layoutParams = (ViewGroup.MarginLayoutParams) editText.getLayoutParams();
|
|
if (layoutParams != null) {
|
|
if (layoutParams instanceof FrameLayout.LayoutParams) {
|
|
((FrameLayout.LayoutParams) layoutParams).gravity = Gravity.CENTER_HORIZONTAL;
|
|
}
|
|
layoutParams.rightMargin = layoutParams.leftMargin = AndroidUtilities.dp(24);
|
|
layoutParams.height = AndroidUtilities.dp(36);
|
|
editText.setLayoutParams(layoutParams);
|
|
}
|
|
builder.setView(editText);
|
|
|
|
builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), (dialogInterface, i) -> {
|
|
if (getParentActivity() == null) {
|
|
return;
|
|
}
|
|
String token = editText.getText().toString();
|
|
|
|
if (token.length() == 0) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("InvalidAccessToken", R.string.InvalidAccessToken));
|
|
return;
|
|
}
|
|
|
|
ConnectionsManager.getInstance(currentAccount).cleanup(false);
|
|
final TLRPC.TL_auth_importBotAuthorization req = new TLRPC.TL_auth_importBotAuthorization();
|
|
|
|
req.api_hash = NekoXConfig.currentAppHash();
|
|
req.api_id = NekoXConfig.currentAppId();
|
|
req.bot_auth_token = token;
|
|
req.flags = 0;
|
|
int reqId = ConnectionsManager.getInstance(currentAccount).sendRequest(req, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (error == null) {
|
|
TLRPC.TL_auth_authorization res = (TLRPC.TL_auth_authorization) response;
|
|
ConnectionsManager.getInstance(currentAccount).setUserId(res.user.id);
|
|
UserConfig.getInstance(currentAccount).clearConfig();
|
|
MessagesController.getInstance(currentAccount).cleanup();
|
|
UserConfig.getInstance(currentAccount).syncContacts = syncContacts;
|
|
UserConfig.getInstance(currentAccount).setCurrentUser(res.user);
|
|
UserConfig.getInstance(currentAccount).saveConfig(true);
|
|
MessagesStorage.getInstance(currentAccount).cleanup(true);
|
|
ArrayList<TLRPC.User> users = new ArrayList<>();
|
|
users.add(res.user);
|
|
MessagesStorage.getInstance(currentAccount).putUsersAndChats(users, null, true, true);
|
|
MessagesController.getInstance(currentAccount).putUser(res.user, false);
|
|
ConnectionsManager.getInstance(currentAccount).updateDcSettings();
|
|
needFinishActivity(false, res.setup_password_required, res.otherwise_relogin_days);
|
|
} else {
|
|
if (error.code == 401) {
|
|
ConnectionsManager.native_cleanUp(currentAccount, true);
|
|
}
|
|
if (error.text != null) {
|
|
if (error.text.contains("ACCESS_TOKEN_INVALID")) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("InvalidAccessToken", R.string.InvalidAccessToken));
|
|
} else if (error.text.startsWith("FLOOD_WAIT")) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), LocaleController.getString("FloodWait", R.string.FloodWait));
|
|
} else if (error.code != -1000) {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), error.code + ": " + error.text);
|
|
}
|
|
}
|
|
}
|
|
needHideProgress(false);
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagTryDifferentDc | ConnectionsManager.RequestFlagEnableUnauthorized);
|
|
needShowProgress(reqId);
|
|
});
|
|
builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), null);
|
|
builder.show().setOnShowListener(dialog -> {
|
|
editText.requestFocus();
|
|
AndroidUtilities.showKeyboard(editText);
|
|
});
|
|
|
|
}
|
|
|
|
private void regenerateLoginToken(Boolean refresh) {
|
|
getNotificationCenter().removeObserver(this, NotificationCenter.updateLoginToken);
|
|
if (getParentActivity() == null || isFinished) return;
|
|
if (exportLoginTokenDialog != null && exportLoginTokenDialog.isShowing()) {
|
|
exportLoginTokenDialog.dismiss();
|
|
} else if (refresh) return;
|
|
exportLoginTokenProgress = new AlertDialog(getParentActivity(), 3);
|
|
exportLoginTokenProgress.setCanCancel(false);
|
|
exportLoginTokenProgress.show();
|
|
if (exportLoginTokenRequest == null) {
|
|
exportLoginTokenRequest = new TLRPC.TL_auth_exportLoginToken();
|
|
exportLoginTokenRequest.api_id = NekoXConfig.currentAppId();
|
|
exportLoginTokenRequest.api_hash = NekoXConfig.currentAppHash();
|
|
exportLoginTokenRequest.except_ids = new ArrayList<>();
|
|
for (int a : SharedConfig.activeAccounts) {
|
|
UserConfig userConfig = UserConfig.getInstance(a);
|
|
if (!userConfig.isClientActivated()) {
|
|
continue;
|
|
}
|
|
exportLoginTokenRequest.except_ids.add(userConfig.clientUserId);
|
|
}
|
|
}
|
|
getNotificationCenter().addObserver(this, NotificationCenter.updateLoginToken);
|
|
getConnectionsManager().sendRequest(exportLoginTokenRequest, (response, error) -> AndroidUtilities.runOnUIThread(() -> {
|
|
if (getParentActivity() == null) return;
|
|
try {
|
|
exportLoginTokenProgress.dismiss();
|
|
} catch (Exception ignore) {
|
|
}
|
|
if (response instanceof TLRPC.TL_auth_loginToken) {
|
|
exportLoginTokenDialog = ProxyUtil.showQrDialog(getParentActivity(), "tg://login?token=" + cn.hutool.core.codec.Base64.encodeUrlSafe(((TLRPC.TL_auth_loginToken) response).token));
|
|
int delay = (int) (((TLRPC.TL_auth_loginToken) response).expires - System.currentTimeMillis() / 1000);
|
|
if (delay < 0 || delay > 20) delay = 20;
|
|
if (BuildVars.DEBUG_VERSION) {
|
|
AlertUtil.showToast("Refresh after " + delay + "s");
|
|
}
|
|
AndroidUtilities.runOnUIThread(() -> regenerateLoginToken(true), delay * 1000L);
|
|
} else if (response instanceof TLRPC.TL_auth_loginTokenMigrateTo) {
|
|
checkMigrateTo((TLRPC.TL_auth_loginTokenMigrateTo) response);
|
|
} else if (response instanceof TLRPC.TL_auth_loginTokenSuccess) {
|
|
processLoginByTokenFinish((TLRPC.TL_auth_loginTokenSuccess) response);
|
|
} else {
|
|
processError(error);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagTryDifferentDc | ConnectionsManager.RequestFlagEnableUnauthorized);
|
|
}
|
|
|
|
private void checkMigrateTo(TLRPC.TL_auth_loginTokenMigrateTo response) {
|
|
getNotificationCenter().removeObserver(this, NotificationCenter.updateLoginToken);
|
|
ConnectionsManager.native_moveToDatacenter(currentAccount, response.dc_id);
|
|
exportLoginTokenProgress.show();
|
|
TLRPC.TL_auth_importLoginToken request = new TLRPC.TL_auth_importLoginToken();
|
|
request.token = response.token;
|
|
getConnectionsManager().sendRequest(request, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
|
|
exportLoginTokenProgress.dismiss();
|
|
if (error1 != null) {
|
|
processError(error1);
|
|
} else if (response1 instanceof TLRPC.TL_auth_loginTokenSuccess) {
|
|
processLoginByTokenFinish((TLRPC.TL_auth_loginTokenSuccess) response1);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin | ConnectionsManager.RequestFlagTryDifferentDc | ConnectionsManager.RequestFlagEnableUnauthorized);
|
|
}
|
|
|
|
private void processError(TLRPC.TL_error error) {
|
|
if (error.text.contains("SESSION_PASSWORD_NEEDED")) {
|
|
exportLoginTokenProgress.show();
|
|
TLRPC.TL_account_getPassword req2 = new TLRPC.TL_account_getPassword();
|
|
ConnectionsManager.getInstance(currentAccount).sendRequest(req2, (response1, error1) -> AndroidUtilities.runOnUIThread(() -> {
|
|
exportLoginTokenProgress.dismiss();
|
|
showDoneButton(false, true);
|
|
if (error1 == null) {
|
|
TLRPC.TL_account_password password = (TLRPC.TL_account_password) response1;
|
|
if (!TwoStepVerificationActivity.canHandleCurrentPassword(password, true)) {
|
|
AlertsCreator.showUpdateAppAlert(getParentActivity(), LocaleController.getString("UpdateAppAlert", R.string.UpdateAppAlert), true);
|
|
return;
|
|
}
|
|
Bundle bundle = new Bundle();
|
|
SerializedData data = new SerializedData(password.getObjectSize());
|
|
password.serializeToStream(data);
|
|
bundle.putString("password", Utilities.bytesToHex(data.toByteArray()));
|
|
setPage(LoginActivity.VIEW_PASSWORD, true, bundle, false);
|
|
} else {
|
|
needShowAlert(LocaleController.getString("NekoX", R.string.NekoX), error1.text);
|
|
}
|
|
}), ConnectionsManager.RequestFlagFailOnServerErrors | ConnectionsManager.RequestFlagWithoutLogin);
|
|
} else {
|
|
AlertUtil.showToast(error);
|
|
exportLoginTokenRequest = null;
|
|
if (!error.text.contains("CONNECTION_NOT_INITED"))
|
|
regenerateLoginToken(false);
|
|
}
|
|
}
|
|
|
|
private void processLoginByTokenFinish(TLRPC.TL_auth_loginTokenSuccess authLoginTokenSuccess) {
|
|
getNotificationCenter().removeObserver(this, NotificationCenter.updateLoginToken);
|
|
TLRPC.auth_Authorization authorization = authLoginTokenSuccess.authorization;
|
|
if (authorization instanceof TLRPC.TL_auth_authorizationSignUpRequired) {
|
|
TLRPC.TL_auth_authorizationSignUpRequired authorizationI = (TLRPC.TL_auth_authorizationSignUpRequired) authorization;
|
|
if (authorizationI.terms_of_service != null) {
|
|
currentTermsOfService = authorizationI.terms_of_service;
|
|
}
|
|
setPage(VIEW_REGISTER, true, new Bundle(), false);
|
|
} else {
|
|
onAuthSuccess((TLRPC.TL_auth_authorization) authorization);
|
|
}
|
|
}
|
|
|
|
}
|