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

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

import android.app.Activity;
import android.content.Intent;
import androidx.annotation.NonNull;
import com.huawei.hmf.tasks.Task;
import com.huawei.hms.common.ApiException;
import com.huawei.hms.network.httpclient.RequestBody;
import com.huawei.hms.network.httpclient.Response;
import com.huawei.hms.support.api.client.Status;
import com.huawei.hms.support.api.entity.auth.Scope;
import com.huawei.hms.support.picker.AccountPickerManager;
import com.huawei.hms.support.picker.request.AccountPickerParams;
import com.huawei.hms.support.picker.request.AccountPickerParamsHelper;
import com.huawei.hms.support.picker.result.AuthAccountPicker;
import com.huawei.hms.support.picker.service.AccountPickerService;
import com.huawei.hwidauth.api.Result;
import com.huawei.hwidauth.api.ResultCallBack;
import com.huawei.maps.app.common.utils.task.TaskExecutor;
import com.huawei.maps.app.common.utils.task.TaskRunnable;
import com.huawei.maps.businessbase.R$string;
import com.huawei.maps.businessbase.database.config.MapConfigDataTools;
import com.huawei.maps.businessbase.network.DefaultObserver;
import com.huawei.maps.businessbase.network.MapApiKeyClient;
import com.huawei.maps.businessbase.network.MapHttpClient;
import com.huawei.maps.businessbase.network.MapNetUtils;
import com.huawei.maps.businessbase.network.NetworkConstant;
import com.huawei.maps.businessbase.network.ResponseData;
import com.huawei.maps.businessbase.network.converter.RequestBodyProviders;
import com.huawei.maps.businessbase.ui.BaseFragment;
import com.huawei.maps.businessbase.utils.account.b;
import com.huawei.maps.businessbase.utils.account.bean.Account;
import com.huawei.maps.businessbase.utils.account.bean.AccountInfoReq;
import com.huawei.maps.businessbase.utils.account.bean.AccountInfoResp;
import com.huawei.maps.businessbase.utils.account.bean.RefreshATReq;
import com.huawei.maps.businessbase.utils.account.bean.RefreshATResp;
import com.huawei.maps.businessbase.utils.account.service.AccountService;
import com.huawei.uikit.hwadvancednumberpicker.widget.PickerHelper;
import defpackage.m5;
import defpackage.p98;
import defpackage.sr4;
import defpackage.ws4;
import defpackage.ye;
import io.reactivex.rxjava3.core.Observable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;

public class b extends AccountApi<AuthAccountPicker> {
    public AccountPickerService a;
    public String b;
    public boolean c;
    public int d;

    public class a extends DefaultObserver<AccountInfoResp> {
        public a() {
        }

        @Override
        public void onSuccess(AccountInfoResp accountInfoResp) {
            b.this.c = false;
            if (accountInfoResp == null) {
                hm4.h("AccountApi", "response is null");
                return;
            }
            hm4.p("AccountApi", "account login success");
            p98.g().c(accountInfoResp.getRefreshToken());
            b.this.setAtRefreshInterval((accountInfoResp.getExpire() * 1000) - TimeUnit.MINUTES.toMillis(5L));
            b bVar = b.this;
            bVar.onSignIn(bVar.E(accountInfoResp.getAccountInfo(), accountInfoResp.getAccessToken()));
            b bVar2 = b.this;
            bVar2.C(bVar2.E(accountInfoResp.getAccountInfo(), accountInfoResp.getAccessToken()));
            b.this.v();
            AbstractAccountReceiveManager.getInstance().actionAccountLogin();
        }

        @Override
        public void onFail(int i, @NonNull ResponseData responseData, String str) {
            b.this.c = false;
            cz9.j(R$string.connect_failed);
            hm4.h("AccountApi", "account login failed returnCode:" + responseData.getReturnCode() + "  Message:" + responseData.getMessage());
            b.this.u(responseData, str);
        }
    }

