package com.huawei.hms.support.api;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;
import android.util.Pair;
import com.huawei.hms.adapter.BaseAdapter;
import com.huawei.hms.common.internal.TransactionIdCreater;
import com.huawei.hms.core.aidl.AbstractMessageEntity;
import com.huawei.hms.core.aidl.IMessageEntity;
import com.huawei.hms.support.api.client.ApiClient;
import com.huawei.hms.support.api.client.InnerPendingResult;
import com.huawei.hms.support.api.client.Result;
import com.huawei.hms.support.api.client.ResultCallback;
import com.huawei.hms.support.api.client.Status;
import com.huawei.hms.support.api.client.SubAppInfo;
import com.huawei.hms.support.api.entity.core.CommonCode;
import com.huawei.hms.support.api.transport.DatagramTransport;
import com.huawei.hms.support.gentyref.GenericTypeReflector;
import com.huawei.hms.support.hianalytics.HiAnalyticsConstant;
import com.huawei.hms.support.hianalytics.HiAnalyticsUtil;
import com.huawei.hms.support.log.HMSLog;
import com.huawei.hms.utils.Util;
import com.meizu.cloud.pushsdk.constants.PushConstants;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public abstract class PendingResultImpl<R extends Result, T extends IMessageEntity> extends InnerPendingResult<R> {
private static final String TAG = "PendingResultImpl";
private WeakReference<ApiClient> api;
private CountDownLatch countLatch;
private boolean isNeedReport = true;
private R result = null;
private String transId = null;
protected DatagramTransport transport = null;
private String url = null;
/* access modifiers changed from: package-private */
public class a implements DatagramTransport.a {
a() {
}
@Override // com.huawei.hms.support.api.transport.DatagramTransport.a
public void a(int i, IMessageEntity iMessageEntity) {
PendingResultImpl.this.setResult(i, iMessageEntity);
PendingResultImpl.this.countLatch.countDown();
}
}
/* access modifiers changed from: package-private */
public class b implements DatagramTransport.a {
final /* synthetic */ AtomicBoolean a;
b(AtomicBoolean atomicBoolean) {
this.a = atomicBoolean;
}
@Override // com.huawei.hms.support.api.transport.DatagramTransport.a
public void a(int i, IMessageEntity iMessageEntity) {
if (!this.a.get()) {
PendingResultImpl.this.setResult(i, iMessageEntity);
}
PendingResultImpl.this.countLatch.countDown();
}
}
/* access modifiers changed from: package-private */
public class c implements DatagramTransport.a {
final /* synthetic */ d a;
final /* synthetic */ ResultCallback b;
c(d dVar, ResultCallback resultCallback) {
this.a = dVar;
this.b = resultCallback;
}
/* JADX DEBUG: Multi-variable search result rejected for r2v1, resolved type: com.huawei.hms.support.api.PendingResultImpl$d */
/* JADX WARN: Multi-variable type inference failed */
@Override // com.huawei.hms.support.api.transport.DatagramTransport.a
public void a(int i, IMessageEntity iMessageEntity) {
PendingResultImpl.this.setResult(i, iMessageEntity);
this.a.a(this.b, PendingResultImpl.this.result);
}
}
/* access modifiers changed from: protected */
public static class d<R extends Result> extends Handler {
public d(Looper looper) {
super(looper);
}
public void a(ResultCallback<? super R> resultCallback, R r) {
sendMessage(obtainMessage(1, new Pair(resultCallback, r)));
}
/* access modifiers changed from: protected */
public void b(ResultCallback<? super R> resultCallback, R r) {
resultCallback.onResult(r);
}
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: com.huawei.hms.support.api.PendingResultImpl$d<R extends com.huawei.hms.support.api.client.Result> */
/* JADX WARN: Multi-variable type inference failed */
public void handleMessage(Message message) {
if (message.what == 1) {
Pair pair = (Pair) message.obj;
b((ResultCallback) pair.first, (Result) pair.second);
}
}
}
public PendingResultImpl(ApiClient apiClient, String str, IMessageEntity iMessageEntity) {
init(apiClient, str, iMessageEntity, getResponseType(), 0);
}
private void biReportEvent(int i, int i2) {
SubAppInfo subAppInfo;
HMSLog.i(TAG, "biReportEvent ====== ");
ApiClient apiClient = this.api.get();
if (apiClient != null && this.url != null && !HiAnalyticsUtil.getInstance().hasError(apiClient.getContext())) {
HashMap hashMap = new HashMap();
hashMap.put("package", apiClient.getPackageName());
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_BASE_VERSION, "5.3.0.304");
if (i2 == 1) {
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_DIRECTION, HiAnalyticsConstant.Direction.REQUEST);
} else {
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_DIRECTION, HiAnalyticsConstant.Direction.RESPONSE);
hashMap.put("result", String.valueOf(i));
R r = this.result;
if (!(r == null || r.getStatus() == null)) {
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_RESULT, String.valueOf(this.result.getStatus().getStatusCode()));
}
}
hashMap.put("version", PushConstants.PUSH_TYPE_NOTIFY);
String appId = Util.getAppId(apiClient.getContext());
if (TextUtils.isEmpty(appId) && (subAppInfo = apiClient.getSubAppInfo()) != null) {
appId = subAppInfo.getSubAppID();
}
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_APPID, appId);
if (TextUtils.isEmpty(this.transId)) {
String id = TransactionIdCreater.getId(appId, this.url);
this.transId = id;
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_TRANSID, id);
} else {
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_TRANSID, this.transId);
this.transId = null;
}
String[] split = this.url.split("\\.");
if (split.length >= 2) {
hashMap.put("service", split[0]);
hashMap.put("apiName", split[1]);
}
hashMap.put("callTime", String.valueOf(System.currentTimeMillis()));
hashMap.put(HiAnalyticsConstant.HaKey.BI_KEY_PHONETYPE, Util.getSystemProperties("ro.logsystem.usertype", ""));
HiAnalyticsUtil.getInstance().onEvent(apiClient.getContext(), HiAnalyticsConstant.HMS_SDK_BASE_CALL_AIDL, hashMap);
}
}
private void init(ApiClient apiClient, String str, IMessageEntity iMessageEntity, Class<T> cls, int i) {
HMSLog.i(TAG, "init uri:" + str);
this.url = str;
if (apiClient == null) {
HMSLog.e(TAG, "client is null");
return;
}
this.api = new WeakReference<>(apiClient);
this.countLatch = new CountDownLatch(1);
try {
this.transport = (DatagramTransport) Class.forName(apiClient.getTransportName()).getConstructor(String.class, IMessageEntity.class, Class.class, Integer.TYPE).newInstance(str, iMessageEntity, cls, Integer.valueOf(i));
} catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | InstantiationException | NoSuchMethodException | InvocationTargetException e) {
HMSLog.e(TAG, "gen transport error:" + e.getMessage());
throw new IllegalStateException("Instancing transport exception, " + e.getMessage(), e);
}
}
/* JADX DEBUG: Multi-variable search result rejected for r10v0, resolved type: com.huawei.hms.core.aidl.IMessageEntity */
/* JADX WARN: Multi-variable type inference failed */
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void setResult(int i, IMessageEntity iMessageEntity) {
Status status;
HMSLog.i(TAG, "setResult:" + i);
Status commonStatus = iMessageEntity instanceof AbstractMessageEntity ? ((AbstractMessageEntity) iMessageEntity).getCommonStatus() : null;
if (i == 0) {
this.result = onComplete(iMessageEntity);
} else {
this.result = onError(i);
}
if (this.isNeedReport) {
biReportEvent(i, 2);
}
R r = this.result;
if (r != null && (status = r.getStatus()) != null && commonStatus != null) {
int statusCode = status.getStatusCode();
String statusMessage = status.getStatusMessage();
int statusCode2 = commonStatus.getStatusCode();
String statusMessage2 = commonStatus.getStatusMessage();
if (statusCode != statusCode2) {
HMSLog.e(TAG, "rstStatus code (" + statusCode + ") is not equal commonStatus code (" + statusCode2 + ")");
HMSLog.e(TAG, "rstStatus msg (" + statusMessage + ") is not equal commonStatus msg (" + statusMessage2 + ")");
} else if (TextUtils.isEmpty(statusMessage) && !TextUtils.isEmpty(statusMessage2)) {
HMSLog.i(TAG, "rstStatus msg (" + statusMessage + ") is not equal commonStatus msg (" + statusMessage2 + ")");
this.result.setStatus(new Status(statusCode, statusMessage2, status.getResolution()));
}
}
}
@Override // com.huawei.hms.support.api.client.PendingResult
public final R await() {
HMSLog.i(TAG, "await");
if (Looper.myLooper() != Looper.getMainLooper()) {
return awaitOnAnyThread();
}
HMSLog.e(TAG, "await in main thread");
throw new IllegalStateException("await must not be called on the UI thread");
}
@Override // com.huawei.hms.support.api.client.InnerPendingResult
public final R awaitOnAnyThread() {
HMSLog.i(TAG, "awaitOnAnyThread");
WeakReference<ApiClient> weakReference = this.api;
if (weakReference == null) {
HMSLog.e(TAG, "api is null");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
return this.result;
}
ApiClient apiClient = weakReference.get();
if (!checkApiClient(apiClient)) {
HMSLog.e(TAG, "client invalid");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
return this.result;
}
if (this.isNeedReport) {
biReportEvent(0, 1);
}
this.transport.send(apiClient, new a());
try {
this.countLatch.await();
} catch (InterruptedException unused) {
HMSLog.e(TAG, "await in anythread InterruptedException");
setResult(CommonCode.ErrorCode.INTERNAL_ERROR, null);
}
return this.result;
}
@Override // com.huawei.hms.support.api.client.PendingResult
@Deprecated
public void cancel() {
}
/* access modifiers changed from: protected */
public boolean checkApiClient(ApiClient apiClient) {
return true;
}
/* access modifiers changed from: protected */
public Class<T> getResponseType() {
Type type;
Type genericSuperclass = getClass().getGenericSuperclass();
if (genericSuperclass == null || (type = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[1]) == null) {
return null;
}
return (Class) type;
}
@Override // com.huawei.hms.support.api.client.PendingResult
@Deprecated
public boolean isCanceled() {
return false;
}
public abstract R onComplete(T t);
/* access modifiers changed from: protected */
public R onError(int i) {
Type genericSuperclass = getClass().getGenericSuperclass();
Type type = genericSuperclass != null ? ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0] : null;
Class<?> type2 = type != null ? GenericTypeReflector.getType(type) : null;
if (type2 != null) {
try {
R r = (R) ((Result) type2.newInstance());
this.result = r;
r.setStatus(new Status(i));
} catch (Exception e) {
HMSLog.e(TAG, "on Error:" + e.getMessage());
return null;
}
}
return this.result;
}
@Override // com.huawei.hms.support.api.client.PendingResult
public void setResultCallback(ResultCallback<R> resultCallback) {
this.isNeedReport = !(resultCallback instanceof BaseAdapter.BaseRequestResultCallback);
setResultCallback(Looper.getMainLooper(), resultCallback);
}
@Override // com.huawei.hms.support.api.client.PendingResult
public final void setResultCallback(Looper looper, ResultCallback<R> resultCallback) {
HMSLog.i(TAG, "setResultCallback");
if (looper == null) {
looper = Looper.myLooper();
}
d dVar = new d(looper);
WeakReference<ApiClient> weakReference = this.api;
if (weakReference == null) {
HMSLog.e(TAG, "api is null");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
return;
}
ApiClient apiClient = weakReference.get();
if (!checkApiClient(apiClient)) {
HMSLog.e(TAG, "client is invalid");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
dVar.a(resultCallback, this.result);
return;
}
if (this.isNeedReport) {
biReportEvent(0, 1);
}
this.transport.post(apiClient, new c(dVar, resultCallback));
}
@Override // com.huawei.hms.support.api.client.PendingResult
public R await(long j, TimeUnit timeUnit) {
HMSLog.i(TAG, "await timeout:" + j + " unit:" + timeUnit.toString());
if (Looper.myLooper() != Looper.getMainLooper()) {
return awaitOnAnyThread(j, timeUnit);
}
HMSLog.i(TAG, "await in main thread");
throw new IllegalStateException("await must not be called on the UI thread");
}
@Override // com.huawei.hms.support.api.client.PendingResult
@Deprecated
public void setResultCallback(ResultCallback<R> resultCallback, long j, TimeUnit timeUnit) {
setResultCallback(resultCallback);
}
public PendingResultImpl(ApiClient apiClient, String str, IMessageEntity iMessageEntity, Class<T> cls) {
init(apiClient, str, iMessageEntity, cls, 0);
}
@Override // com.huawei.hms.support.api.client.InnerPendingResult
public final R awaitOnAnyThread(long j, TimeUnit timeUnit) {
HMSLog.i(TAG, "awaitOnAnyThread timeout:" + j + " unit:" + timeUnit.toString());
WeakReference<ApiClient> weakReference = this.api;
if (weakReference == null) {
HMSLog.e(TAG, "api is null");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
return this.result;
}
ApiClient apiClient = weakReference.get();
if (!checkApiClient(apiClient)) {
HMSLog.e(TAG, "client invalid");
setResult(CommonCode.ErrorCode.CLIENT_API_INVALID, null);
return this.result;
}
AtomicBoolean atomicBoolean = new AtomicBoolean();
if (this.isNeedReport) {
biReportEvent(0, 1);
}
this.transport.post(apiClient, new b(atomicBoolean));
try {
if (!this.countLatch.await(j, timeUnit)) {
atomicBoolean.set(true);
setResult(CommonCode.ErrorCode.EXECUTE_TIMEOUT, null);
}
} catch (InterruptedException unused) {
HMSLog.e(TAG, "awaitOnAnyThread InterruptedException");
setResult(CommonCode.ErrorCode.INTERNAL_ERROR, null);
}
return this.result;
}
public PendingResultImpl(ApiClient apiClient, String str, IMessageEntity iMessageEntity, int i) {
init(apiClient, str, iMessageEntity, getResponseType(), i);
}
}