Petal Maps v4.7.0.310001 - a.java 源代码

package com.huawei.maps.businessbase.utils.account;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import com.huawei.agconnect.AGConnectInstance;
import com.huawei.hmf.tasks.OnFailureListener;
import com.huawei.hmf.tasks.OnSuccessListener;
import com.huawei.hmf.tasks.Task;
import com.huawei.hms.common.ApiException;
import com.huawei.hms.support.api.client.Status;
import com.huawei.hms.support.api.entity.auth.Scope;
import com.huawei.hms.support.hwid.HuaweiIdAuthManager;
import com.huawei.hms.support.hwid.request.HuaweiIdAuthParams;
import com.huawei.hms.support.hwid.request.HuaweiIdAuthParamsHelper;
import com.huawei.hms.support.hwid.result.AuthHuaweiId;
import com.huawei.hms.support.hwid.service.HuaweiIdAuthService;
import com.huawei.hms.utils.HMSPackageManager;
import com.huawei.hwidauth.api.ResultCallBack;
import com.huawei.maps.app.common.remoteconfig.MapRemoteConfig;
import com.huawei.maps.businessbase.report.MapDevOpsReport;
import com.huawei.maps.businessbase.ui.BaseFragment;
import com.huawei.maps.businessbase.utils.account.OnAccountFailureListener;
import com.huawei.maps.businessbase.utils.account.a;
import com.huawei.maps.businessbase.utils.account.bean.Account;
import com.huawei.secure.android.common.intent.IntentUtils;
import com.huawei.secure.android.common.intent.SafeIntent;
import com.huawei.uikit.hwadvancednumberpicker.widget.PickerHelper;
import defpackage.ye;
import java.util.ArrayList;
import java.util.Iterator;

public class a extends AccountApi<AuthHuaweiId> {
    public HuaweiIdAuthService a;
    public HuaweiIdAuthParams b;
    public HuaweiIdAuthService c;
    public int d;
    public boolean e;

    public class C0010a implements OnSuccessListener<AuthHuaweiId> {
        public final OnAccountSuccessListener a;

        public C0010a(OnAccountSuccessListener onAccountSuccessListener) {
            this.a = onAccountSuccessListener;
        }

        public void onSuccess(AuthHuaweiId authHuaweiId) {
            OnAccountSuccessListener onAccountSuccessListener = this.a;
            if (onAccountSuccessListener != null) {
                onAccountSuccessListener.onSuccess(a.this.mAccount);
            }
        }
    }

    public static final class b {
        public static final a a = new a();
    }

    public static a g() {
        return b.a;
    }

    public static void l(OnAccountFailureListener onAccountFailureListener, Exception exc) {
        if (onAccountFailureListener != null) {
            onAccountFailureListener.onFailure(exc);
        }
    }

    public final void d(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        addOnSuccessListener(onAccountSuccessListener);
        addOnFailureListener(onAccountFailureListener);
    }

    public final boolean e() {
        if (this.a == null) {
            h();
        }
        return this.a == null;
    }

    @Override
    public Account dataTransform(AuthHuaweiId authHuaweiId) {
        Account account = new Account();
        account.setUid(authHuaweiId.getUid());
        account.setCountryCode(authHuaweiId.getCountryCode());
        account.setAccessToken(authHuaweiId.getAccessToken());
        account.setAgeRangeFlag(authHuaweiId.getAgeRangeFlag());
        account.setUnionId(authHuaweiId.getUnionId());
        account.setDisplayName(authHuaweiId.getDisplayName());
        account.setAvatarUriString(authHuaweiId.getAvatarUriString());
        account.setServiceCountryCode(authHuaweiId.getServiceCountryCode());
        return account;
    }

    @Override
    public Intent getAccountIntent() {
        if (e()) {
            return null;
        }
        return this.a.getSignInIntent();
    }

    @Override
    public Task<AuthHuaweiId> getAuthTask(Intent intent) {
        return HuaweiIdAuthManager.parseAuthResultFromIntent(intent);
    }

    public final void h() {
        if (o41.c() == null) {
            hm4.p("AccountApi", "initAuthManager fail");
            return;
        }
        ArrayList arrayList = new ArrayList();
        Scope scope = new Scope("https://www.huawei.com/auth/account/country");
        Scope scope2 = new Scope("https://www.huawei.com/auth/account/age.range");
        arrayList.add(scope);
        arrayList.add(scope2);
        if (this.a == null) {
            this.b = new HuaweiIdAuthParamsHelper(HuaweiIdAuthParams.DEFAULT_AUTH_REQUEST_PARAM).setProfile().setAccessToken().setScopeList(arrayList).setUid().setAuthorizationCode().createParams();
            this.a = HuaweiIdAuthManager.getService(o41.c(), this.b);
        }
        if (this.c == null) {
            this.c = HuaweiIdAuthManager.getService(o41.c(), new HuaweiIdAuthParamsHelper(HuaweiIdAuthParams.DEFAULT_AUTH_REQUEST_PARAM).setProfile().setAccessToken().setScopeList(arrayList).setUid().createParams());
        }
    }