    public class C0011b extends TaskRunnable {
        public C0011b() {
        }

        public String getClassName() {
            return "AccountApi";
        }

        public String getFunctionName() {
            return "requestRefreshATForThreadPool";
        }

        public void run() {
            b.this.z();
        }
    }

    public class c extends DefaultObserver<RefreshATResp> {
        public c() {
        }

        public final void c(String str, RefreshATResp refreshATResp) {
            Account account = (Account) og3.d(str, Account.class);
            if (account == null) {
                hm4.h("AccountApi", "account == null");
                b.this.u(refreshATResp, "account == null");
            } else {
                account.setAccessToken(refreshATResp.getAccessToken());
                b.this.onSignIn(account);
                b.this.v();
            }
        }

        public final void d(final RefreshATResp refreshATResp, final String str) {
            com.huawei.maps.app.common.utils.task.a.c(com.huawei.maps.app.common.utils.task.a.a("AccountApi", "requestObservableRefreshAT", new Runnable() {
                @Override
                public final void run() {
                    b.c.this.c(str, refreshATResp);
                }
            }));
        }

        @Override
        public void onSuccess(final RefreshATResp refreshATResp) {
            b.this.c = false;
            if (refreshATResp == null) {
                hm4.h("AccountApi", "onSuccess response is null");
                return;
            }
            hm4.p("AccountApi", "refresh AT success");
            b.this.setAtRefreshInterval((refreshATResp.getExpire() * 1000) - TimeUnit.MINUTES.toMillis(5L));
            Account account = b.this.mAccount;
            if (account == null) {
                MapConfigDataTools.r().v(MapConfigDataTools.BusinessType.ACCOUNT_INFO, new MapConfigDataTools.DbCallBackValue() {
                    @Override
                    public final void setValue(String str) {
                        b.c.this.d(refreshATResp, str);
                    }
                });
            } else {
                account.setAccessToken(refreshATResp.getAccessToken());
                b.this.v();
            }
            ye yeVar = ye.a;
            if (yeVar.w()) {
                yeVar.a("refreshAT end success=" + System.currentTimeMillis() + ",");
                yeVar.p0(true);
            }
            hm4.p("AccountApi", "requestObservableRefreshAT --->onSuccess end");
        }

        @Override
        public void onFail(int i, @NonNull ResponseData responseData, String str) {
            hm4.h("AccountApi", "refresh AT failed:" + str);
            b.this.c = false;
            if (responseData == null) {
                hm4.h("AccountApi", "onFail response is null");
                return;
            }
            hm4.h("AccountApi", "refresh AT failed code:" + responseData.getReturnCode());
            if (NetworkConstant.REFRESH_TOKEN_EXPIRED_CODE.equals(responseData.getReturnCode())) {
                AbstractAccountReceiveManager.getInstance().setInAccountCenter(true);
                AbstractAccountReceiveManager.getInstance().actionAccountRemove(false);
                b.this.u(responseData, str);
            } else if (NetworkConstant.REFRESH_TIME_STAMP_CODE.equals(responseData.getReturnCode())) {
                b.this.A(p98.g().f(responseData.getServerTimestamp()));
            } else {
                b bVar = b.this;
                if (bVar.mAccount == null) {
                    bVar.u(responseData, str);
                } else {
                    bVar.v();
                }
            }
            ye yeVar = ye.a;
            if (yeVar.w()) {
                yeVar.a("refreshAT end failure=" + System.currentTimeMillis() + ",");
            }
            hm4.p("AccountApi", "onFail end");
        }
    }

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

    private void k(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        addOnSuccessListener(onAccountSuccessListener);
        addOnFailureListener(onAccountFailureListener);
    }

    public static b n() {
        return d.a;
    }

    private boolean p() {
        return this.mAccount == null;
    }

    private void w(OnAccountSuccessListener onAccountSuccessListener) {
        if (onAccountSuccessListener != null) {
            onAccountSuccessListener.onSuccess(this.mAccount);
        }
    }

