导航菜单
登录 注册

页面标题

页面副标题

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

正在查看： Petal Maps v4.7.0.310001 应用的 HmsProxy.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。 


package com.huawei.hiassistant.platform.base.adapter.businessadapter;

import android.app.Activity;
import android.content.ContentProviderClient;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.text.TextUtils;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.huawei.hiassistant.platform.base.northinterface.Constants;
import com.huawei.hiassistant.platform.base.report.OperationReportUtils;
import com.huawei.hiassistant.platform.base.util.HmsListener;
import com.huawei.hiassistant.platform.base.util.IAssistantConfig;
import com.huawei.hiassistant.platform.base.util.KitLog;
import com.huawei.hiassistant.platform.base.util.SecurityComponentUtils;
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.account.AccountAuthManager;
import com.huawei.hms.support.account.request.AccountAuthParams;
import com.huawei.hms.support.account.request.AccountAuthParamsHelper;
import com.huawei.hms.support.account.result.AuthAccount;
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 java.util.ArrayList;
import java.util.Optional;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

class HmsProxy implements HmsAdapter {
    private static final int ERROR_CODE_HMS_VERSION = 907135003;
    private static final long FIRST_LOGIN_TIMEOUT = 2;
    private static final long GET_UID_TIMEOUT = 5;
    private static final String HMS_API_URI = "content://com.huawei.hwid.api.provider/";
    private static final String HMS_WATCH_API_URI = "content://com.huawei.hms.contentprovider/com.huawei.hwid.api.provider/";
    private static final String HWID = "com.huawei.hwid";
    private static final String PACKAGE_NAME_HEAD = "com.huawei";
    private static final int REQUEST_API_HMS_APK_VERSION_MIN = 40000300;
    private static final String TAG = "HmsProxy";
    private HuaweiIdAuthParams cloudAuthParam;
    private volatile boolean isGettingAccessInfo;
    private HuaweiIdAuthParams localAuthParam;
    private static final Scope SCOPE_SMARTHOME_SKILL = new Scope("https://smarthome.com/auth/smarthome/skill");
    private static final Scope SCOPE_SMARTHOME_DEVICES = new Scope("https://smarthome.com/auth/smarthome/devices");
    private static final Scope SCOPE_ACCOUNT = new Scope("https://www.huawei.com/auth/account/account.flags");
    private String accessToken = "";
    private String uid = "";
    private boolean isNeedUpgrade = false;
    private final Object lockForGetAccessInfo = new Object();
    private volatile boolean isAllowRequestInfo = true;

    public HmsProxy() {
        Context appContext = IAssistantConfig.getInstance().getAppContext();
        if (appContext != null && !appContext.getPackageName().startsWith(PACKAGE_NAME_HEAD)) {
            KitLog.info(TAG, "non-huawei pkg");
            HuaweiIdAuthParams huaweiIdAuthParams = HuaweiIdAuthParams.DEFAULT_AUTH_REQUEST_PARAM;
            this.cloudAuthParam = new HuaweiIdAuthParamsHelper(huaweiIdAuthParams).setIdToken().setAccessToken().createParams();
            this.localAuthParam = new HuaweiIdAuthParamsHelper(huaweiIdAuthParams).setIdToken().createParams();
            return;
        }
        KitLog.info(TAG, "huawei pkg");
        ArrayList arrayList = new ArrayList();
        arrayList.add(SCOPE_SMARTHOME_SKILL);
        arrayList.add(SCOPE_SMARTHOME_DEVICES);
        Scope scope = SCOPE_ACCOUNT;
        arrayList.add(scope);
        HuaweiIdAuthParams huaweiIdAuthParams2 = HuaweiIdAuthParams.DEFAULT_AUTH_REQUEST_PARAM;
        this.cloudAuthParam = new HuaweiIdAuthParamsHelper(huaweiIdAuthParams2).setIdToken().setScopeList(arrayList).setAccessToken().setUid().createParams();
        ArrayList arrayList2 = new ArrayList();
        arrayList2.add(scope);
        this.localAuthParam = new HuaweiIdAuthParamsHelper(huaweiIdAuthParams2).setIdToken().setScopeList(arrayList2).setUid().createParams();
    }

