NetMirror.apk
Download file
package com.facebook.react.bridge;
import a1.C0210a;
import com.facebook.react.bridge.JavaModuleWrapper;
import d2.C0519b;
import j0.C0569c;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import k0.C0582a;
/* JADX INFO: loaded from: classes.dex */
class JavaMethodWrapper implements JavaModuleWrapper.NativeMethod {
private ArgumentExtractor[] mArgumentExtractors;
private Object[] mArguments;
private boolean mArgumentsProcessed = false;
private int mJSArgumentsNeeded;
private final Method mMethod;
private final JavaModuleWrapper mModuleWrapper;
private final int mParamLength;
private final Class[] mParameterTypes;
private String mSignature;
private String mType;
private static final ArgumentExtractor<Boolean> ARGUMENT_EXTRACTOR_BOOLEAN = new ArgumentExtractor<Boolean>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.1
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Boolean extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return Boolean.valueOf(readableArray.getBoolean(i3));
}
};
private static final ArgumentExtractor<Double> ARGUMENT_EXTRACTOR_DOUBLE = new ArgumentExtractor<Double>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.2
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Double extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return Double.valueOf(readableArray.getDouble(i3));
}
};
private static final ArgumentExtractor<Float> ARGUMENT_EXTRACTOR_FLOAT = new ArgumentExtractor<Float>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.3
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Float extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return Float.valueOf((float) readableArray.getDouble(i3));
}
};
private static final ArgumentExtractor<Integer> ARGUMENT_EXTRACTOR_INTEGER = new ArgumentExtractor<Integer>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.4
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Integer extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return Integer.valueOf((int) readableArray.getDouble(i3));
}
};
private static final ArgumentExtractor<String> ARGUMENT_EXTRACTOR_STRING = new ArgumentExtractor<String>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.5
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public String extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return readableArray.getString(i3);
}
};
private static final ArgumentExtractor<ReadableArray> ARGUMENT_EXTRACTOR_ARRAY = new ArgumentExtractor<ReadableArray>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.6
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public ReadableArray extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return readableArray.getArray(i3);
}
};
private static final ArgumentExtractor<Dynamic> ARGUMENT_EXTRACTOR_DYNAMIC = new ArgumentExtractor<Dynamic>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.7
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Dynamic extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return DynamicFromArray.create(readableArray, i3);
}
};
private static final ArgumentExtractor<ReadableMap> ARGUMENT_EXTRACTOR_MAP = new ArgumentExtractor<ReadableMap>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.8
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public ReadableMap extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return readableArray.getMap(i3);
}
};
private static final ArgumentExtractor<Callback> ARGUMENT_EXTRACTOR_CALLBACK = new ArgumentExtractor<Callback>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.9
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Callback extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
if (readableArray.isNull(i3)) {
return null;
}
return new CallbackImpl(jSInstance, (int) readableArray.getDouble(i3));
}
};
private static final ArgumentExtractor<Promise> ARGUMENT_EXTRACTOR_PROMISE = new ArgumentExtractor<Promise>() { // from class: com.facebook.react.bridge.JavaMethodWrapper.10
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public int getJSArgumentsNeeded() {
return 2;
}
/* JADX WARN: Can't rename method to resolve collision */
@Override // com.facebook.react.bridge.JavaMethodWrapper.ArgumentExtractor
public Promise extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3) {
return new PromiseImpl((Callback) JavaMethodWrapper.ARGUMENT_EXTRACTOR_CALLBACK.extractArgument(jSInstance, readableArray, i3), (Callback) JavaMethodWrapper.ARGUMENT_EXTRACTOR_CALLBACK.extractArgument(jSInstance, readableArray, i3 + 1));
}
};
private static final boolean DEBUG = C0569c.a().a(C0582a.f9582e);
private static abstract class ArgumentExtractor<T> {
public abstract T extractArgument(JSInstance jSInstance, ReadableArray readableArray, int i3);
public int getJSArgumentsNeeded() {
return 1;
}
private ArgumentExtractor() {
}
}
public JavaMethodWrapper(JavaModuleWrapper javaModuleWrapper, Method method, boolean z3) {
this.mType = BaseJavaModule.METHOD_TYPE_ASYNC;
this.mModuleWrapper = javaModuleWrapper;
this.mMethod = method;
method.setAccessible(true);
Class<?>[] parameterTypes = method.getParameterTypes();
this.mParameterTypes = parameterTypes;
int length = parameterTypes.length;
this.mParamLength = length;
if (z3) {
this.mType = BaseJavaModule.METHOD_TYPE_SYNC;
} else {
if (length <= 0 || parameterTypes[length - 1] != Promise.class) {
return;
}
this.mType = BaseJavaModule.METHOD_TYPE_PROMISE;
}
}
private ArgumentExtractor[] buildArgumentExtractors(Class[] clsArr) {
ArgumentExtractor[] argumentExtractorArr = new ArgumentExtractor[clsArr.length];
int jSArgumentsNeeded = 0;
while (jSArgumentsNeeded < clsArr.length) {
Class cls = clsArr[jSArgumentsNeeded];
if (cls == Boolean.class || cls == Boolean.TYPE) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_BOOLEAN;
} else if (cls == Integer.class || cls == Integer.TYPE) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_INTEGER;
} else if (cls == Double.class || cls == Double.TYPE) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_DOUBLE;
} else if (cls == Float.class || cls == Float.TYPE) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_FLOAT;
} else if (cls == String.class) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_STRING;
} else if (cls == Callback.class) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_CALLBACK;
} else if (cls == Promise.class) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_PROMISE;
C0210a.b(jSArgumentsNeeded == clsArr.length - 1, "Promise must be used as last parameter only");
} else if (cls == ReadableMap.class) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_MAP;
} else if (cls == ReadableArray.class) {
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_ARRAY;
} else {
if (cls != Dynamic.class) {
throw new RuntimeException("Got unknown argument class: " + cls.getSimpleName());
}
argumentExtractorArr[jSArgumentsNeeded] = ARGUMENT_EXTRACTOR_DYNAMIC;
}
jSArgumentsNeeded += argumentExtractorArr[jSArgumentsNeeded].getJSArgumentsNeeded();
}
return argumentExtractorArr;
}
private String buildSignature(Method method, Class[] clsArr, boolean z3) {
StringBuilder sb = new StringBuilder(clsArr.length + 2);
if (z3) {
sb.append(returnTypeToChar(method.getReturnType()));
sb.append('.');
} else {
sb.append("v.");
}
int i3 = 0;
while (i3 < clsArr.length) {
Class cls = clsArr[i3];
if (cls == Promise.class) {
C0210a.b(i3 == clsArr.length - 1, "Promise must be used as last parameter only");
}
sb.append(paramTypeToChar(cls));
i3++;
}
return sb.toString();
}
private int calculateJSArgumentsNeeded() {
int jSArgumentsNeeded = 0;
for (ArgumentExtractor argumentExtractor : (ArgumentExtractor[]) C0210a.c(this.mArgumentExtractors)) {
jSArgumentsNeeded += argumentExtractor.getJSArgumentsNeeded();
}
return jSArgumentsNeeded;
}
private static char commonTypeToChar(Class cls) {
if (cls == Boolean.TYPE) {
return 'z';
}
if (cls == Boolean.class) {
return 'Z';
}
if (cls == Integer.TYPE) {
return 'i';
}
if (cls == Integer.class) {
return 'I';
}
if (cls == Double.TYPE) {
return 'd';
}
if (cls == Double.class) {
return 'D';
}
if (cls == Float.TYPE) {
return 'f';
}
if (cls == Float.class) {
return 'F';
}
return cls == String.class ? 'S' : (char) 0;
}
private static String createInvokeExceptionMessage(String str) {
return "Could not invoke " + str;
}
private String getAffectedRange(int i3, int i4) {
if (i4 <= 1) {
return "" + i3;
}
return "" + i3 + "-" + ((i3 + i4) - 1);
}
private static char paramTypeToChar(Class cls) {
char cCommonTypeToChar = commonTypeToChar(cls);
if (cCommonTypeToChar != 0) {
return cCommonTypeToChar;
}
if (cls == Callback.class) {
return 'X';
}
if (cls == Promise.class) {
return 'P';
}
if (cls == ReadableMap.class) {
return 'M';
}
if (cls == ReadableArray.class) {
return 'A';
}
if (cls == Dynamic.class) {
return 'Y';
}
throw new RuntimeException("Got unknown param class: " + cls.getSimpleName());
}
private void processArguments() {
if (this.mArgumentsProcessed) {
return;
}
C0519b.a(0L, "processArguments").b("method", this.mModuleWrapper.getName() + "." + this.mMethod.getName()).c();
try {
this.mArgumentsProcessed = true;
this.mArgumentExtractors = buildArgumentExtractors(this.mParameterTypes);
this.mSignature = buildSignature(this.mMethod, this.mParameterTypes, this.mType.equals(BaseJavaModule.METHOD_TYPE_SYNC));
this.mArguments = new Object[this.mParameterTypes.length];
this.mJSArgumentsNeeded = calculateJSArgumentsNeeded();
} finally {
C0519b.b(0L).c();
}
}
private static char returnTypeToChar(Class cls) {
char cCommonTypeToChar = commonTypeToChar(cls);
if (cCommonTypeToChar != 0) {
return cCommonTypeToChar;
}
if (cls == Void.TYPE) {
return 'v';
}
if (cls == WritableMap.class) {
return 'M';
}
if (cls == WritableArray.class) {
return 'A';
}
throw new RuntimeException("Got unknown return class: " + cls.getSimpleName());
}
public Method getMethod() {
return this.mMethod;
}
public String getSignature() {
if (!this.mArgumentsProcessed) {
processArguments();
}
return (String) C0210a.c(this.mSignature);
}
@Override // com.facebook.react.bridge.JavaModuleWrapper.NativeMethod
public String getType() {
return this.mType;
}
@Override // com.facebook.react.bridge.JavaModuleWrapper.NativeMethod
public void invoke(JSInstance jSInstance, ReadableArray readableArray) {
String str = this.mModuleWrapper.getName() + "." + this.mMethod.getName();
C0519b.a(0L, "callJavaModuleMethod").b("method", str).c();
if (DEBUG) {
C0569c.a().b(C0582a.f9582e, "JS->Java: %s.%s()", this.mModuleWrapper.getName(), this.mMethod.getName());
}
try {
if (!this.mArgumentsProcessed) {
processArguments();
}
if (this.mArguments == null || this.mArgumentExtractors == null) {
throw new Error("processArguments failed");
}
if (this.mJSArgumentsNeeded != readableArray.size()) {
throw new NativeArgumentsParseException(str + " got " + readableArray.size() + " arguments, expected " + this.mJSArgumentsNeeded);
}
int i3 = 0;
int jSArgumentsNeeded = 0;
while (true) {
try {
ArgumentExtractor[] argumentExtractorArr = this.mArgumentExtractors;
if (i3 >= argumentExtractorArr.length) {
try {
this.mMethod.invoke(this.mModuleWrapper.getModule(), this.mArguments);
C0519b.b(0L).c();
return;
} catch (IllegalAccessException e4) {
e = e4;
throw new RuntimeException(createInvokeExceptionMessage(str), e);
} catch (IllegalArgumentException e5) {
e = e5;
throw new RuntimeException(createInvokeExceptionMessage(str), e);
} catch (InvocationTargetException e6) {
if (!(e6.getCause() instanceof RuntimeException)) {
throw new RuntimeException(createInvokeExceptionMessage(str), e6);
}
throw ((RuntimeException) e6.getCause());
}
}
this.mArguments[i3] = argumentExtractorArr[i3].extractArgument(jSInstance, readableArray, jSArgumentsNeeded);
jSArgumentsNeeded += this.mArgumentExtractors[i3].getJSArgumentsNeeded();
i3++;
} catch (UnexpectedNativeTypeException | NullPointerException e7) {
throw new NativeArgumentsParseException(e7.getMessage() + " (constructing arguments for " + str + " at argument index " + getAffectedRange(jSArgumentsNeeded, this.mArgumentExtractors[i3].getJSArgumentsNeeded()) + ")", e7);
}
}
} catch (Throwable th) {
C0519b.b(0L).c();
throw th;
}
}
}
⚠️ This content was hidden by an advertisement filtering extension in your browser. Please disable it and reload the page to access the decompiled content.
We only display one small text ad to keep this service free. Here's what it looks like:
Read the Docs for Business: You write the docs. We do the rest.
Try it today!Ad by EthicalAds