    public final boolean i() {
        return this.mAccount == null;
    }

    public final void j(AuthHuaweiId authHuaweiId) {
        ye yeVar = ye.a;
        if (yeVar.w()) {
            yeVar.a("setUid start success=" + System.currentTimeMillis() + ",");
        }
        this.e = false;
        if (authHuaweiId != null) {
            if (yeVar.w()) {
                yeVar.a("onSignIn start" + System.currentTimeMillis() + ",");
            }
            onSignIn(dataTransform(authHuaweiId));
            if (yeVar.w()) {
                yeVar.a("onSignIn end" + System.currentTimeMillis() + ",");
            }
            this.lastRefreshTime = System.currentTimeMillis();
            this.mRefreshHandler.a();
        }
        if (!tha.b(this.mOnSuccessListeners)) {
            hm4.p("AccountApi", "setUid ---> onSuccess ---> mOnSuccessListeners:" + this.mOnSuccessListeners.size());
            Iterator<OnAccountSuccessListener> it = this.mOnSuccessListeners.iterator();
            while (it.hasNext()) {
                it.next().onSuccess(this.mAccount);
            }
        }
        removeAllListener();
        ye yeVar2 = ye.a;
        if (yeVar2.w()) {
            yeVar2.a("setUid end success=" + System.currentTimeMillis() + ",");
            yeVar2.p0(true);
        }
        this.d = 0;
        hm4.p("AccountApi", "setUid --->isSilentSignInIng end:" + this.e);
    }

    public final void k(Task task, Exception exc) {
        if (exc instanceof ApiException) {
            int statusCode = ((ApiException) exc).getStatusCode();
            hm4.p("AccountApi", "account statusCode = " + statusCode);
            if (statusCode == 2001 || statusCode == 2002) {
                signOut();
            }
            MapDevOpsReport.b("map_startup").U0("exception_process").k0(MapDevOpsReport.SDKCode.ACCOUNT).J0().h1(statusCode + PickerHelper.STRING_DRAW_END).l0(exc.getMessage()).m1().e();
            int i = this.d;
            if (i < 3 && (statusCode == 2005 || statusCode == 2007 || statusCode == 2009)) {
                this.d = i + 1;
                hm4.p("AccountApi", "retry count = " + this.d);
                this.e = false;
                p(task);
                return;
            }
        }
        hm4.p("AccountApi", "setUid ---> onFailure e:" + exc.getMessage());
        this.e = false;
        this.mAccount = null;
        if (!tha.b(this.mOnFailureListeners)) {
            hm4.p("AccountApi", "setUid ---> onFailure ---> mOnFailureListeners:" + this.mOnFailureListeners.size());
            Iterator<OnAccountFailureListener> it = this.mOnFailureListeners.iterator();
            while (it.hasNext()) {
                it.next().onFailure(exc);
            }
        }
        removeAllListener();
        ye yeVar = ye.a;
        if (yeVar.w()) {
            yeVar.a("setUid end failure=" + System.currentTimeMillis() + ",");
        }
        hm4.p("AccountApi", "setUid ---> onFailure e end:");
    }

    public final boolean m(OnAccountSuccessListener onAccountSuccessListener) {
        return n(onAccountSuccessListener, null);
    }

    public final boolean n(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        boolean booleanValue = MapRemoteConfig.g().k("login_use_cache_switch").booleanValue();
        hm4.p("AccountApi", "cacheSwitch = " + booleanValue);
        if (!booleanValue || h87.a == 1) {
            return false;
        }
        if (getAccount() != null) {
            hm4.p("AccountApi", "account is not null");
            o(onAccountSuccessListener);
        } else if (onAccountFailureListener != null) {
            onAccountFailureListener.onFailure(new ApiException(new Status(0)));
        }
        return true;
    }

    public final void o(OnAccountSuccessListener onAccountSuccessListener) {
        if (onAccountSuccessListener != null) {
            onAccountSuccessListener.onSuccess(this.mAccount);
        }
    }