    public final void A(String str) {
        hm4.p("AccountApi", "requestRefreshAT");
        RefreshATReq refreshATReq = new RefreshATReq();
        refreshATReq.setLoginRequest(str);
        RequestBody create = RequestBodyProviders.create(NetworkConstant.CONTENT_TYPE, og3.a(refreshATReq).getBytes(NetworkConstant.UTF_8));
        StringBuilder sb = new StringBuilder();
        sb.append(MapHttpClient.getMapRootHostAddress());
        sb.append(b73.b() ? NetworkConstant.URL_REFRESH_AT_FOR_CAR : NetworkConstant.URL_REFRESH_AT);
        String sb2 = sb.toString();
        String valueOf = String.valueOf(qk9.u(o41.b()));
        String mapApiKey = MapApiKeyClient.getMapApiKey();
        if (tha.a(mapApiKey)) {
            this.c = false;
            if (this.mAccount != null) {
                v();
                return;
            }
            ResponseData responseData = new ResponseData();
            responseData.setCode(201);
            u(responseData, "apiKey is null");
            return;
        }
        if (da4.a()) {
            sb2 = b91.j + NetworkConstant.URL_REFRESH_AT;
            mapApiKey = b91.l;
        }
        y(((AccountService) MapNetUtils.getInstance().getApi(AccountService.class)).refreshAT(sr4.d(sb2, mapApiKey) + "&appClientVersion=" + valueOf, create));
    }

    public final void B() {
        com.huawei.maps.app.common.utils.task.a.b(TaskExecutor.SETTING).d(new C0011b());
    }

    public final void C(Account account) {
        account.setAccessToken(PickerHelper.STRING_DRAW_END);
        ws4 ws4Var = new ws4();
        ws4Var.e(MapConfigDataTools.BusinessType.ACCOUNT_INFO);
        ws4Var.d(og3.a(account));
        MapConfigDataTools.r().x(ws4Var);
    }

    public void D(String str) {
        if (tha.a(str)) {
            return;
        }
        this.b = str;
    }

    public final Account E(AccountInfoResp.AccountInfo accountInfo, String str) {
        Account account = new Account();
        account.setAccessToken(str);
        account.setDisplayName(accountInfo.getDisplayName());
        account.setAvatarUriString(accountInfo.getHeadPictureUrl());
        account.setUid(accountInfo.getUserId());
        account.setUnionId(accountInfo.getUnionId());
        account.setAccountAttr(this.d);
        try {
            account.setAgeRangeFlag(Integer.parseInt(accountInfo.getAgeGroupFlag()));
        } catch (NumberFormatException e) {
            hm4.h("AccountApi", "NumberFormatException:" + e.getMessage());
        }
        account.setCountryCode(accountInfo.getNationalCode());
        account.setServiceCountryCode(accountInfo.getSrvNationalCode());
        return account;
    }

    @Override
    public Intent getAccountIntent() {
        if (m5.i()) {
            return null;
        }
        if (this.a == null) {
            o();
        }
        AccountPickerService accountPickerService = this.a;
        if (accountPickerService == null) {
            return null;
        }
        return accountPickerService.signIn();
    }

    @Override
    public Task<AuthAccountPicker> getAuthTask(Intent intent) {
        Task<AuthAccountPicker> parseAuthResultFromIntent = AccountPickerManager.parseAuthResultFromIntent(intent);
        if (parseAuthResultFromIntent.isSuccessful()) {
            this.d = ((AuthAccountPicker) parseAuthResultFromIntent.getResult()).getAccountAttr();
        }
        return parseAuthResultFromIntent;
    }

    @Override
    public Account dataTransform(AuthAccountPicker authAccountPicker) {
        return null;
    }

    public String m() {
        return this.b;
    }

