CrackMe.apk
Download file
package com.facebook.react.views.textinput;
import android.content.Context;
import android.content.res.ColorStateList;
import android.graphics.BlendMode;
import android.graphics.BlendModeColorFilter;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.text.Editable;
import android.text.InputFilter;
import android.text.SpannableStringBuilder;
import android.text.TextWatcher;
import android.view.KeyEvent;
import android.view.View;
import android.widget.TextView;
import androidx.autofill.HintConstants;
import androidx.core.content.ContextCompat;
import androidx.core.view.ViewCompat;
import com.facebook.common.logging.FLog;
import com.facebook.infer.annotation.Assertions;
import com.facebook.react.bridge.Dynamic;
import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.bridge.ReactSoftExceptionLogger;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableNativeMap;
import com.facebook.react.bridge.ReadableType;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableNativeMap;
import com.facebook.react.common.MapBuilder;
import com.facebook.react.module.annotations.ReactModule;
import com.facebook.react.uimanager.BaseViewManager;
import com.facebook.react.uimanager.FabricViewStateManager;
import com.facebook.react.uimanager.LayoutShadowNode;
import com.facebook.react.uimanager.PixelUtil;
import com.facebook.react.uimanager.ReactStylesDiffMap;
import com.facebook.react.uimanager.StateWrapper;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.UIManagerHelper;
import com.facebook.react.uimanager.ViewProps;
import com.facebook.react.uimanager.annotations.ReactProp;
import com.facebook.react.uimanager.annotations.ReactPropGroup;
import com.facebook.react.uimanager.events.EventDispatcher;
import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
import com.facebook.react.views.scroll.ScrollEvent;
import com.facebook.react.views.scroll.ScrollEventType;
import com.facebook.react.views.text.DefaultStyleValuesUtil;
import com.facebook.react.views.text.ReactBaseTextShadowNode;
import com.facebook.react.views.text.ReactTextUpdate;
import com.facebook.react.views.text.ReactTextViewManagerCallback;
import com.facebook.react.views.text.TextAttributeProps;
import com.facebook.react.views.text.TextInlineImageSpan;
import com.facebook.react.views.text.TextLayoutManager;
import com.facebook.react.views.text.TextTransform;
import com.facebook.yoga.YogaConstants;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import kotlinx.coroutines.DebugKt;
@ReactModule(name = "AndroidTextInput")
public class ReactTextInputManager extends BaseViewManager<ReactEditText, LayoutShadowNode> {
private static final int AUTOCAPITALIZE_FLAGS = 28672;
private static final int BLUR_TEXT_INPUT = 2;
private static final String[] DRAWABLE_FIELDS = {"mCursorDrawable", "mSelectHandleLeft", "mSelectHandleRight", "mSelectHandleCenter"};
private static final String[] DRAWABLE_RESOURCES = {"mCursorDrawableRes", "mTextSelectHandleLeftRes", "mTextSelectHandleRightRes", "mTextSelectHandleRes"};
private static final InputFilter[] EMPTY_FILTERS = new InputFilter[0];
private static final int FOCUS_TEXT_INPUT = 1;
private static final int IME_ACTION_ID = 1648;
private static final int INPUT_TYPE_KEYBOARD_DECIMAL_PAD = 8194;
private static final int INPUT_TYPE_KEYBOARD_NUMBERED = 12290;
private static final int INPUT_TYPE_KEYBOARD_NUMBER_PAD = 2;
private static final String KEYBOARD_TYPE_DECIMAL_PAD = "decimal-pad";
private static final String KEYBOARD_TYPE_EMAIL_ADDRESS = "email-address";
private static final String KEYBOARD_TYPE_NUMBER_PAD = "number-pad";
private static final String KEYBOARD_TYPE_NUMERIC = "numeric";
private static final String KEYBOARD_TYPE_PHONE_PAD = "phone-pad";
private static final String KEYBOARD_TYPE_URI = "url";
private static final String KEYBOARD_TYPE_VISIBLE_PASSWORD = "visible-password";
private static final int PASSWORD_VISIBILITY_FLAG = 16;
public static final String REACT_CLASS = "AndroidTextInput";
private static final Map<String, String> REACT_PROPS_AUTOFILL_HINTS_MAP = new HashMap<String, String>() {
{
put("birthdate-day", HintConstants.AUTOFILL_HINT_BIRTH_DATE_DAY);
put("birthdate-full", HintConstants.AUTOFILL_HINT_BIRTH_DATE_FULL);
put("birthdate-month", HintConstants.AUTOFILL_HINT_BIRTH_DATE_MONTH);
put("birthdate-year", HintConstants.AUTOFILL_HINT_BIRTH_DATE_YEAR);
put("cc-csc", HintConstants.AUTOFILL_HINT_CREDIT_CARD_SECURITY_CODE);
put("cc-exp", HintConstants.AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DATE);
put("cc-exp-day", HintConstants.AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DAY);
put("cc-exp-month", HintConstants.AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_MONTH);
put("cc-exp-year", HintConstants.AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_YEAR);
put("cc-number", HintConstants.AUTOFILL_HINT_CREDIT_CARD_NUMBER);
put("email", HintConstants.AUTOFILL_HINT_EMAIL_ADDRESS);
put(HintConstants.AUTOFILL_HINT_GENDER, HintConstants.AUTOFILL_HINT_GENDER);
put(HintConstants.AUTOFILL_HINT_NAME, HintConstants.AUTOFILL_HINT_PERSON_NAME);
put("name-family", HintConstants.AUTOFILL_HINT_PERSON_NAME_FAMILY);
put("name-given", HintConstants.AUTOFILL_HINT_PERSON_NAME_GIVEN);
put("name-middle", HintConstants.AUTOFILL_HINT_PERSON_NAME_MIDDLE);
put("name-middle-initial", HintConstants.AUTOFILL_HINT_PERSON_NAME_MIDDLE_INITIAL);
put("name-prefix", HintConstants.AUTOFILL_HINT_PERSON_NAME_PREFIX);
put("name-suffix", HintConstants.AUTOFILL_HINT_PERSON_NAME_SUFFIX);
put("password", "password");
put("password-new", HintConstants.AUTOFILL_HINT_NEW_PASSWORD);
put("postal-address", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS);
put("postal-address-country", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_COUNTRY);
put("postal-address-extended", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_ADDRESS);
put("postal-address-extended-postal-code", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_POSTAL_CODE);
put("postal-address-locality", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_LOCALITY);
put("postal-address-region", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_REGION);
put("postal-code", HintConstants.AUTOFILL_HINT_POSTAL_CODE);
put("street-address", HintConstants.AUTOFILL_HINT_POSTAL_ADDRESS_STREET_ADDRESS);
put("sms-otp", HintConstants.AUTOFILL_HINT_SMS_OTP);
put("tel", HintConstants.AUTOFILL_HINT_PHONE_NUMBER);
put("tel-country-code", HintConstants.AUTOFILL_HINT_PHONE_COUNTRY_CODE);
put("tel-national", HintConstants.AUTOFILL_HINT_PHONE_NATIONAL);
put("tel-device", HintConstants.AUTOFILL_HINT_PHONE_NUMBER_DEVICE);
put(HintConstants.AUTOFILL_HINT_USERNAME, HintConstants.AUTOFILL_HINT_USERNAME);
put("username-new", HintConstants.AUTOFILL_HINT_NEW_USERNAME);
}
};
private static final int SET_MOST_RECENT_EVENT_COUNT = 3;
private static final int SET_TEXT_AND_SELECTION = 4;
private static final int[] SPACING_TYPES = {8, 0, 2, 1, 3};
public static final String TAG = "ReactTextInputManager";
private static final int UNSET = -1;
protected ReactTextViewManagerCallback mReactTextViewManagerCallback;
public String getName() {
return REACT_CLASS;
}
public ReactEditText createViewInstance(ThemedReactContext themedReactContext) {
ReactEditText reactEditText = new ReactEditText(themedReactContext);
reactEditText.setInputType(reactEditText.getInputType() & -131073);
reactEditText.setReturnKeyType("done");
return reactEditText;
}
public ReactBaseTextShadowNode createShadowNodeInstance() {
return new ReactTextInputShadowNode();
}
public ReactBaseTextShadowNode createShadowNodeInstance(ReactTextViewManagerCallback reactTextViewManagerCallback) {
return new ReactTextInputShadowNode(reactTextViewManagerCallback);
}
public Class<? extends LayoutShadowNode> getShadowNodeClass() {
return ReactTextInputShadowNode.class;
}
public Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
Map<String, Object> exportedCustomBubblingEventTypeConstants = super.getExportedCustomBubblingEventTypeConstants();
if (exportedCustomBubblingEventTypeConstants == null) {
exportedCustomBubblingEventTypeConstants = new HashMap<>();
}
exportedCustomBubblingEventTypeConstants.putAll(MapBuilder.builder().put("topSubmitEditing", MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onSubmitEditing", "captured", "onSubmitEditingCapture"))).put("topEndEditing", MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onEndEditing", "captured", "onEndEditingCapture"))).put(ReactTextInputEvent.EVENT_NAME, MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onTextInput", "captured", "onTextInputCapture"))).put("topFocus", MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onFocus", "captured", "onFocusCapture"))).put("topBlur", MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onBlur", "captured", "onBlurCapture"))).put(ReactTextInputKeyPressEvent.EVENT_NAME, MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onKeyPress", "captured", "onKeyPressCapture"))).build());
return exportedCustomBubblingEventTypeConstants;
}
public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
Map<String, Object> exportedCustomDirectEventTypeConstants = super.getExportedCustomDirectEventTypeConstants();
if (exportedCustomDirectEventTypeConstants == null) {
exportedCustomDirectEventTypeConstants = new HashMap<>();
}
exportedCustomDirectEventTypeConstants.putAll(MapBuilder.builder().put(ScrollEventType.getJSEventName(ScrollEventType.SCROLL), MapBuilder.of("registrationName", "onScroll")).build());
return exportedCustomDirectEventTypeConstants;
}
public Map<String, Integer> getCommandsMap() {
return MapBuilder.of("focusTextInput", 1, "blurTextInput", 2);
}
public void receiveCommand(ReactEditText reactEditText, int i, ReadableArray readableArray) {
if (i == 1) {
receiveCommand(reactEditText, "focus", readableArray);
} else if (i == 2) {
receiveCommand(reactEditText, "blur", readableArray);
} else if (i == 4) {
receiveCommand(reactEditText, "setTextAndSelection", readableArray);
}
}
/* JADX WARNING: Can't fix incorrect switch cases order */
/* Code decompiled incorrectly, please refer to instructions dump. */
public void receiveCommand(com.facebook.react.views.textinput.ReactEditText r7, java.lang.String r8, com.facebook.react.bridge.ReadableArray r9) {
/*
r6 = this;
r8.hashCode()
int r0 = r8.hashCode()
r1 = 3
r2 = 2
r3 = 0
r4 = 1
r5 = -1
switch(r0) {
case -1699362314: goto L_0x003e;
case 3027047: goto L_0x0033;
case 97604824: goto L_0x0028;
case 1427010500: goto L_0x001c;
case 1690703013: goto L_0x0011;
default: goto L_0x000f;
}
L_0x000f:
r8 = -1
goto L_0x0048
L_0x0011:
java.lang.String r0 = "focusTextInput"
boolean r8 = r8.equals(r0)
if (r8 != 0) goto L_0x001a
goto L_0x000f
L_0x001a:
r8 = 4
goto L_0x0048
L_0x001c:
java.lang.String r0 = "setTextAndSelection"
boolean r8 = r8.equals(r0)
if (r8 != 0) goto L_0x0026
goto L_0x000f
L_0x0026:
r8 = 3
goto L_0x0048
L_0x0028:
java.lang.String r0 = "focus"
boolean r8 = r8.equals(r0)
if (r8 != 0) goto L_0x0031
goto L_0x000f
L_0x0031:
r8 = 2
goto L_0x0048
L_0x0033:
java.lang.String r0 = "blur"
boolean r8 = r8.equals(r0)
if (r8 != 0) goto L_0x003c
goto L_0x000f
L_0x003c:
r8 = 1
goto L_0x0048
L_0x003e:
java.lang.String r0 = "blurTextInput"
boolean r8 = r8.equals(r0)
if (r8 != 0) goto L_0x0047
goto L_0x000f
L_0x0047:
r8 = 0
L_0x0048:
switch(r8) {
case 0: goto L_0x0077;
case 1: goto L_0x0077;
case 2: goto L_0x0073;
case 3: goto L_0x004c;
case 4: goto L_0x0073;
default: goto L_0x004b;
}
L_0x004b:
goto L_0x007a
L_0x004c:
int r8 = r9.getInt(r3)
if (r8 != r5) goto L_0x0053
return
L_0x0053:
int r0 = r9.getInt(r2)
int r1 = r9.getInt(r1)
if (r1 != r5) goto L_0x005e
r1 = r0
L_0x005e:
boolean r2 = r9.isNull(r4)
if (r2 != 0) goto L_0x006f
java.lang.String r9 = r9.getString(r4)
com.facebook.react.views.text.ReactTextUpdate r9 = r6.getReactTextUpdate(r9, r8, r0, r1)
r7.maybeSetTextFromJS(r9)
L_0x006f:
r7.maybeSetSelection(r8, r0, r1)
goto L_0x007a
L_0x0073:
r7.requestFocusFromJS()
goto L_0x007a
L_0x0077:
r7.clearFocusFromJS()
L_0x007a:
return
*/
throw new UnsupportedOperationException("Method not decompiled: com.facebook.react.views.textinput.ReactTextInputManager.receiveCommand(com.facebook.react.views.textinput.ReactEditText, java.lang.String, com.facebook.react.bridge.ReadableArray):void");
}
private ReactTextUpdate getReactTextUpdate(String str, int i, int i2, int i3) {
SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
String str2 = str;
spannableStringBuilder.append(TextTransform.apply(str, TextTransform.UNSET));
return new ReactTextUpdate(spannableStringBuilder, i, false, 0.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, i2, i3);
}
public void updateExtraData(ReactEditText reactEditText, Object obj) {
if (obj instanceof ReactTextUpdate) {
ReactTextUpdate reactTextUpdate = (ReactTextUpdate) obj;
int paddingLeft = (int) reactTextUpdate.getPaddingLeft();
int paddingTop = (int) reactTextUpdate.getPaddingTop();
int paddingRight = (int) reactTextUpdate.getPaddingRight();
int paddingBottom = (int) reactTextUpdate.getPaddingBottom();
if (!(paddingLeft == -1 && paddingTop == -1 && paddingRight == -1 && paddingBottom == -1)) {
if (paddingLeft == -1) {
paddingLeft = reactEditText.getPaddingLeft();
}
if (paddingTop == -1) {
paddingTop = reactEditText.getPaddingTop();
}
if (paddingRight == -1) {
paddingRight = reactEditText.getPaddingRight();
}
if (paddingBottom == -1) {
paddingBottom = reactEditText.getPaddingBottom();
}
reactEditText.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom);
}
if (reactTextUpdate.containsImages()) {
TextInlineImageSpan.possiblyUpdateInlineImageSpans(reactTextUpdate.getText(), reactEditText);
}
int i = 0;
boolean z = reactEditText.getSelectionStart() == reactEditText.getSelectionEnd();
int selectionStart = reactTextUpdate.getSelectionStart();
int selectionEnd = reactTextUpdate.getSelectionEnd();
if ((selectionStart == -1 || selectionEnd == -1) && z) {
if (reactEditText.getText() != null) {
i = reactEditText.getText().length();
}
selectionStart = reactTextUpdate.getText().length() - (i - reactEditText.getSelectionStart());
selectionEnd = selectionStart;
}
reactEditText.maybeSetTextFromState(reactTextUpdate);
reactEditText.maybeSetSelection(reactTextUpdate.getJsEventCounter(), selectionStart, selectionEnd);
}
}
@ReactProp(defaultFloat = 14.0f, name = "fontSize")
public void setFontSize(ReactEditText reactEditText, float f) {
reactEditText.setFontSize(f);
}
@ReactProp(name = "fontFamily")
public void setFontFamily(ReactEditText reactEditText, String str) {
reactEditText.setFontFamily(str);
}
@ReactProp(defaultFloat = Float.NaN, name = "maxFontSizeMultiplier")
public void setMaxFontSizeMultiplier(ReactEditText reactEditText, float f) {
reactEditText.setMaxFontSizeMultiplier(f);
}
@ReactProp(name = "fontWeight")
public void setFontWeight(ReactEditText reactEditText, String str) {
reactEditText.setFontWeight(str);
}
@ReactProp(name = "fontStyle")
public void setFontStyle(ReactEditText reactEditText, String str) {
reactEditText.setFontStyle(str);
}
@ReactProp(defaultBoolean = true, name = "includeFontPadding")
public void setIncludeFontPadding(ReactEditText reactEditText, boolean z) {
reactEditText.setIncludeFontPadding(z);
}
@ReactProp(name = "importantForAutofill")
public void setImportantForAutofill(ReactEditText reactEditText, String str) {
int i;
if ("no".equals(str)) {
i = 2;
} else if ("noExcludeDescendants".equals(str)) {
i = 8;
} else if ("yes".equals(str)) {
i = 1;
} else {
i = "yesExcludeDescendants".equals(str) ? 4 : 0;
}
setImportantForAutofill(reactEditText, i);
}
private void setImportantForAutofill(ReactEditText reactEditText, int i) {
if (Build.VERSION.SDK_INT >= 26) {
reactEditText.setImportantForAutofill(i);
}
}
private void setAutofillHints(ReactEditText reactEditText, String... strArr) {
if (Build.VERSION.SDK_INT >= 26) {
reactEditText.setAutofillHints(strArr);
}
}
@ReactProp(defaultBoolean = false, name = "onSelectionChange")
public void setOnSelectionChange(ReactEditText reactEditText, boolean z) {
if (z) {
reactEditText.setSelectionWatcher(new ReactSelectionWatcher(reactEditText));
} else {
reactEditText.setSelectionWatcher((SelectionWatcher) null);
}
}
@ReactProp(name = "blurOnSubmit")
public void setBlurOnSubmit(ReactEditText reactEditText, Boolean bool) {
reactEditText.setBlurOnSubmit(bool);
}
@ReactProp(defaultBoolean = false, name = "onContentSizeChange")
public void setOnContentSizeChange(ReactEditText reactEditText, boolean z) {
if (z) {
reactEditText.setContentSizeWatcher(new ReactContentSizeWatcher(reactEditText));
} else {
reactEditText.setContentSizeWatcher((ContentSizeWatcher) null);
}
}
@ReactProp(defaultBoolean = false, name = "onScroll")
public void setOnScroll(ReactEditText reactEditText, boolean z) {
if (z) {
reactEditText.setScrollWatcher(new ReactScrollWatcher(reactEditText));
} else {
reactEditText.setScrollWatcher((ScrollWatcher) null);
}
}
@ReactProp(defaultBoolean = false, name = "onKeyPress")
public void setOnKeyPress(ReactEditText reactEditText, boolean z) {
reactEditText.setOnKeyPress(z);
}
@ReactProp(defaultFloat = 0.0f, name = "letterSpacing")
public void setLetterSpacing(ReactEditText reactEditText, float f) {
reactEditText.setLetterSpacingPt(f);
}
@ReactProp(defaultBoolean = true, name = "allowFontScaling")
public void setAllowFontScaling(ReactEditText reactEditText, boolean z) {
reactEditText.setAllowFontScaling(z);
}
@ReactProp(name = "placeholder")
public void setPlaceholder(ReactEditText reactEditText, String str) {
reactEditText.setHint(str);
}
@ReactProp(customType = "Color", name = "placeholderTextColor")
public void setPlaceholderTextColor(ReactEditText reactEditText, Integer num) {
if (num == null) {
reactEditText.setHintTextColor(DefaultStyleValuesUtil.getDefaultTextColorHint(reactEditText.getContext()));
} else {
reactEditText.setHintTextColor(num.intValue());
}
}
@ReactProp(customType = "Color", name = "selectionColor")
public void setSelectionColor(ReactEditText reactEditText, Integer num) {
if (num == null) {
reactEditText.setHighlightColor(DefaultStyleValuesUtil.getDefaultTextColorHighlight(reactEditText.getContext()));
} else {
reactEditText.setHighlightColor(num.intValue());
}
setCursorColor(reactEditText, num);
}
@ReactProp(customType = "Color", name = "cursorColor")
public void setCursorColor(ReactEditText reactEditText, Integer num) {
if (num != null) {
if (Build.VERSION.SDK_INT >= 29) {
Drawable textCursorDrawable = reactEditText.getTextCursorDrawable();
if (textCursorDrawable != null) {
textCursorDrawable.setColorFilter(new BlendModeColorFilter(num.intValue(), BlendMode.SRC_IN));
reactEditText.setTextCursorDrawable(textCursorDrawable);
}
} else if (Build.VERSION.SDK_INT != 28) {
int i = 0;
while (true) {
String[] strArr = DRAWABLE_RESOURCES;
if (i < strArr.length) {
try {
Field declaredField = TextView.class.getDeclaredField(strArr[i]);
declaredField.setAccessible(true);
int i2 = declaredField.getInt(reactEditText);
if (i2 != 0) {
Drawable mutate = ContextCompat.getDrawable(reactEditText.getContext(), i2).mutate();
mutate.setColorFilter(num.intValue(), PorterDuff.Mode.SRC_IN);
Field declaredField2 = TextView.class.getDeclaredField("mEditor");
declaredField2.setAccessible(true);
Object obj = declaredField2.get(reactEditText);
Field declaredField3 = obj.getClass().getDeclaredField(DRAWABLE_FIELDS[i]);
declaredField3.setAccessible(true);
if (strArr[i] == "mCursorDrawableRes") {
declaredField3.set(obj, new Drawable[]{mutate, mutate});
} else {
declaredField3.set(obj, mutate);
}
i++;
} else {
return;
}
} catch (IllegalAccessException | NoSuchFieldException unused) {
}
} else {
return;
}
}
}
}
}
private static boolean shouldHideCursorForEmailTextInput() {
return Build.VERSION.SDK_INT == 29 && Build.MANUFACTURER.toLowerCase(Locale.ROOT).contains("xiaomi");
}
@ReactProp(defaultBoolean = false, name = "caretHidden")
public void setCaretHidden(ReactEditText reactEditText, boolean z) {
if (reactEditText.getStagedInputType() != 32 || !shouldHideCursorForEmailTextInput()) {
reactEditText.setCursorVisible(!z);
}
}
@ReactProp(defaultBoolean = false, name = "contextMenuHidden")
public void setContextMenuHidden(ReactEditText reactEditText, final boolean z) {
reactEditText.setOnLongClickListener(new View.OnLongClickListener() {
public boolean onLongClick(View view) {
return z;
}
});
}
@ReactProp(defaultBoolean = false, name = "selectTextOnFocus")
public void setSelectTextOnFocus(ReactEditText reactEditText, boolean z) {
reactEditText.setSelectAllOnFocus(z);
}
@ReactProp(customType = "Color", name = "color")
public void setColor(ReactEditText reactEditText, Integer num) {
if (num == null) {
ColorStateList defaultTextColor = DefaultStyleValuesUtil.getDefaultTextColor(reactEditText.getContext());
if (defaultTextColor != null) {
reactEditText.setTextColor(defaultTextColor);
return;
}
Context context = reactEditText.getContext();
String str = TAG;
StringBuilder sb = new StringBuilder();
sb.append("Could not get default text color from View Context: ");
sb.append(context != null ? context.getClass().getCanonicalName() : "null");
ReactSoftExceptionLogger.logSoftException(str, new IllegalStateException(sb.toString()));
return;
}
reactEditText.setTextColor(num.intValue());
}
@ReactProp(customType = "Color", name = "underlineColorAndroid")
public void setUnderlineColor(ReactEditText reactEditText, Integer num) {
Drawable background = reactEditText.getBackground();
if (background.getConstantState() != null) {
try {
background = background.mutate();
} catch (NullPointerException e) {
FLog.e(TAG, "NullPointerException when setting underlineColorAndroid for TextInput", (Throwable) e);
}
}
if (num == null) {
background.clearColorFilter();
} else if (Build.VERSION.SDK_INT == 21) {
int borderColor = reactEditText.getBorderColor(3);
setBorderColor(reactEditText, 4, num);
background.setColorFilter(num.intValue(), PorterDuff.Mode.SRC_IN);
setBorderColor(reactEditText, 4, Integer.valueOf(borderColor));
} else {
background.setColorFilter(num.intValue(), PorterDuff.Mode.SRC_IN);
}
}
@ReactProp(name = "textAlign")
public void setTextAlign(ReactEditText reactEditText, String str) {
if ("justify".equals(str)) {
if (Build.VERSION.SDK_INT >= 26) {
reactEditText.setJustificationMode(1);
}
reactEditText.setGravityHorizontal(3);
return;
}
if (Build.VERSION.SDK_INT >= 26) {
reactEditText.setJustificationMode(0);
}
if (str == null || "auto".equals(str)) {
reactEditText.setGravityHorizontal(0);
} else if ("left".equals(str)) {
reactEditText.setGravityHorizontal(3);
} else if ("right".equals(str)) {
reactEditText.setGravityHorizontal(5);
} else if (TtmlNode.CENTER.equals(str)) {
reactEditText.setGravityHorizontal(1);
} else {
throw new JSApplicationIllegalArgumentException("Invalid textAlign: " + str);
}
}
@ReactProp(name = "textAlignVertical")
public void setTextAlignVertical(ReactEditText reactEditText, String str) {
if (str == null || "auto".equals(str)) {
reactEditText.setGravityVertical(0);
} else if (ViewProps.TOP.equals(str)) {
reactEditText.setGravityVertical(48);
} else if (ViewProps.BOTTOM.equals(str)) {
reactEditText.setGravityVertical(80);
} else if (TtmlNode.CENTER.equals(str)) {
reactEditText.setGravityVertical(16);
} else {
throw new JSApplicationIllegalArgumentException("Invalid textAlignVertical: " + str);
}
}
@ReactProp(name = "inlineImageLeft")
public void setInlineImageLeft(ReactEditText reactEditText, String str) {
reactEditText.setCompoundDrawablesWithIntrinsicBounds(ResourceDrawableIdHelper.getInstance().getResourceDrawableId(reactEditText.getContext(), str), 0, 0, 0);
}
@ReactProp(name = "inlineImagePadding")
public void setInlineImagePadding(ReactEditText reactEditText, int i) {
reactEditText.setCompoundDrawablePadding(i);
}
@ReactProp(defaultBoolean = true, name = "editable")
public void setEditable(ReactEditText reactEditText, boolean z) {
reactEditText.setEnabled(z);
}
@ReactProp(defaultInt = 1, name = "numberOfLines")
public void setNumLines(ReactEditText reactEditText, int i) {
reactEditText.setLines(i);
}
@ReactProp(name = "maxLength")
public void setMaxLength(ReactEditText reactEditText, Integer num) {
InputFilter[] filters = reactEditText.getFilters();
InputFilter[] inputFilterArr = EMPTY_FILTERS;
if (num == null) {
if (filters.length > 0) {
LinkedList linkedList = new LinkedList();
for (int i = 0; i < filters.length; i++) {
if (!(filters[i] instanceof InputFilter.LengthFilter)) {
linkedList.add(filters[i]);
}
}
if (!linkedList.isEmpty()) {
inputFilterArr = (InputFilter[]) linkedList.toArray(new InputFilter[linkedList.size()]);
}
}
} else if (filters.length > 0) {
boolean z = false;
for (int i2 = 0; i2 < filters.length; i2++) {
if (filters[i2] instanceof InputFilter.LengthFilter) {
filters[i2] = new InputFilter.LengthFilter(num.intValue());
z = true;
}
}
if (!z) {
InputFilter[] inputFilterArr2 = new InputFilter[(filters.length + 1)];
System.arraycopy(filters, 0, inputFilterArr2, 0, filters.length);
filters[filters.length] = new InputFilter.LengthFilter(num.intValue());
filters = inputFilterArr2;
}
inputFilterArr = filters;
} else {
inputFilterArr = new InputFilter[]{new InputFilter.LengthFilter(num.intValue())};
}
reactEditText.setFilters(inputFilterArr);
}
@ReactProp(name = "autoComplete")
public void setTextContentType(ReactEditText reactEditText, String str) {
if (str == null) {
setImportantForAutofill(reactEditText, 2);
} else if (DebugKt.DEBUG_PROPERTY_VALUE_OFF.equals(str)) {
setImportantForAutofill(reactEditText, 2);
} else {
Map<String, String> map = REACT_PROPS_AUTOFILL_HINTS_MAP;
if (map.containsKey(str)) {
setAutofillHints(reactEditText, map.get(str));
return;
}
throw new JSApplicationIllegalArgumentException("Invalid autoComplete: " + str);
}
}
@ReactProp(name = "autoCorrect")
public void setAutoCorrect(ReactEditText reactEditText, Boolean bool) {
updateStagedInputTypeFlag(reactEditText, 557056, bool != null ? bool.booleanValue() ? 32768 : 524288 : 0);
}
@ReactProp(defaultBoolean = false, name = "multiline")
public void setMultiline(ReactEditText reactEditText, boolean z) {
int i = 0;
int i2 = z ? 0 : 131072;
if (z) {
i = 131072;
}
updateStagedInputTypeFlag(reactEditText, i2, i);
}
@ReactProp(defaultBoolean = false, name = "secureTextEntry")
public void setSecureTextEntry(ReactEditText reactEditText, boolean z) {
updateStagedInputTypeFlag(reactEditText, 144, z ? 128 : 0);
checkPasswordType(reactEditText);
}
@ReactProp(name = "autoCapitalize")
public void setAutoCapitalize(ReactEditText reactEditText, Dynamic dynamic) {
int i = 16384;
if (dynamic.getType() == ReadableType.Number) {
i = dynamic.asInt();
} else if (dynamic.getType() == ReadableType.String) {
String asString = dynamic.asString();
if (asString.equals("none")) {
i = 0;
} else if (asString.equals("characters")) {
i = 4096;
} else if (asString.equals("words")) {
i = 8192;
} else {
boolean equals = asString.equals("sentences");
}
}
updateStagedInputTypeFlag(reactEditText, AUTOCAPITALIZE_FLAGS, i);
}
@ReactProp(name = "keyboardType")
public void setKeyboardType(ReactEditText reactEditText, String str) {
int i;
if (KEYBOARD_TYPE_NUMERIC.equalsIgnoreCase(str)) {
i = INPUT_TYPE_KEYBOARD_NUMBERED;
} else if (KEYBOARD_TYPE_NUMBER_PAD.equalsIgnoreCase(str)) {
i = 2;
} else if (KEYBOARD_TYPE_DECIMAL_PAD.equalsIgnoreCase(str)) {
i = 8194;
} else if (KEYBOARD_TYPE_EMAIL_ADDRESS.equalsIgnoreCase(str)) {
i = 33;
if (shouldHideCursorForEmailTextInput()) {
reactEditText.setCursorVisible(false);
}
} else {
i = KEYBOARD_TYPE_PHONE_PAD.equalsIgnoreCase(str) ? 3 : KEYBOARD_TYPE_VISIBLE_PASSWORD.equalsIgnoreCase(str) ? 144 : "url".equalsIgnoreCase(str) ? 16 : 1;
}
updateStagedInputTypeFlag(reactEditText, 15, i);
checkPasswordType(reactEditText);
}
@ReactProp(name = "returnKeyType")
public void setReturnKeyType(ReactEditText reactEditText, String str) {
reactEditText.setReturnKeyType(str);
}
@ReactProp(defaultBoolean = false, name = "disableFullscreenUI")
public void setDisableFullscreenUI(ReactEditText reactEditText, boolean z) {
reactEditText.setDisableFullscreenUI(z);
}
@ReactProp(name = "returnKeyLabel")
public void setReturnKeyLabel(ReactEditText reactEditText, String str) {
reactEditText.setImeActionLabel(str, IME_ACTION_ID);
}
@ReactPropGroup(defaultFloat = Float.NaN, names = {"borderRadius", "borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"})
public void setBorderRadius(ReactEditText reactEditText, int i, float f) {
if (!YogaConstants.isUndefined(f)) {
f = PixelUtil.toPixelFromDIP(f);
}
if (i == 0) {
reactEditText.setBorderRadius(f);
} else {
reactEditText.setBorderRadius(f, i - 1);
}
}
@ReactProp(name = "borderStyle")
public void setBorderStyle(ReactEditText reactEditText, String str) {
reactEditText.setBorderStyle(str);
}
@ReactProp(defaultBoolean = true, name = "showSoftInputOnFocus")
public void showKeyboardOnFocus(ReactEditText reactEditText, boolean z) {
reactEditText.setShowSoftInputOnFocus(z);
}
@ReactProp(defaultBoolean = false, name = "autoFocus")
public void setAutoFocus(ReactEditText reactEditText, boolean z) {
reactEditText.setAutoFocus(z);
}
@ReactPropGroup(defaultFloat = Float.NaN, names = {"borderWidth", "borderLeftWidth", "borderRightWidth", "borderTopWidth", "borderBottomWidth"})
public void setBorderWidth(ReactEditText reactEditText, int i, float f) {
if (!YogaConstants.isUndefined(f)) {
f = PixelUtil.toPixelFromDIP(f);
}
reactEditText.setBorderWidth(SPACING_TYPES[i], f);
}
@ReactPropGroup(customType = "Color", names = {"borderColor", "borderLeftColor", "borderRightColor", "borderTopColor", "borderBottomColor"})
public void setBorderColor(ReactEditText reactEditText, int i, Integer num) {
float f = Float.NaN;
float intValue = num == null ? Float.NaN : (float) (num.intValue() & ViewCompat.MEASURED_SIZE_MASK);
if (num != null) {
f = (float) (num.intValue() >>> 24);
}
reactEditText.setBorderColor(SPACING_TYPES[i], intValue, f);
}
/* access modifiers changed from: protected */
public void onAfterUpdateTransaction(ReactEditText reactEditText) {
super.onAfterUpdateTransaction(reactEditText);
reactEditText.maybeUpdateTypeface();
reactEditText.commitStagedInputType();
}
private static void checkPasswordType(ReactEditText reactEditText) {
if ((reactEditText.getStagedInputType() & INPUT_TYPE_KEYBOARD_NUMBERED) != 0 && (reactEditText.getStagedInputType() & 128) != 0) {
updateStagedInputTypeFlag(reactEditText, 128, 16);
}
}
private static void updateStagedInputTypeFlag(ReactEditText reactEditText, int i, int i2) {
reactEditText.setStagedInputType(((~i) & reactEditText.getStagedInputType()) | i2);
}
/* access modifiers changed from: private */
public static EventDispatcher getEventDispatcher(ReactContext reactContext, ReactEditText reactEditText) {
return UIManagerHelper.getEventDispatcherForReactTag(reactContext, reactEditText.getId());
}
private final class ReactTextInputTextWatcher implements TextWatcher {
/* access modifiers changed from: private */
public final ReactEditText mEditText;
private final EventDispatcher mEventDispatcher;
private String mPreviousText = null;
private final int mSurfaceId;
public void afterTextChanged(Editable editable) {
}
public ReactTextInputTextWatcher(ReactContext reactContext, ReactEditText reactEditText) {
this.mEventDispatcher = ReactTextInputManager.getEventDispatcher(reactContext, reactEditText);
this.mEditText = reactEditText;
this.mSurfaceId = UIManagerHelper.getSurfaceId((Context) reactContext);
}
public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) {
this.mPreviousText = charSequence.toString();
}
public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) {
if (!this.mEditText.mDisableTextDiffing) {
if (i3 != 0 || i2 != 0) {
Assertions.assertNotNull(this.mPreviousText);
String substring = charSequence.toString().substring(i, i + i3);
int i4 = i + i2;
String substring2 = this.mPreviousText.substring(i, i4);
if (i3 != i2 || !substring.equals(substring2)) {
FabricViewStateManager fabricViewStateManager = this.mEditText.getFabricViewStateManager();
if (fabricViewStateManager.hasStateWrapper()) {
fabricViewStateManager.setState(new FabricViewStateManager.StateUpdateCallback() {
public WritableMap getStateUpdate() {
WritableNativeMap writableNativeMap = new WritableNativeMap();
writableNativeMap.putInt("mostRecentEventCount", ReactTextInputTextWatcher.this.mEditText.incrementAndGetEventCounter());
writableNativeMap.putInt("opaqueCacheId", ReactTextInputTextWatcher.this.mEditText.getId());
return writableNativeMap;
}
});
}
this.mEventDispatcher.dispatchEvent(new ReactTextChangedEvent(this.mSurfaceId, this.mEditText.getId(), charSequence.toString(), this.mEditText.incrementAndGetEventCounter()));
this.mEventDispatcher.dispatchEvent(new ReactTextInputEvent(this.mSurfaceId, this.mEditText.getId(), substring, substring2, i, i4));
}
}
}
}
}
/* access modifiers changed from: protected */
public void addEventEmitters(final ThemedReactContext themedReactContext, final ReactEditText reactEditText) {
reactEditText.setEventDispatcher(getEventDispatcher(themedReactContext, reactEditText));
reactEditText.addTextChangedListener(new ReactTextInputTextWatcher(themedReactContext, reactEditText));
reactEditText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
public void onFocusChange(View view, boolean z) {
int surfaceId = themedReactContext.getSurfaceId();
EventDispatcher access$000 = ReactTextInputManager.getEventDispatcher(themedReactContext, reactEditText);
if (z) {
access$000.dispatchEvent(new ReactTextInputFocusEvent(surfaceId, reactEditText.getId()));
return;
}
access$000.dispatchEvent(new ReactTextInputBlurEvent(surfaceId, reactEditText.getId()));
access$000.dispatchEvent(new ReactTextInputEndEditingEvent(surfaceId, reactEditText.getId(), reactEditText.getText().toString()));
}
});
reactEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
public boolean onEditorAction(TextView textView, int i, KeyEvent keyEvent) {
if ((i & 255) == 0 && i != 0) {
return true;
}
boolean blurOnSubmit = reactEditText.getBlurOnSubmit();
boolean isMultiline = reactEditText.isMultiline();
ReactTextInputManager.getEventDispatcher(themedReactContext, reactEditText).dispatchEvent(new ReactTextInputSubmitEditingEvent(themedReactContext.getSurfaceId(), reactEditText.getId(), reactEditText.getText().toString()));
if (blurOnSubmit) {
reactEditText.clearFocus();
}
if (blurOnSubmit || !isMultiline || i == 5 || i == 7) {
return true;
}
return false;
}
});
}
private static class ReactContentSizeWatcher implements ContentSizeWatcher {
private final ReactEditText mEditText;
private final EventDispatcher mEventDispatcher;
private int mPreviousContentHeight = 0;
private int mPreviousContentWidth = 0;
private final int mSurfaceId;
public ReactContentSizeWatcher(ReactEditText reactEditText) {
this.mEditText = reactEditText;
ReactContext reactContext = UIManagerHelper.getReactContext(reactEditText);
this.mEventDispatcher = ReactTextInputManager.getEventDispatcher(reactContext, reactEditText);
this.mSurfaceId = UIManagerHelper.getSurfaceId((Context) reactContext);
}
public void onLayout() {
if (this.mEventDispatcher != null) {
int width = this.mEditText.getWidth();
int height = this.mEditText.getHeight();
if (this.mEditText.getLayout() != null) {
width = this.mEditText.getCompoundPaddingLeft() + this.mEditText.getLayout().getWidth() + this.mEditText.getCompoundPaddingRight();
height = this.mEditText.getCompoundPaddingTop() + this.mEditText.getLayout().getHeight() + this.mEditText.getCompoundPaddingBottom();
}
if (width != this.mPreviousContentWidth || height != this.mPreviousContentHeight) {
this.mPreviousContentHeight = height;
this.mPreviousContentWidth = width;
this.mEventDispatcher.dispatchEvent(new ReactContentSizeChangedEvent(this.mSurfaceId, this.mEditText.getId(), PixelUtil.toDIPFromPixel((float) width), PixelUtil.toDIPFromPixel((float) height)));
}
}
}
}
private static class ReactSelectionWatcher implements SelectionWatcher {
private final EventDispatcher mEventDispatcher;
private int mPreviousSelectionEnd;
private int mPreviousSelectionStart;
private final ReactEditText mReactEditText;
private final int mSurfaceId;
public ReactSelectionWatcher(ReactEditText reactEditText) {
this.mReactEditText = reactEditText;
ReactContext reactContext = UIManagerHelper.getReactContext(reactEditText);
this.mEventDispatcher = ReactTextInputManager.getEventDispatcher(reactContext, reactEditText);
this.mSurfaceId = UIManagerHelper.getSurfaceId((Context) reactContext);
}
public void onSelectionChanged(int i, int i2) {
int min = Math.min(i, i2);
int max = Math.max(i, i2);
if (this.mPreviousSelectionStart != min || this.mPreviousSelectionEnd != max) {
this.mEventDispatcher.dispatchEvent(new ReactTextInputSelectionEvent(this.mSurfaceId, this.mReactEditText.getId(), min, max));
this.mPreviousSelectionStart = min;
this.mPreviousSelectionEnd = max;
}
}
}
private static class ReactScrollWatcher implements ScrollWatcher {
private final EventDispatcher mEventDispatcher;
private int mPreviousHoriz;
private int mPreviousVert;
private final ReactEditText mReactEditText;
private final int mSurfaceId;
public ReactScrollWatcher(ReactEditText reactEditText) {
this.mReactEditText = reactEditText;
ReactContext reactContext = UIManagerHelper.getReactContext(reactEditText);
this.mEventDispatcher = ReactTextInputManager.getEventDispatcher(reactContext, reactEditText);
this.mSurfaceId = UIManagerHelper.getSurfaceId((Context) reactContext);
}
public void onScrollChanged(int i, int i2, int i3, int i4) {
if (this.mPreviousHoriz != i || this.mPreviousVert != i2) {
this.mEventDispatcher.dispatchEvent(ScrollEvent.obtain(this.mSurfaceId, this.mReactEditText.getId(), ScrollEventType.SCROLL, (float) i, (float) i2, 0.0f, 0.0f, 0, 0, this.mReactEditText.getWidth(), this.mReactEditText.getHeight()));
this.mPreviousHoriz = i;
this.mPreviousVert = i2;
}
}
}
public Map getExportedViewConstants() {
return MapBuilder.of("AutoCapitalizationType", MapBuilder.of("none", 0, "characters", 4096, "words", 8192, "sentences", 16384));
}
public void setPadding(ReactEditText reactEditText, int i, int i2, int i3, int i4) {
reactEditText.setPadding(i, i2, i3, i4);
}
public Object updateState(ReactEditText reactEditText, ReactStylesDiffMap reactStylesDiffMap, StateWrapper stateWrapper) {
FabricViewStateManager fabricViewStateManager = reactEditText.getFabricViewStateManager();
if (!fabricViewStateManager.hasStateWrapper()) {
reactEditText.setPadding(0, 0, 0, 0);
}
fabricViewStateManager.setStateWrapper(stateWrapper);
ReadableNativeMap stateData = stateWrapper.getStateData();
if (stateData == null || !stateData.hasKey("attributedString")) {
return null;
}
ReadableNativeMap map = stateData.getMap("attributedString");
ReadableNativeMap map2 = stateData.getMap("paragraphAttributes");
if (map == null || map2 == null) {
throw new IllegalArgumentException("Invalid TextInput State was received as a parameters");
}
return ReactTextUpdate.buildReactTextUpdateFromState(TextLayoutManager.getOrCreateSpannableForText(reactEditText.getContext(), map, this.mReactTextViewManagerCallback), stateData.getInt("mostRecentEventCount"), TextAttributeProps.getTextAlignment(reactStylesDiffMap, TextLayoutManager.isRTL(map)), TextAttributeProps.getTextBreakStrategy(map2.getString(ViewProps.TEXT_BREAK_STRATEGY)), TextAttributeProps.getJustificationMode(reactStylesDiffMap), map.getArray("fragments").toArrayList().size() > 1);
}
}
Download file