    public final void p(final Task<AuthHuaweiId> task) {
        hm4.p("AccountApi", "setUid --->isSilentSignInIng start:" + this.e);
        ye yeVar = ye.a;
        if (yeVar.w()) {
            yeVar.a("setUid start=" + System.currentTimeMillis() + ",");
        }
        if (this.e) {
            return;
        }
        this.e = true;
        task.addOnSuccessListener(new OnSuccessListener() {
            public final void onSuccess(Object obj) {
                a.this.j((AuthHuaweiId) obj);
            }
        });
        task.addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                a.this.k(task, exc);
            }
        });
    }

    @Override
    public void refreshIfNeed() {
        StringBuilder sb = new StringBuilder();
        sb.append("refreshIfNeed --> need refresh:");
        sb.append(System.currentTimeMillis() - this.lastRefreshTime > AccountApi.mATRefreshInterval);
        hm4.p("AccountApi", sb.toString());
        if (System.currentTimeMillis() - this.lastRefreshTime > AccountApi.mATRefreshInterval) {
            hm4.p("AccountApi", "refreshIfNeed --> need refresh");
            onAccountRemove();
            silentSignIn();
        }
    }

    @Override
    public void silentSignIn() {
        if (m(null)) {
            hm4.p("AccountApi", "loginInterceptor silentSignIn ---> ()");
            return;
        }
        hm4.p("AccountApi", "silentSignIn ---> ()");
        if (e()) {
            return;
        }
        p(this.a.silentSignIn());
    }

    @Override
    public void silentSignInFromCache(OnAccountSuccessListener onAccountSuccessListener, final OnAccountFailureListener onAccountFailureListener) {
        hm4.p("AccountApi", "silentSignInFromCache ---> (onSuccessListener,onFailureListener)");
        if (!i()) {
            o(onAccountSuccessListener);
            hm4.p("AccountApi", "silentSignInFromCache noNeedSignIn");
            return;
        }
        HuaweiIdAuthService huaweiIdAuthService = this.c;
        if (huaweiIdAuthService == null) {
            h();
            return;
        }
        Task<AuthHuaweiId> silentSignIn = huaweiIdAuthService.silentSignIn();
        p(silentSignIn);
        silentSignIn.addOnSuccessListener(new C0010a(onAccountSuccessListener));
        silentSignIn.addOnFailureListener(new OnFailureListener() {
            public final void onFailure(Exception exc) {
                a.l(OnAccountFailureListener.this, exc);
            }
        });
    }

    @Override
    public void silentSignInWithOutId(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        if (n(onAccountSuccessListener, onAccountFailureListener)) {
            hm4.p("AccountApi", "loginInterceptor silentSignInWithOutId ---> (onSuccessListener,onFailureListener)");
            return;
        }
        hm4.p("AccountApi", "silentSignInWithOutId ---> (onSuccessListener,onFailureListener)");
        if (e()) {
            if (onAccountFailureListener != null) {
                onAccountFailureListener.onFailure(new ApiException(new Status(0)));
            }
        } else {
            Task<AuthHuaweiId> silentSignIn = this.a.silentSignIn();
            d(onAccountSuccessListener, onAccountFailureListener);
            p(silentSignIn);
        }
    }

    @Override
    public void validPassword(Activity activity, BaseFragment baseFragment, boolean z, int i, ResultCallBack<ap0> resultCallBack) {
        if (kj2.c() < 520) {
            chkUserPasswordForH5(activity, baseFragment, z, resultCallBack);
            return;
        }
        String string = AGConnectInstance.getInstance().getOptions().getString("/client/app_id");
        if (tha.a(string)) {
            return;
        }
        SafeIntent safeIntent = new SafeIntent(new Intent("android.intent.action.VIEW", Uri.parse("hwid://com.huawei.hwid/VerifyPasswordV2")));
        try {
            safeIntent.setPackage(HMSPackageManager.getInstance(o41.c()).getHMSPackageName());
            if (z) {
                safeIntent.putExtra("VERIFY_PWD_TYPE", 3);
            }
            safeIntent.putExtra("clientID", string);
            if (activity != null) {
                IntentUtils.safeStartActivityForResultStatic(activity, safeIntent, i);
            } else if (baseFragment != null) {
                baseFragment.startActivityForResult(safeIntent, i);
            }
        } catch (IllegalArgumentException unused) {
            hm4.h("AccountApi", "safeIntent.setPackage IllegalArgumentException.");
        }
    }

    public a() {
        h();
    }

    @Override
    public void silentSignIn(OnAccountSuccessListener onAccountSuccessListener) {
        if (m(onAccountSuccessListener)) {
            hm4.p("AccountApi", "loginInterceptor silentSignIn ---> (onSuccessListener) interceptor");
            return;
        }
        hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener)");
        if (!i()) {
            hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener) --> noNeedSignIn");
            o(onAccountSuccessListener);
        } else {
            if (e()) {
                return;
            }
            Task<AuthHuaweiId> silentSignIn = this.a.silentSignIn();
            d(onAccountSuccessListener, null);
            p(silentSignIn);
        }
    }

    @Override
    public void silentSignIn(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        if (n(onAccountSuccessListener, onAccountFailureListener)) {
            hm4.p("AccountApi", "loginInterceptor silentSignIn ---> (onSuccessListener,onFailureListener)");
            return;
        }
        hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener,onFailureListener)");
        if (!i()) {
            hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener,onFailureListener) --> noNeedSignIn");
            o(onAccountSuccessListener);
        } else if (e()) {
            if (onAccountFailureListener != null) {
                onAccountFailureListener.onFailure(new ApiException(new Status(0)));
            }
        } else {
            Task<AuthHuaweiId> silentSignIn = this.a.silentSignIn();
            d(onAccountSuccessListener, onAccountFailureListener);
            p(silentSignIn);
        }
    }
}