    private Optional<ContentProviderClient> acquireProviderClient(Context context, Uri uri) {
        if (SecurityComponentUtils.isValidUri(uri)) {
            return Optional.ofNullable(context.getContentResolver().acquireUnstableContentProviderClient(uri));
        }
        KitLog.warn(TAG, "uri invalid");
        return Optional.empty();
    }

    public Optional<AuthHuaweiIdConversion> getConversionObject(AuthHuaweiId authHuaweiId) {
        if (authHuaweiId == null) {
            return Optional.empty();
        }
        KitLog.info(TAG, "async AT empty? " + TextUtils.isEmpty(authHuaweiId.getAccessToken()) + ", async uid empty? " + TextUtils.isEmpty(authHuaweiId.getUid()));
        AuthHuaweiIdConversion authHuaweiIdConversion = new AuthHuaweiIdConversion();
        authHuaweiIdConversion.setAccessToken(authHuaweiId.getAccessToken());
        authHuaweiIdConversion.setUid(authHuaweiId.getUid());
        return Optional.of(authHuaweiIdConversion);
    }

    private boolean isNeedUpgradeHms(Context context) {
        if (context == null) {
            KitLog.warn(TAG, "context is null");
            return false;
        }
        try {
            PackageInfo packageInfo = context.getPackageManager().getPackageInfo("com.huawei.hwid", 0);
            KitLog.debug(TAG, "pkg: {}, versionName: {}, versionCode: {}", "com.huawei.hwid", packageInfo.versionName, Integer.valueOf(packageInfo.versionCode));
            return packageInfo.versionCode < REQUEST_API_HMS_APK_VERSION_MIN;
        } catch (PackageManager.NameNotFoundException | RuntimeException unused) {
            KitLog.error(TAG, "NameNotFoundException");
            return false;
        }
    }

    public static void lambda$getAuthCode$2(HmsListener hmsListener, long j, AuthAccount authAccount) {
        KitLog.info(TAG, "getAuthCode end, isEmpty?  " + TextUtils.isEmpty(authAccount.getAuthorizationCode()));
        AuthHuaweiIdConversion authHuaweiIdConversion = new AuthHuaweiIdConversion();
        authHuaweiIdConversion.setAuthCode(authAccount.getAuthorizationCode());
        hmsListener.onSuccess(Optional.of(authHuaweiIdConversion));
        OperationReportUtils.getInstance().reportGetAuthCodeEvent(System.currentTimeMillis() - j, "0");
    }

    public static void lambda$getAuthCode$3(HmsListener hmsListener, long j, Exception exc) {
        if (exc instanceof ApiException) {
            KitLog.info(TAG, "getAuthCode failed status:" + ((ApiException) exc).getStatusCode());
            hmsListener.onFail();
        }
        OperationReportUtils.getInstance().reportGetAuthCodeEvent(System.currentTimeMillis() - j, "1");
    }

    public void lambda$requestAccessInfo$0(Context context, CountDownLatch countDownLatch, Exception exc) {
        KitLog.warn(TAG, "requestAccessInfo fail.");
        resetAccessInfoValue();
        onAuthTaskFailure(exc, context);
        countDownLatch.countDown();
    }

    public void lambda$requestAccessInfo$1(CountDownLatch countDownLatch, AuthHuaweiId authHuaweiId) {
        KitLog.info(TAG, "requestAccessInfo onSuccess");
        this.accessToken = authHuaweiId.getAccessToken();
        this.uid = authHuaweiId.getUid();
        this.isNeedUpgrade = false;
        countDownLatch.countDown();
    }

    private JsonObject makeAccessInfoJson() {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty(Constants.UserData.HUAWEI_AT, this.accessToken);
        String str = this.uid;
        if (str == null) {
            str = "";
        }
        jsonObject.addProperty("uid", str);
        if (this.isNeedUpgrade) {
            KitLog.info(TAG, "NeedUpgrade");
            jsonObject.addProperty("isNeedUpgrade", Boolean.valueOf(this.isNeedUpgrade));
            jsonObject.addProperty("packageName", "com.huawei.hwid");
        }
        return jsonObject;
    }