    public final void o() {
        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);
        try {
            this.a = AccountPickerManager.getService(o41.b().getMapAppLifeCycle().getTopActivity(), new AccountPickerParamsHelper(AccountPickerParams.DEFAULT_AUTH_REQUEST_PARAM).setAuthorizationCode().setScopeList(arrayList).setRedirecturl("hms://redirect_uri").setDeviceInfo(getDeviceInfo()).setGrsAppName(b91.a).setProfile().createParams());
        } catch (NullPointerException e) {
            hm4.h("AccountApi", "init service failed: " + e.getMessage());
        }
    }

    @Override
    public void openAccountManager(Activity activity) {
        super.openAccountManager(activity);
        if (hasLogin()) {
            jr3.i(activity, b91.a, this.mAccount.getAccessToken(), getDeviceInfo(), PickerHelper.STRING_DRAW_END, new ResultCallBack() {
                public final void onResult(Result result) {
                    b.this.t((c89) result);
                }
            });
        }
    }

    public final boolean q() {
        return !p98.g().j();
    }

    public final void r(ResponseData responseData, String str) {
        if (!tha.b(this.mOnFailureListeners)) {
            hm4.p("AccountApi", "onFail ---> mOnFailureListeners:" + this.mOnFailureListeners.size());
            Iterator<OnAccountFailureListener> it = this.mOnFailureListeners.iterator();
            while (it.hasNext()) {
                it.next().onFailure(new ApiException(new Status(responseData.getCode(), str)));
            }
        }
        removeAllListener();
    }

    @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");
            if (q()) {
                return;
            }
            B();
        }
    }

    @Override
    public void requestAccountLogin(String str, OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        if (this.c) {
            return;
        }
        hm4.p("AccountApi", "requestAccountLogin");
        this.c = true;
        k(onAccountSuccessListener, onAccountFailureListener);
        D(str);
        AccountInfoReq accountInfoReq = new AccountInfoReq();
        accountInfoReq.setAuthCode(m());
        accountInfoReq.setPublicKey(p98.g().h());
        RequestBody create = RequestBodyProviders.create(NetworkConstant.CONTENT_TYPE, og3.a(accountInfoReq).getBytes(NetworkConstant.UTF_8));
        StringBuilder sb = new StringBuilder();
        sb.append(MapHttpClient.getMapRootHostAddress());
        sb.append(b73.b() ? NetworkConstant.URL_ACCOUNT_LOGIN_FOR_CAR : NetworkConstant.URL_ACCOUNT_LOGIN);
        String sb2 = sb.toString();
        String valueOf = String.valueOf(qk9.u(o41.b()));
        String mapApiKey = MapApiKeyClient.getMapApiKey();
        if (da4.a()) {
            sb2 = b91.j + NetworkConstant.URL_ACCOUNT_LOGIN;
            mapApiKey = b91.l;
        }
        x(((AccountService) MapNetUtils.getInstance().getApi(AccountService.class)).accountLogin(sr4.d(sb2, mapApiKey) + "&appClientVersion=" + valueOf, create));
    }

    public final void s() {
        if (!tha.b(this.mOnSuccessListeners)) {
            hm4.p("AccountApi", "onSuccess ---> mOnSuccessListeners:" + this.mOnSuccessListeners.size());
            Iterator<OnAccountSuccessListener> it = this.mOnSuccessListeners.iterator();
            while (it.hasNext()) {
                it.next().onSuccess(this.mAccount);
            }
        }
        removeAllListener();
    }

    @Override
    public void signOut() {
        super.signOut();
        this.mAccount = null;
        if (this.a == null) {
            o();
        }
        AccountPickerService accountPickerService = this.a;
        if (accountPickerService != null) {
            accountPickerService.signOut();
            p98.g().d();
            MapConfigDataTools.r().j(MapConfigDataTools.BusinessType.ACCOUNT_INFO);
        }
    }

    @Override
    public void silentSignIn() {
        hm4.p("AccountApi", "silentSignIn ---> ()");
        if (q()) {
            return;
        }
        B();
    }

    @Override
    public void silentSignInFromCache(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        hm4.p("AccountApi", "silentSignInFromCache ---> (onSuccessListener,onFailureListener)");
        if (!p()) {
            w(onAccountSuccessListener);
            hm4.p("AccountApi", "silentSignInFromCache noNeedSignIn");
        } else if (onAccountFailureListener != null) {
            onAccountFailureListener.onFailure(new ApiException(new Status(0)));
        }
    }

    @Override
    public void silentSignInWithOutId(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        hm4.p("AccountApi", "silentSignInWithOutId ---> (onSuccessListener,onFailureListener)");
        if (!q()) {
            k(onAccountSuccessListener, onAccountFailureListener);
            B();
        } else if (onAccountFailureListener != null) {
            onAccountFailureListener.onFailure(new ApiException(new Status(0)));
        }
    }

    public final void t(c89 c89Var) {
        if (!c89Var.getStatus().c()) {
            hm4.p("AccountApi", "SignOutResult fail:" + c89Var.getStatus().a());
            return;
        }
        if (this.a == null) {
            o();
        }
        AccountPickerService accountPickerService = this.a;
        if (accountPickerService == null) {
            return;
        }
        accountPickerService.signOut();
        AbstractAccountReceiveManager.getInstance().setInAccountCenter(true);
        AbstractAccountReceiveManager.getInstance().actionAccountRemove(false);
        signOut();
        hm4.p("AccountApi", "SignOutResult success:" + c89Var.getStatus().a());
    }

    public final void u(final ResponseData responseData, final String str) {
        com.huawei.maps.app.common.utils.task.a.c(com.huawei.maps.app.common.utils.task.a.a("AccountApi", "loginFailure", new Runnable() {
            @Override
            public final void run() {
                b.this.r(responseData, str);
            }
        }));
    }

    public final void v() {
        this.lastRefreshTime = System.currentTimeMillis();
        this.mRefreshHandler.a();
        com.huawei.maps.app.common.utils.task.a.c(com.huawei.maps.app.common.utils.task.a.a("AccountApi", "loginSuccess", new Runnable() {
            @Override
            public final void run() {
                b.this.s();
            }
        }));
    }

    @Override
    public void validPassword(Activity activity, BaseFragment baseFragment, boolean z, int i, ResultCallBack<ap0> resultCallBack) {
        chkUserPasswordForH5(activity, baseFragment, z, resultCallBack);
    }

    public final void x(Observable<Response<AccountInfoResp>> observable) {
        MapNetUtils.getInstance().request(observable, new a());
    }

    public final void y(Observable<Response<RefreshATResp>> observable) {
        ye yeVar = ye.a;
        if (yeVar.w()) {
            yeVar.a("setUid start=" + System.currentTimeMillis() + ",");
        }
        hm4.p("AccountApi", "requestObservableRefreshAT --->start");
        MapNetUtils.getInstance().request(observable, new c());
    }

    public final void z() {
        if (this.c) {
            return;
        }
        this.c = true;
        A(p98.g().e());
    }

    public b() {
    }

    @Override
    public void silentSignIn(OnAccountSuccessListener onAccountSuccessListener) {
        hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener)");
        if (!p()) {
            hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener) --> noNeedSignIn");
            w(onAccountSuccessListener);
        } else {
            if (q()) {
                return;
            }
            k(onAccountSuccessListener, null);
            B();
        }
    }

    @Override
    public void silentSignIn(OnAccountSuccessListener onAccountSuccessListener, OnAccountFailureListener onAccountFailureListener) {
        hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener,onFailureListener)");
        if (!p()) {
            hm4.p("AccountApi", "silentSignIn ---> (onSuccessListener,onFailureListener) --> noNeedSignIn");
            w(onAccountSuccessListener);
        } else if (!q() || this.c) {
            k(onAccountSuccessListener, onAccountFailureListener);
            B();
        } else if (onAccountFailureListener != null) {
            onAccountFailureListener.onFailure(new ApiException(new Status(0)));
        }
    }
}