package com.huawei.hms.api;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.text.TextUtils;
import com.huawei.hms.api.Api;
import com.huawei.hms.api.HuaweiApiClient;
import com.huawei.hms.common.api.ConnectionPostProcessor;
import com.huawei.hms.common.internal.AutoLifecycleFragment;
import com.huawei.hms.core.aidl.IMessageEntity;
import com.huawei.hms.core.aidl.RequestHeader;
import com.huawei.hms.core.aidl.ResponseHeader;
import com.huawei.hms.core.aidl.c;
import com.huawei.hms.core.aidl.d;
import com.huawei.hms.support.api.PendingResultImpl;
import com.huawei.hms.support.api.ResolveResult;
import com.huawei.hms.support.api.client.ApiClient;
import com.huawei.hms.support.api.client.BundleResult;
import com.huawei.hms.support.api.client.InnerApiClient;
import com.huawei.hms.support.api.client.PendingResult;
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.core.ConnectService;
import com.huawei.hms.support.api.entity.auth.PermissionInfo;
import com.huawei.hms.support.api.entity.auth.Scope;
import com.huawei.hms.support.api.entity.core.CheckConnectInfo;
import com.huawei.hms.support.api.entity.core.CommonCode;
import com.huawei.hms.support.api.entity.core.ConnectInfo;
import com.huawei.hms.support.api.entity.core.ConnectResp;
import com.huawei.hms.support.api.entity.core.DisconnectInfo;
import com.huawei.hms.support.api.entity.core.DisconnectResp;
import com.huawei.hms.support.api.entity.core.JosGetNoticeResp;
import com.huawei.hms.support.log.HMSLog;
import com.huawei.hms.utils.Checker;
import com.huawei.hms.utils.HMSPackageManager;
import com.huawei.hms.utils.PackageManagerHelper;
import com.huawei.hms.utils.UIUtil;
import com.huawei.hms.utils.Util;
import com.huawei.updatesdk.UpdateSdkAPI;
import com.huawei.updatesdk.service.appmgr.bean.ApkUpgradeInfo;
import com.huawei.updatesdk.service.otaupdate.CheckUpdateCallBack;
import com.huawei.updatesdk.service.otaupdate.UpdateKey;
import com.xiaomi.mipush.sdk.Constants;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class HuaweiApiClientImpl extends HuaweiApiClient implements ServiceConnection, InnerApiClient {
private static final Object B = new Object();
private static final Object C = new Object();
public static final String DEFAULT_ACCOUNT = "<<default account>>";
public static final int SIGN_IN_MODE_OPTIONAL = 2;
public static final int SIGN_IN_MODE_REQUIRED = 1;
private CheckUpdateCallBack A;
private int a = -1;
private final Context b;
private final String c;
private String d;
private String e;
private volatile com.huawei.hms.core.aidl.d f;
private String g;
private WeakReference<Activity> h;
private WeakReference<Activity> i;
private boolean j = false;
private AtomicInteger k = new AtomicInteger(1);
private List<Scope> l;
private List<PermissionInfo> m;
private Map<Api<?>, Api.ApiOptions> n;
private SubAppInfo o;
private long p = 0;
private int q = 0;
private final Object r = new Object();
private final ReentrantLock s;
private final Condition t;
private ConnectionResult u;
private HuaweiApiClient.ConnectionCallbacks v;
private HuaweiApiClient.OnConnectionFailedListener w;
private Handler x;
private Handler y;
private CheckUpdatelistener z;
/* access modifiers changed from: package-private */
public class a implements CheckUpdateCallBack {
a() {
}
@Override // com.huawei.updatesdk.service.otaupdate.CheckUpdateCallBack
public void onMarketInstallInfo(Intent intent) {
if (intent != null) {
int intExtra = intent.getIntExtra(UpdateKey.MARKET_DLD_STATUS, -99);
int intExtra2 = intent.getIntExtra(UpdateKey.MARKET_INSTALL_STATE, -99);
int intExtra3 = intent.getIntExtra(UpdateKey.MARKET_INSTALL_TYPE, -99);
HMSLog.i("HuaweiApiClientImpl", "onMarketInstallInfo installState: " + intExtra2 + ",installType: " + intExtra3 + ",downloadCode: " + intExtra);
}
}
@Override // com.huawei.updatesdk.service.otaupdate.CheckUpdateCallBack
public void onMarketStoreError(int i) {
HMSLog.e("HuaweiApiClientImpl", "onMarketStoreError responseCode: " + i);
}
@Override // com.huawei.updatesdk.service.otaupdate.CheckUpdateCallBack
public void onUpdateInfo(Intent intent) {
if (intent != null && HuaweiApiClientImpl.this.z != null) {
try {
int intExtra = intent.getIntExtra(UpdateKey.STATUS, -99);
int intExtra2 = intent.getIntExtra(UpdateKey.FAIL_CODE, -99);
boolean booleanExtra = intent.getBooleanExtra(UpdateKey.MUST_UPDATE, false);
HMSLog.i("HuaweiApiClientImpl", "onUpdateInfo status: " + intExtra + ",failcause: " + intExtra2 + ",isExit: " + booleanExtra);
if (intExtra == 7) {
ApkUpgradeInfo apkUpgradeInfo = (ApkUpgradeInfo) intent.getSerializableExtra(UpdateKey.INFO);
if (apkUpgradeInfo != null) {
HMSLog.i("HuaweiApiClientImpl", "onUpdateInfo: " + apkUpgradeInfo.toString());
}
HuaweiApiClientImpl.this.z.onResult(1);
} else if (intExtra == 3) {
HuaweiApiClientImpl.this.z.onResult(0);
} else {
HuaweiApiClientImpl.this.z.onResult(-1);
}
HuaweiApiClientImpl.this.z = null;
} catch (Exception e) {
HMSLog.e("HuaweiApiClientImpl", "intent has some error" + e.getMessage());
HuaweiApiClientImpl.this.z.onResult(-1);
}
}
}
@Override // com.huawei.updatesdk.service.otaupdate.CheckUpdateCallBack
public void onUpdateStoreError(int i) {
HMSLog.e("HuaweiApiClientImpl", "onUpdateStoreError responseCode: " + i);
}
}
/* access modifiers changed from: package-private */
public class b implements Handler.Callback {
b() {
}
public boolean handleMessage(Message message) {
if (message == null || message.what != 2) {
return false;
}
HMSLog.e("HuaweiApiClientImpl", "In connect, bind core service time out");
if (HuaweiApiClientImpl.this.k.get() == 5) {
HuaweiApiClientImpl.this.c((HuaweiApiClientImpl) 1);
HuaweiApiClientImpl.this.b();
}
return true;
}
}
/* access modifiers changed from: package-private */
public class c implements Handler.Callback {
c() {
}
public boolean handleMessage(Message message) {
if (message == null || message.what != 3) {
return false;
}
HMSLog.e("HuaweiApiClientImpl", "In connect, process time out");
if (HuaweiApiClientImpl.this.k.get() == 2) {
HuaweiApiClientImpl.this.c((HuaweiApiClientImpl) 1);
HuaweiApiClientImpl.this.b();
}
return true;
}
}
class d extends c.a {
final /* synthetic */ ResultCallback a;
d(HuaweiApiClientImpl huaweiApiClientImpl, ResultCallback resultCallback) {
this.a = resultCallback;
}
@Override // com.huawei.hms.core.aidl.c
public void call(com.huawei.hms.core.aidl.b bVar) {
if (bVar != null) {
com.huawei.hms.core.aidl.e a2 = com.huawei.hms.core.aidl.a.a(bVar.c());
ResponseHeader responseHeader = new ResponseHeader();
a2.a(bVar.b, responseHeader);
BundleResult bundleResult = new BundleResult(responseHeader.getStatusCode(), bVar.a());
HMSLog.i("HuaweiApiClientImpl", "Exit asyncRequest onResult");
this.a.onResult(bundleResult);
return;
}
HMSLog.i("HuaweiApiClientImpl", "Exit asyncRequest onResult -1");
this.a.onResult(new BundleResult(-1, null));
}
}
static class e extends PendingResultImpl<Status, IMessageEntity> {
public e(ApiClient apiClient, String str, IMessageEntity iMessageEntity) {
super(apiClient, str, iMessageEntity);
}
@Override // com.huawei.hms.support.api.PendingResultImpl
public Status onComplete(IMessageEntity iMessageEntity) {
return new Status(0);
}
}
/* access modifiers changed from: private */
public class f implements ResultCallback<ResolveResult<ConnectResp>> {
/* access modifiers changed from: package-private */
public class a implements Runnable {
final /* synthetic */ ResolveResult a;
a(ResolveResult resolveResult) {
this.a = resolveResult;
}
public void run() {
HuaweiApiClientImpl.this.a((HuaweiApiClientImpl) this.a);
}
}
private f() {
}
/* renamed from: a */
public void onResult(ResolveResult<ConnectResp> resolveResult) {
new Handler(Looper.getMainLooper()).post(new a(resolveResult));
}
/* synthetic */ f(HuaweiApiClientImpl huaweiApiClientImpl, a aVar) {
this();
}
}
/* access modifiers changed from: private */
public class g implements ResultCallback<ResolveResult<DisconnectResp>> {
/* access modifiers changed from: package-private */
public class a implements Runnable {
final /* synthetic */ ResolveResult a;
a(ResolveResult resolveResult) {
this.a = resolveResult;
}
public void run() {
HuaweiApiClientImpl.this.b((HuaweiApiClientImpl) this.a);
}
}
private g() {
}
/* renamed from: a */
public void onResult(ResolveResult<DisconnectResp> resolveResult) {
new Handler(Looper.getMainLooper()).post(new a(resolveResult));
}
/* synthetic */ g(HuaweiApiClientImpl huaweiApiClientImpl, a aVar) {
this();
}
}
/* access modifiers changed from: private */
public class h implements ResultCallback<ResolveResult<JosGetNoticeResp>> {
private h() {
}
/* renamed from: a */
public void onResult(ResolveResult<JosGetNoticeResp> resolveResult) {
JosGetNoticeResp value;
Intent noticeIntent;
if (resolveResult != null && resolveResult.getStatus().isSuccess() && (noticeIntent = (value = resolveResult.getValue()).getNoticeIntent()) != null && value.getStatusCode() == 0) {
HMSLog.i("HuaweiApiClientImpl", "get notice has intent.");
Activity validActivity = Util.getValidActivity((Activity) HuaweiApiClientImpl.this.h.get(), HuaweiApiClientImpl.this.getTopActivity());
if (validActivity == null) {
HMSLog.e("HuaweiApiClientImpl", "showNotice no valid activity!");
return;
}
HuaweiApiClientImpl.this.j = true;
validActivity.startActivity(noticeIntent);
}
}
/* synthetic */ h(HuaweiApiClientImpl huaweiApiClientImpl, a aVar) {
this();
}
}
public HuaweiApiClientImpl(Context context) {
ReentrantLock reentrantLock = new ReentrantLock();
this.s = reentrantLock;
this.t = reentrantLock.newCondition();
this.x = null;
this.y = null;
this.z = null;
this.b = context;
String appId = Util.getAppId(context);
this.c = appId;
this.d = appId;
this.e = Util.getCpId(context);
}
private int e() {
int hmsVersion = Util.getHmsVersion(this.b);
if (hmsVersion != 0 && hmsVersion >= 20503000) {
return hmsVersion;
}
int f2 = f();
if (h()) {
if (f2 < 20503000) {
return 20503000;
}
return f2;
} else if (f2 < 20600000) {
return 20600000;
} else {
return f2;
}
}
private int f() {
Integer num;
int intValue;
Map<Api<?>, Api.ApiOptions> apiMap = getApiMap();
int i2 = 0;
if (apiMap == null) {
return 0;
}
for (Api<?> api : apiMap.keySet()) {
String apiName = api.getApiName();
if (!TextUtils.isEmpty(apiName) && (num = HuaweiApiAvailability.getApiMap().get(apiName)) != null && (intValue = num.intValue()) > i2) {
i2 = intValue;
}
}
return i2;
}
private void g() {
this.A = new a();
}
private boolean h() {
Map<Api<?>, Api.ApiOptions> map = this.n;
if (map == null) {
return false;
}
for (Api<?> api : map.keySet()) {
if (HuaweiApiAvailability.HMS_API_NAME_GAME.equals(api.getApiName())) {
return true;
}
}
return false;
}
private void i() {
Handler handler = this.x;
if (handler != null) {
handler.removeMessages(2);
} else {
this.x = new Handler(Looper.getMainLooper(), new b());
}
this.x.sendEmptyMessageDelayed(2, 5000);
}
private void j() {
synchronized (C) {
if (this.y != null) {
this.y.removeMessages(3);
} else {
this.y = new Handler(Looper.getMainLooper(), new c());
}
boolean sendEmptyMessageDelayed = this.y.sendEmptyMessageDelayed(3, 3000);
HMSLog.d("HuaweiApiClientImpl", "sendEmptyMessageDelayed for onConnectionResult 3 seconds. the result is : " + sendEmptyMessageDelayed);
}
}
private void k() {
HMSLog.i("HuaweiApiClientImpl", "Enter sendConnectApiServceRequest.");
ConnectService.connect(this, c()).setResultCallback(new f(this, null));
}
private void l() {
ConnectService.disconnect(this, d()).setResultCallback(new g(this, null));
}
private void m() {
HMSLog.i("HuaweiApiClientImpl", "Enter sendForceConnectApiServceRequest.");
ConnectService.forceConnect(this, c()).setResultCallback(new f(this, null));
}
private void n() {
if (this.j) {
HMSLog.i("HuaweiApiClientImpl", "Connect notice has been shown.");
} else if (HuaweiApiAvailability.getInstance().isHuaweiMobileNoticeAvailable(this.b) == 0) {
ConnectService.getNotice(this, 0, "5.3.0.304").setResultCallback(new h(this, null));
}
}
private void o() {
Util.unBindServiceCatchException(this.b, this);
this.f = null;
}
public int asyncRequest(Bundle bundle, String str, int i2, ResultCallback<BundleResult> resultCallback) {
HMSLog.i("HuaweiApiClientImpl", "Enter asyncRequest.");
if (resultCallback == null || str == null || bundle == null) {
HMSLog.e("HuaweiApiClientImpl", "arguments is invalid.");
return CommonCode.ErrorCode.ARGUMENTS_INVALID;
} else if (!innerIsConnected()) {
HMSLog.e("HuaweiApiClientImpl", "client is unConnect.");
return CommonCode.ErrorCode.CLIENT_API_INVALID;
} else {
com.huawei.hms.core.aidl.b bVar = new com.huawei.hms.core.aidl.b(str, i2);
com.huawei.hms.core.aidl.e a2 = com.huawei.hms.core.aidl.a.a(bVar.c());
bVar.a(bundle);
RequestHeader requestHeader = new RequestHeader(getAppID(), getPackageName(), 50300304, getSessionId());
requestHeader.setApiNameList(getApiNameList());
bVar.b = a2.a(requestHeader, new Bundle());
try {
getService().a(bVar, new d(this, resultCallback));
return 0;
} catch (RemoteException e2) {
HMSLog.e("HuaweiApiClientImpl", "remote exception:" + e2.getMessage());
return CommonCode.ErrorCode.INTERNAL_ERROR;
}
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void checkUpdate(Activity activity, CheckUpdatelistener checkUpdatelistener) {
if (Util.isAvailableLibExist(this.b)) {
HMSLog.i("HuaweiApiClientImpl", "Enter checkUpdate");
if (checkUpdatelistener == null) {
HMSLog.e("HuaweiApiClientImpl", "listener is null!");
} else if (activity == null || activity.isFinishing()) {
HMSLog.e("HuaweiApiClientImpl", "checkUpdate, activity is illegal: " + activity);
checkUpdatelistener.onResult(-1);
} else {
this.z = checkUpdatelistener;
if (this.A == null) {
g();
}
UpdateSdkAPI.checkClientOTAUpdate(activity, this.A, true, 0, true);
}
} else {
HMSLog.i("HuaweiApiClientImpl", "available lib does not exist.");
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void connect(Activity activity) {
HMSLog.i("HuaweiApiClientImpl", "====== HMSSDK version: 50300304 ======");
int i2 = this.k.get();
HMSLog.i("HuaweiApiClientImpl", "Enter connect, Connection Status: " + i2);
if (i2 != 3 && i2 != 5 && i2 != 2 && i2 != 4) {
if (activity != null) {
this.h = new WeakReference<>(activity);
this.i = new WeakReference<>(activity);
}
this.d = TextUtils.isEmpty(this.c) ? Util.getAppId(this.b) : this.c;
int e2 = e();
HMSLog.i("HuaweiApiClientImpl", "connect minVersion:" + e2);
HuaweiApiAvailability.setServicesVersionCode(e2);
int isHuaweiMobileServicesAvailable = HuaweiMobileServicesUtil.isHuaweiMobileServicesAvailable(this.b, e2);
HMSLog.i("HuaweiApiClientImpl", "In connect, isHuaweiMobileServicesAvailable result: " + isHuaweiMobileServicesAvailable);
this.q = HMSPackageManager.getInstance(this.b).getHmsVersionCode();
if (isHuaweiMobileServicesAvailable == 0) {
c(5);
if (this.f == null) {
a();
return;
}
c(2);
k();
j();
} else if (this.w != null) {
b(isHuaweiMobileServicesAvailable);
}
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void connectForeground() {
HMSLog.i("HuaweiApiClientImpl", "====== HMSSDK version: 50300304 ======");
int i2 = this.k.get();
HMSLog.i("HuaweiApiClientImpl", "Enter forceConnect, Connection Status: " + i2);
if (i2 != 3 && i2 != 5 && i2 != 2 && i2 != 4) {
this.d = TextUtils.isEmpty(this.c) ? Util.getAppId(this.b) : this.c;
m();
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void disableLifeCycleManagement(Activity activity) {
if (this.a >= 0) {
AutoLifecycleFragment instance = AutoLifecycleFragment.getInstance(activity);
if (instance != null) {
instance.stopAutoManage(this.a);
return;
}
return;
}
throw new IllegalStateException("disableLifeCycleManagement failed");
}
@Override // com.huawei.hms.api.HuaweiApiClient
public PendingResult<Status> discardAndReconnect() {
return new e(this, null, null);
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void disconnect() {
int i2 = this.k.get();
HMSLog.i("HuaweiApiClientImpl", "Enter disconnect, Connection Status: " + i2);
if (i2 == 2) {
c(4);
} else if (i2 == 3) {
c(4);
l();
} else if (i2 == 5) {
a(2);
c(4);
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public Map<Api<?>, Api.ApiOptions> getApiMap() {
return this.n;
}
@Override // com.huawei.hms.support.api.client.AidlApiClient
public List<String> getApiNameList() {
ArrayList arrayList = new ArrayList();
Map<Api<?>, Api.ApiOptions> map = this.n;
if (map != null) {
for (Api<?> api : map.keySet()) {
arrayList.add(api.getApiName());
}
}
return arrayList;
}
@Override // com.huawei.hms.support.api.client.ApiClient
public String getAppID() {
return this.d;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public ConnectionResult getConnectionResult(Api<?> api) {
if (isConnected()) {
this.u = null;
return new ConnectionResult(0, (PendingIntent) null);
}
ConnectionResult connectionResult = this.u;
if (connectionResult != null) {
return connectionResult;
}
return new ConnectionResult(13, (PendingIntent) null);
}
@Override // com.huawei.hms.support.api.client.ApiClient
public Context getContext() {
return this.b;
}
@Override // com.huawei.hms.support.api.client.ApiClient
public String getCpID() {
return this.e;
}
@Override // com.huawei.hms.support.api.client.ApiClient
public String getPackageName() {
return this.b.getPackageName();
}
@Override // com.huawei.hms.api.HuaweiApiClient
public List<PermissionInfo> getPermissionInfos() {
return this.m;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public List<Scope> getScopes() {
return this.l;
}
@Override // com.huawei.hms.support.api.client.AidlApiClient
public com.huawei.hms.core.aidl.d getService() {
return this.f;
}
@Override // com.huawei.hms.support.api.client.ApiClient
public String getSessionId() {
return this.g;
}
@Override // com.huawei.hms.support.api.client.ApiClient
public final SubAppInfo getSubAppInfo() {
return this.o;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public Activity getTopActivity() {
WeakReference<Activity> weakReference = this.i;
if (weakReference == null) {
return null;
}
return weakReference.get();
}
@Override // com.huawei.hms.support.api.client.ApiClient
public String getTransportName() {
return IPCTransport.class.getName();
}
@Override // com.huawei.hms.api.HuaweiApiClient
public boolean hasConnectedApi(Api<?> api) {
return isConnected();
}
@Override // com.huawei.hms.api.HuaweiApiClient
public boolean hasConnectionFailureListener(HuaweiApiClient.OnConnectionFailedListener onConnectionFailedListener) {
Checker.checkNonNull(onConnectionFailedListener, "onConnectionFailedListener should not be null");
synchronized (this.r) {
if (this.w == onConnectionFailedListener) {
return true;
}
return false;
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public boolean hasConnectionSuccessListener(HuaweiApiClient.ConnectionCallbacks connectionCallbacks) {
Checker.checkNonNull(connectionCallbacks, "connectionCallbacksListener should not be null");
synchronized (this.r) {
if (this.v == connectionCallbacks) {
return true;
}
return false;
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public ConnectionResult holdUpConnect() {
if (Looper.myLooper() != Looper.getMainLooper()) {
this.s.lock();
try {
connect((Activity) null);
while (isConnecting()) {
try {
this.t.await();
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
return new ConnectionResult(15, (PendingIntent) null);
}
}
if (isConnected()) {
this.u = null;
ConnectionResult connectionResult = new ConnectionResult(0, (PendingIntent) null);
this.s.unlock();
return connectionResult;
} else if (this.u != null) {
ConnectionResult connectionResult2 = this.u;
this.s.unlock();
return connectionResult2;
} else {
ConnectionResult connectionResult3 = new ConnectionResult(13, (PendingIntent) null);
this.s.unlock();
return connectionResult3;
}
} finally {
this.s.unlock();
}
} else {
throw new IllegalStateException("blockingConnect must not be called on the UI thread");
}
}
@Override // com.huawei.hms.support.api.client.InnerApiClient
public boolean innerIsConnected() {
return this.k.get() == 3 || this.k.get() == 4;
}
@Override // com.huawei.hms.api.HuaweiApiClient, com.huawei.hms.support.api.client.ApiClient
public boolean isConnected() {
if (this.q == 0) {
this.q = HMSPackageManager.getInstance(this.b).getHmsVersionCode();
}
if (this.q >= 20504000) {
return innerIsConnected();
}
long currentTimeMillis = System.currentTimeMillis() - this.p;
if (currentTimeMillis > 0 && currentTimeMillis < Constants.ASSEMBLE_PUSH_NETWORK_INTERVAL) {
return innerIsConnected();
}
if (!innerIsConnected()) {
return false;
}
Status status = ConnectService.checkconnect(this, new CheckConnectInfo()).awaitOnAnyThread(2000, TimeUnit.MILLISECONDS).getStatus();
if (status.isSuccess()) {
this.p = System.currentTimeMillis();
return true;
}
int statusCode = status.getStatusCode();
HMSLog.i("HuaweiApiClientImpl", "isConnected is false, statuscode:" + statusCode);
if (statusCode == 907135004) {
return false;
}
o();
c(1);
this.p = System.currentTimeMillis();
return false;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public boolean isConnecting() {
int i2 = this.k.get();
return i2 == 2 || i2 == 5;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void onPause(Activity activity) {
HMSLog.i("HuaweiApiClientImpl", "onPause");
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void onResume(Activity activity) {
if (activity != null) {
HMSLog.i("HuaweiApiClientImpl", "onResume");
this.i = new WeakReference<>(activity);
}
}
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
HMSLog.i("HuaweiApiClientImpl", "Enter onServiceConnected.");
a(2);
this.f = d.a.a(iBinder);
if (this.f == null) {
HMSLog.e("HuaweiApiClientImpl", "In onServiceConnected, mCoreService must not be null.");
o();
c(1);
if (this.w != null) {
PendingIntent pendingIntent = null;
WeakReference<Activity> weakReference = this.h;
if (!(weakReference == null || weakReference.get() == null)) {
pendingIntent = HuaweiApiAvailability.getInstance().getResolveErrorPendingIntent(this.h.get(), 10);
}
ConnectionResult connectionResult = new ConnectionResult(10, pendingIntent);
this.w.onConnectionFailed(connectionResult);
this.u = connectionResult;
}
} else if (this.k.get() == 5) {
c(2);
k();
j();
} else if (this.k.get() != 3) {
o();
}
}
public void onServiceDisconnected(ComponentName componentName) {
HMSLog.i("HuaweiApiClientImpl", "Enter onServiceDisconnected.");
this.f = null;
c(1);
HuaweiApiClient.ConnectionCallbacks connectionCallbacks = this.v;
if (connectionCallbacks != null) {
connectionCallbacks.onConnectionSuspended(1);
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void print(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void reconnect() {
disconnect();
connect((Activity) null);
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void removeConnectionFailureListener(HuaweiApiClient.OnConnectionFailedListener onConnectionFailedListener) {
Checker.checkNonNull(onConnectionFailedListener, "onConnectionFailedListener should not be null");
synchronized (this.r) {
if (this.w != onConnectionFailedListener) {
HMSLog.w("HuaweiApiClientImpl", "unregisterConnectionFailedListener: this onConnectionFailedListener has not been registered");
} else {
this.w = null;
}
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void removeConnectionSuccessListener(HuaweiApiClient.ConnectionCallbacks connectionCallbacks) {
Checker.checkNonNull(connectionCallbacks, "connectionCallbacksListener should not be null");
synchronized (this.r) {
if (this.v != connectionCallbacks) {
HMSLog.w("HuaweiApiClientImpl", "unregisterConnectionCallback: this connectionCallbacksListener has not been registered");
} else {
this.v = null;
}
}
}
public void setApiMap(Map<Api<?>, Api.ApiOptions> map) {
this.n = map;
}
/* access modifiers changed from: protected */
public void setAutoLifecycleClientId(int i2) {
this.a = i2;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void setConnectionCallbacks(HuaweiApiClient.ConnectionCallbacks connectionCallbacks) {
this.v = connectionCallbacks;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void setConnectionFailedListener(HuaweiApiClient.OnConnectionFailedListener onConnectionFailedListener) {
this.w = onConnectionFailedListener;
}
public void setHasShowNotice(boolean z2) {
this.j = z2;
}
public void setPermissionInfos(List<PermissionInfo> list) {
this.m = list;
}
public void setScopes(List<Scope> list) {
this.l = list;
}
@Override // com.huawei.hms.api.HuaweiApiClient
public boolean setSubAppInfo(SubAppInfo subAppInfo) {
HMSLog.i("HuaweiApiClientImpl", "Enter setSubAppInfo");
if (subAppInfo == null) {
HMSLog.e("HuaweiApiClientImpl", "subAppInfo is null");
return false;
}
String subAppID = subAppInfo.getSubAppID();
if (TextUtils.isEmpty(subAppID)) {
HMSLog.e("HuaweiApiClientImpl", "subAppId is empty");
return false;
}
if (subAppID.equals(TextUtils.isEmpty(this.c) ? Util.getAppId(this.b) : this.c)) {
HMSLog.e("HuaweiApiClientImpl", "subAppId is host appid");
return false;
}
this.o = new SubAppInfo(subAppInfo);
return true;
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void c(int i2) {
this.k.set(i2);
if (i2 == 1 || i2 == 3 || i2 == 2) {
this.s.lock();
try {
this.t.signalAll();
} finally {
this.s.unlock();
}
}
}
private DisconnectInfo d() {
ArrayList arrayList = new ArrayList();
Map<Api<?>, Api.ApiOptions> map = this.n;
if (map != null) {
for (Api<?> api : map.keySet()) {
arrayList.add(api.getApiName());
}
}
return new DisconnectInfo(this.l, arrayList);
}
private void b(int i2) {
PendingIntent pendingIntent;
WeakReference<Activity> weakReference = this.h;
if (weakReference == null || weakReference.get() == null) {
pendingIntent = null;
} else {
pendingIntent = HuaweiApiAvailability.getInstance().getResolveErrorPendingIntent(this.h.get(), i2);
HMSLog.i("HuaweiApiClientImpl", "connect 2.0 fail: " + i2);
}
ConnectionResult connectionResult = new ConnectionResult(i2, pendingIntent);
this.w.onConnectionFailed(connectionResult);
this.u = connectionResult;
}
private void a() {
Intent intent = new Intent("com.huawei.hms.core.aidlservice");
HMSPackageManager.getInstance(this.b).refresh();
intent.setPackage(HMSPackageManager.getInstance(this.b).getHMSPackageName());
synchronized (B) {
if (this.b.bindService(intent, this, 1)) {
i();
return;
}
c(1);
HMSLog.e("HuaweiApiClientImpl", "In connect, bind core service fail");
b();
}
}
private ConnectInfo c() {
String packageSignature = new PackageManagerHelper(this.b).getPackageSignature(this.b.getPackageName());
if (packageSignature == null) {
packageSignature = "";
}
SubAppInfo subAppInfo = this.o;
return new ConnectInfo(getApiNameList(), this.l, packageSignature, subAppInfo == null ? null : subAppInfo.getSubAppID());
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void b() {
o();
if (this.w != null) {
int i2 = UIUtil.isBackground(this.b) ? 7 : 6;
PendingIntent pendingIntent = null;
WeakReference<Activity> weakReference = this.h;
if (!(weakReference == null || weakReference.get() == null)) {
pendingIntent = HuaweiApiAvailability.getInstance().getResolveErrorPendingIntent(this.h.get(), i2);
}
ConnectionResult connectionResult = new ConnectionResult(i2, pendingIntent);
this.w.onConnectionFailed(connectionResult);
this.u = connectionResult;
}
}
private void a(int i2) {
if (i2 == 2) {
synchronized (B) {
if (this.x != null) {
this.x.removeMessages(i2);
this.x = null;
}
}
}
if (i2 == 3) {
synchronized (C) {
if (this.y != null) {
this.y.removeMessages(i2);
this.y = null;
}
}
}
synchronized (B) {
if (this.x != null) {
this.x.removeMessages(2);
this.x = null;
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void b(ResolveResult<DisconnectResp> resolveResult) {
HMSLog.i("HuaweiApiClientImpl", "Enter onDisconnectionResult, disconnect from server result: " + resolveResult.getStatus().getStatusCode());
o();
c(1);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void a(ResolveResult<ConnectResp> resolveResult) {
HMSLog.i("HuaweiApiClientImpl", "Enter onConnectionResult");
if (this.f == null || this.k.get() != 2) {
HMSLog.e("HuaweiApiClientImpl", "Invalid onConnectionResult");
return;
}
a(3);
ConnectResp value = resolveResult.getValue();
if (value != null) {
this.g = value.sessionId;
}
SubAppInfo subAppInfo = this.o;
PendingIntent pendingIntent = null;
String subAppID = subAppInfo == null ? null : subAppInfo.getSubAppID();
if (!TextUtils.isEmpty(subAppID)) {
this.d = subAppID;
}
int statusCode = resolveResult.getStatus().getStatusCode();
HMSLog.i("HuaweiApiClientImpl", "Enter onConnectionResult, connect to server result: " + statusCode);
if (Status.SUCCESS.equals(resolveResult.getStatus())) {
if (resolveResult.getValue() != null) {
ProtocolNegotiate.getInstance().negotiate(resolveResult.getValue().protocolVersion);
}
c(3);
this.u = null;
HuaweiApiClient.ConnectionCallbacks connectionCallbacks = this.v;
if (connectionCallbacks != null) {
connectionCallbacks.onConnected();
}
if (this.h != null) {
n();
}
for (Map.Entry<Api<?>, Api.ApiOptions> entry : getApiMap().entrySet()) {
if (entry.getKey().getmConnetctPostList() != null && !entry.getKey().getmConnetctPostList().isEmpty()) {
HMSLog.i("HuaweiApiClientImpl", "Enter onConnectionResult, get the ConnetctPostList ");
for (ConnectionPostProcessor connectionPostProcessor : entry.getKey().getmConnetctPostList()) {
HMSLog.i("HuaweiApiClientImpl", "Enter onConnectionResult, processor.run");
connectionPostProcessor.run(this, this.h);
}
}
}
} else if (resolveResult.getStatus() == null || resolveResult.getStatus().getStatusCode() != 1001) {
o();
c(1);
if (this.w != null) {
WeakReference<Activity> weakReference = this.h;
if (!(weakReference == null || weakReference.get() == null)) {
pendingIntent = HuaweiApiAvailability.getInstance().getResolveErrorPendingIntent(this.h.get(), statusCode);
}
ConnectionResult connectionResult = new ConnectionResult(statusCode, pendingIntent);
this.w.onConnectionFailed(connectionResult);
this.u = connectionResult;
}
} else {
o();
c(1);
HuaweiApiClient.ConnectionCallbacks connectionCallbacks2 = this.v;
if (connectionCallbacks2 != null) {
connectionCallbacks2.onConnectionSuspended(3);
}
}
}
@Override // com.huawei.hms.api.HuaweiApiClient
public void connect(int i2) {
connect((Activity) null);
}
@Override // com.huawei.hms.api.HuaweiApiClient
public ConnectionResult holdUpConnect(long j2, TimeUnit timeUnit) {
if (Looper.myLooper() != Looper.getMainLooper()) {
this.s.lock();
try {
connect((Activity) null);
long nanos = timeUnit.toNanos(j2);
while (isConnecting()) {
if (nanos <= 0) {
disconnect();
ConnectionResult connectionResult = new ConnectionResult(14, (PendingIntent) null);
this.s.unlock();
return connectionResult;
}
try {
nanos = this.t.awaitNanos(nanos);
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
return new ConnectionResult(15, (PendingIntent) null);
}
}
if (isConnected()) {
this.u = null;
ConnectionResult connectionResult2 = new ConnectionResult(0, (PendingIntent) null);
this.s.unlock();
return connectionResult2;
} else if (this.u != null) {
ConnectionResult connectionResult3 = this.u;
this.s.unlock();
return connectionResult3;
} else {
ConnectionResult connectionResult4 = new ConnectionResult(13, (PendingIntent) null);
this.s.unlock();
return connectionResult4;
}
} finally {
this.s.unlock();
}
} else {
throw new IllegalStateException("blockingConnect must not be called on the UI thread");
}
}
}