    private void onAuthTaskFailure(Exception exc, Context context) {
        if (exc instanceof ApiException) {
            int statusCode = ((ApiException) exc).getStatusCode();
            KitLog.info(TAG, "StatusCode is:" + statusCode);
            if (statusCode == 907135003) {
                this.isNeedUpgrade = isNeedUpgradeHms(context);
            }
        }
    }

    private JsonObject requestAccessInfo(final Context context, String str, HuaweiIdAuthParams huaweiIdAuthParams, long j) {
        HuaweiIdAuthService service;
        this.isGettingAccessInfo = true;
        if (!this.isAllowRequestInfo) {
            KitLog.info(TAG, "requestAccessInfo onfail, allowRequestInfo is false");
            resetAccessInfoValue();
            return makeAccessInfoJson();
        }
        if (context instanceof Activity) {
            KitLog.info(TAG, "requestAccessInfo with activity");
            service = HuaweiIdAuthManager.getService((Activity) context, huaweiIdAuthParams);
        } else {
            service = HuaweiIdAuthManager.getService(context, huaweiIdAuthParams);
        }
        if (service == null) {
            resetAccessInfoValue();
            return makeAccessInfoJson();
        }
        Task silentSignIn = service.silentSignIn();
        if (silentSignIn == null) {
            resetAccessInfoValue();
            return makeAccessInfoJson();
        }
        final CountDownLatch countDownLatch = new CountDownLatch(1);
        silentSignIn.addOnFailureListener(new OnFailureListener() {
            @Override
            public final void onFailure(Exception exc) {
                HmsProxy.this.lambda$requestAccessInfo$0(context, countDownLatch, exc);
            }
        }).addOnSuccessListener(new OnSuccessListener() {
            @Override
            public final void onSuccess(Object obj) {
                HmsProxy.this.lambda$requestAccessInfo$1(countDownLatch, (AuthHuaweiId) obj);
            }
        });
        try {
            countDownLatch.await(j, TimeUnit.SECONDS);
        } catch (InterruptedException unused) {
            KitLog.error(TAG, "lock error");
        }
        KitLog.info(TAG, "request type= " + str + ", AT empty? " + TextUtils.isEmpty(this.accessToken) + ", uid empty? " + TextUtils.isEmpty(this.uid));
        this.isGettingAccessInfo = false;
        return makeAccessInfoJson();
    }

    private void resetAccessInfoValue() {
        this.accessToken = "";
        this.uid = "";
        this.isNeedUpgrade = false;
    }

    public void sendFailResultCallback(HmsListener hmsListener) {
        if (hmsListener != null) {
            hmsListener.onFail();
        }
    }

    @Override
    public String getAccountUidSync(Context context) {
        KitLog.info(TAG, "getAccountUidSync start");
        long currentTimeMillis = System.currentTimeMillis();
        JsonElement jsonElement = requestAccessInfo(context, "local", this.localAuthParam, GET_UID_TIMEOUT).get("uid");
        String asString = jsonElement != null ? jsonElement.getAsString() : null;
        KitLog.info(TAG, "getAccountUidSync end, cost: " + (System.currentTimeMillis() - currentTimeMillis));
        return asString;
    }

    @Override
    public void getAuthCode(Context context, final HmsListener hmsListener) {
        KitLog.info(TAG, "getAuthCode start.");
        final long currentTimeMillis = System.currentTimeMillis();
        ArrayList arrayList = new ArrayList();
        arrayList.add(SCOPE_ACCOUNT);
        AccountAuthManager.getService(context, new AccountAuthParamsHelper(AccountAuthParams.DEFAULT_AUTH_REQUEST_PARAM).setAuthorizationCode().setScopeList(arrayList).createParams()).silentSignIn().addOnSuccessListener(new OnSuccessListener() {
            @Override
            public final void onSuccess(Object obj) {
                HmsProxy.lambda$getAuthCode$2(HmsListener.this, currentTimeMillis, (AuthAccount) obj);
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public final void onFailure(Exception exc) {
                HmsProxy.lambda$getAuthCode$3(HmsListener.this, currentTimeMillis, exc);
            }
        });
    }

    @Override
    public Optional<AuthHuaweiIdConversion> getCacheAuthInfo() {
        if (TextUtils.isEmpty(this.accessToken) || TextUtils.isEmpty(this.uid)) {
            KitLog.warn(TAG, "token or uid is empty");
            return Optional.empty();
        }
        AuthHuaweiIdConversion authHuaweiIdConversion = new AuthHuaweiIdConversion();
        authHuaweiIdConversion.setAccessToken(this.accessToken);
        authHuaweiIdConversion.setUid(this.uid);
        return Optional.ofNullable(authHuaweiIdConversion);
    }

    @Override
    public boolean getLoginStatus(android.content.Context r10) {
        throw new UnsupportedOperationException("Method not decompiled: com.huawei.hiassistant.platform.base.adapter.businessadapter.HmsProxy.getLoginStatus(android.content.Context):boolean");
    }

    @Override
    public void requestAccessInfoAsynchronous(Context context, final HmsListener hmsListener) {
        HuaweiIdAuthService service;
        if (!this.isAllowRequestInfo) {
            KitLog.info(TAG, "requestAccessInfoAsynchronous onfail, allowRequestInfo is false");
            sendFailResultCallback(hmsListener);
            return;
        }
        if (context instanceof Activity) {
            KitLog.info(TAG, "requestAccessInfoAsynchronous with activity");
            service = HuaweiIdAuthManager.getService((Activity) context, this.cloudAuthParam);
        } else {
            service = HuaweiIdAuthManager.getService(context, this.cloudAuthParam);
        }
        if (service == null) {
            sendFailResultCallback(hmsListener);
            return;
        }
        Task silentSignIn = service.silentSignIn();
        if (silentSignIn == null) {
            sendFailResultCallback(hmsListener);
        } else {
            KitLog.debug(TAG, "silentSignIn end", new Object[0]);
            silentSignIn.addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(Exception exc) {
                    KitLog.warn(HmsProxy.TAG, "requestAccessInfoAsynchronous fail.");
                    HmsProxy.this.sendFailResultCallback(hmsListener);
                }
            }).addOnSuccessListener(new OnSuccessListener<AuthHuaweiId>() {
                @Override
                public void onSuccess(AuthHuaweiId authHuaweiId) {
                    KitLog.info(HmsProxy.TAG, "requestAccessInfoAsynchronous success");
                    HmsListener hmsListener2 = hmsListener;
                    if (hmsListener2 != null) {
                        hmsListener2.onSuccess(HmsProxy.this.getConversionObject(authHuaweiId));
                    }
                }
            });
        }
    }

    @Override
    public JsonObject requestAccessInfoSynchronize(Context context) {
        JsonObject requestAccessInfo;
        JsonObject makeAccessInfoJson;
        KitLog.info(TAG, "requestAccessInfoSynchronize");
        if (this.isGettingAccessInfo) {
            synchronized (this.lockForGetAccessInfo) {
                makeAccessInfoJson = makeAccessInfoJson();
            }
            return makeAccessInfoJson;
        }
        synchronized (this.lockForGetAccessInfo) {
            requestAccessInfo = requestAccessInfo(context, "cloud", this.cloudAuthParam, FIRST_LOGIN_TIMEOUT);
        }
        return requestAccessInfo;
    }

    @Override
    public void requestLogin(Activity activity, int i) {
        KitLog.info(TAG, "requestLogin");
        if (activity == null) {
            KitLog.warn(TAG, "activity is null");
            return;
        }
        HuaweiIdAuthService service = HuaweiIdAuthManager.getService(activity, this.cloudAuthParam);
        if (service != null) {
            Intent signInIntent = service.getSignInIntent();
            signInIntent.setPackage("com.huawei.hwid");
            activity.startActivityForResult(signInIntent, i);
        }
    }

    @Override
    public void setAllowRequestHwInfo(boolean z) {
        this.isAllowRequestInfo = z;
    }
}