QQ浏览器 v12.2.3.7053版本的 MD5 值为：8285ab3059e5c8b521a264dfbc5c3685
以下内容为反编译后的 WeChatMiniProgramServiceImpl.java 源代码，内容仅作参考
package com.tencent.mtt.miniprogram.service;
import MTT.GetWxAppletBlackListRsp;
import MTT.UGDataReportReq;
import MTT.UGDataReportResp;
import MTT.WxAppletDetail;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Application;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import android.text.TextUtils;
import android.view.View;
import com.huawei.hms.framework.common.ContainerUtils;
import com.huawei.hms.support.hianalytics.HiAnalyticsConstant;
import com.tencent.common.boot.BootFeatureToggle;
import com.tencent.common.featuretoggle.FeatureToggle;
import com.tencent.common.fresco.pipeline.ImageHub;
import com.tencent.common.fresco.request.ImageRequester;
import com.tencent.common.manifest.EventEmiter;
import com.tencent.common.manifest.EventMessage;
import com.tencent.common.manifest.annotation.CreateMethod;
import com.tencent.common.manifest.annotation.ServiceImpl;
import com.tencent.common.task.CancellationTokenSource;
import com.tencent.common.task.Continuation;
import com.tencent.common.task.QBTask;
import com.tencent.common.threadpool.BrowserExecutorSupplier;
import com.tencent.common.utils.FileUtils;
import com.tencent.common.utils.PlatformUtils;
import com.tencent.common.utils.PrivacyAPI;
import com.tencent.common.utils.StorageDirs;
import com.tencent.common.utils.ThreadUtils;
import com.tencent.common.utils.UrlUtils;
import com.tencent.common.wup.IWUPRequestCallBack;
import com.tencent.common.wup.WUPRequestBase;
import com.tencent.common.wup.WUPResponseBase;
import com.tencent.common.wup.WUPTaskProxy;
import com.tencent.connect.share.QQShare;
import com.tencent.luggage.wxa.gq.a;
import com.tencent.luggage.wxaapi.InitDynamicPkgResult;
import com.tencent.luggage.wxaapi.LaunchWxaAppResult;
import com.tencent.luggage.wxaapi.LaunchWxaAppResultListener;
import com.tencent.luggage.wxaapi.LaunchWxaAppResultListenerEx;
import com.tencent.luggage.wxaapi.PreloadWxaProcessEnvResult;
import com.tencent.luggage.wxaapi.PreloadWxaProcessEnvResultListener;
import com.tencent.luggage.wxaapi.TdiAuthCheckStateListener;
import com.tencent.luggage.wxaapi.TdiAuthErrCode;
import com.tencent.luggage.wxaapi.TdiAuthListener;
import com.tencent.luggage.wxaapi.TdiAuthState;
import com.tencent.luggage.wxaapi.WxaApi;
import com.tencent.luggage.wxaapi.WxaAppCloseEventListener;
import com.tencent.map.geolocation.util.DateUtils;
import com.tencent.mm.opensdk.modelbase.BaseReq;
import com.tencent.mm.opensdk.modelbase.BaseResp;
import com.tencent.mm.opensdk.modelmsg.SendAuth;
import com.tencent.mm.opensdk.openapi.IWXAPI;
import com.tencent.mm.opensdk.openapi.IWXAPIEventHandler;
import com.tencent.mm.opensdk.openapi.WXAPIFactory;
import com.tencent.mm.ui.widget.dialog.MMTipsBar;
import com.tencent.mtt.AppInfoHolder;
import com.tencent.mtt.ContextHolder;
import com.tencent.mtt.QBUIAppEngine;
import com.tencent.mtt.R;
import com.tencent.mtt.account.base.IAccount;
import com.tencent.mtt.account.base.IUserSwitchListener;
import com.tencent.mtt.account.base.UserLoginListener;
import com.tencent.mtt.base.account.AccountConst;
import com.tencent.mtt.base.account.AccountInfo;
import com.tencent.mtt.base.account.facade.IAccountService;
import com.tencent.mtt.base.account.facade.QuerySocialTypeCallback;
import com.tencent.mtt.base.functionwindow.ActivityHandler;
import com.tencent.mtt.base.stat.StatManager;
import com.tencent.mtt.base.stat.interfaces.IUnitTimeHelper;
import com.tencent.mtt.base.stat.utils.PlatformStatUtils;
import com.tencent.mtt.base.utils.PackageUtils;
import com.tencent.mtt.base.wup.WUPRequest;
import com.tencent.mtt.browser.download.business.flowctrl.FlowCtrlHelper;
import com.tencent.mtt.browser.download.core.facade.IFlowCtrlCallback;
import com.tencent.mtt.browser.share.export.socialshare.qqshare.QQShareActivity;
import com.tencent.mtt.businesscenter.facade.IFrameworkDelegate;
import com.tencent.mtt.businesscenter.facade.IHostService;
import com.tencent.mtt.history.base.IHistory;
import com.tencent.mtt.javaswitch.FeatureSwitcher;
import com.tencent.mtt.miniprogram.MiniProgramSource;
import com.tencent.mtt.miniprogram.auth.MiniAuthStateServiceImpl;
import com.tencent.mtt.miniprogram.dialog.DebugDialogUtil;
import com.tencent.mtt.miniprogram.dialog.DownLoadSoUtils;
import com.tencent.mtt.miniprogram.dialog.ErrorPageDialog;
import com.tencent.mtt.miniprogram.dialog.GuideAuthDialog;
import com.tencent.mtt.miniprogram.monitor.MiniProgramMonitorMgr;
import com.tencent.mtt.miniprogram.util.MiniDetailUtil;
import com.tencent.mtt.miniprogram.util.WeChatMiniProgramConstant;
import com.tencent.mtt.miniprogram.util.WeChatMiniProgramHandler;
import com.tencent.mtt.miniprogram.util.activity.ActivityLifeCycleHandler;
import com.tencent.mtt.miniprogram.util.activity.SimpleActivityLifeCycle;
import com.tencent.mtt.miniprogram.util.download.MiniPreLoadIPrefer;
import com.tencent.mtt.miniprogram.util.download.PluginUtils;
import com.tencent.mtt.miniprogram.util.download.PreDownloadUtils;
import com.tencent.mtt.miniprogram.util.download.SoDownloadManager;
import com.tencent.mtt.miniprogram.util.education.EducationParamsEntity;
import com.tencent.mtt.miniprogram.util.education.EducationUserUtil;
import com.tencent.mtt.miniprogram.util.education.H5FallbackUtils;
import com.tencent.mtt.miniprogram.util.education.LoadingDialogUtil;
import com.tencent.mtt.miniprogram.util.env.MiniProgramSoState;
import com.tencent.mtt.miniprogram.util.history.HistoryUtils;
import com.tencent.mtt.miniprogram.util.log.FeedsLogUtils;
import com.tencent.mtt.miniprogram.util.log.MiniLogUtil;
import com.tencent.mtt.miniprogram.util.log.MiniOpenSdkUploadLogIPrefer;
import com.tencent.mtt.miniprogram.util.log.TimeLogUtils;
import com.tencent.mtt.miniprogram.util.log.UploadUtil;
import com.tencent.mtt.miniprogram.util.patch.core.task.PatchTaskManager;
import com.tencent.mtt.miniprogram.util.patch.miniprogram.MiniProgramPatchTask;
import com.tencent.mtt.miniprogram.util.patch.miniprogram.config.MiniProgramPatchConfigCacheHolder;
import com.tencent.mtt.miniprogram.util.patch.miniprogram.config.MiniProgramPatchPreferenceReceiver;
import com.tencent.mtt.miniprogram.util.upload.MiniProgramUploadEntity;
import com.tencent.mtt.miniprogram.util.upload.TimeUploadEntity;
import com.tencent.mtt.network.QBNetworkInfo;
import com.tencent.mtt.qbcontext.core.QBContext;
import com.tencent.mtt.sdkcontext.SDKContext;
import com.tencent.mtt.setting.PublicSettingManager;
import com.tencent.mtt.stabilization.rqd.RqdSdkProxy;
import com.tencent.mtt.view.dialog.newui.SimpleDialogBuilder;
import com.tencent.mtt.view.dialog.newui.builder.api.ICommonDialogBuilder;
import com.tencent.mtt.view.dialog.newui.builder.api.base.IDialogBuilder;
import com.tencent.mtt.view.dialog.newui.dialog.DialogBase;
import com.tencent.mtt.view.dialog.newui.view.ViewOnClickListener;
import com.tencent.mtt.view.toast.MttToaster;
import com.tencent.mtt.wechatminiprogram.AuthStateCallback;
import com.tencent.mtt.wechatminiprogram.GetAuthStateCallback;
import com.tencent.mtt.wechatminiprogram.IMiniAuthStateService;
import com.tencent.mtt.wechatminiprogram.IWeChatMiniActionCheckerService;
import com.tencent.mtt.wechatminiprogram.IWeChatMiniProgramService;
import com.tencent.mtt.wechatminiprogram.LoadSoCallback;
import com.tencent.mtt.wechatminiprogram.MiniAuthErrCode;
import com.tencent.mtt.wechatminiprogram.MiniAuthState;
import com.tencent.mtt.wechatminiprogram.MiniCombineAuthEnvCheckCallback;
import com.tencent.mtt.wechatminiprogram.MiniPreloadCallback;
import com.tencent.mtt.wechatminiprogram.MiniPreloadParams;
import com.tencent.mtt.wechatminiprogram.MiniProgramHistoryEntity;
import com.tencent.mtt.wechatminiprogram.MiniProgramHistoryRefreshListener;
import com.tencent.mtt.wechatminiprogram.MiniProgramOpenCallback;
import com.tencent.mtt.wechatminiprogram.RecentCallback;
import com.tencent.mtt.wechatminiprogram.SoDownloadPluginShowListener;
import com.tencent.mtt.wechatminiprogram.WidgetMiniEntity;
import com.tencent.trpcprotocol.pf.diffpkgserver.diffpkg.diffpkg;
import com.tencent.trpcprotocol.qb_weapp.applet_general_info_svr.applet_general_info_svr.appletGeneralInfoSvr;
import com.tencent.trpcprotocol.weapp.weapp_base_info_portal.weapp_base_info_portal.weappBaseInfoPortal;
import com.xiaomi.mipush.sdk.Constants;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.json.JSONException;
import org.json.JSONObject;
import qb.wechatminiprogram.BuildConfig;
@ServiceImpl(createMethod = CreateMethod.GET, service = IWeChatMiniProgramService.class)
public class WeChatMiniProgramServiceImpl implements Application.ActivityLifecycleCallbacks, IUserSwitchListener, IFlowCtrlCallback, IWeChatMiniProgramService {
public static final String BEGINDOWNLOAD_PRE_WECHATMINIPROGRAM = "h_begindownload_wechatminiprogram";
static final String BEGINDOWNLOAD_WECHATMINIPROGRAM = "f_begindownload_wechatminiprogram";
static final String CALLLOAD_WECHATMINIPROGRAM = "b_callload_wechatminiprogram";
public static final String COMPLETEDDOWNLOAD_PRE_WECHATMINIPROGRAM = "i_completeddownload_wechatminiprogram";
public static final String COMPLETEDDOWNLOAD_WECHATMINIPROGRAM = "g_completeddownload_wechatminiprogram";
static final String DOLOAD_WECHATMINIPROGRAM = "c_doload_wechatminiprogram";
static final String FUN_NAME_BASE = "/trpc.weapp.weapp_base_info_portal.weapp_base_info_portal/";
static final String GET_BLACK_LIST_FUN_NAME = "/trpc.weapp.weapp_base_info_portal.weapp_base_info_portal/GetWxAppletBlackList";
static final String GET_OP_LIST_FUN_NAME = "/trpc.weapp.weapp_base_info_portal.weapp_base_info_portal/GetWxAppletOpList";
static final String INITAPP_WECHATMINIPROGRAM = "a_initapp_wechatminiprogram";
private static final String OPEN_WITHOUT_PACKAGE = "WITHOUT_CODE_PACKAGE";
private static final String OPEN_WITH_PACKAGE = "WITH_CODE_PACKAGE";
static final String PREPARED_WECHATMINIPROGRAM = "d_prepared_wechatminiprogram";
static final String SEVER_NAME = "trpc.weapp.weapp_base_info_portal.weapp_base_info_portal";
static final String STAT_WXMINI_FLOWCTRL_DELAY = "WXMINI_FLOWCTRL_DELAY";
static final String STAT_WXMINI_FLOWCTRL_PASS = "WXMINI_FLOWCTRL_PASS";
static final String STAT_WXMINI_FLOWCTRL_REQ = "WXMINI_FLOWCTRL_REQ";
static final String USEDOWNLOADED_WECHATMINIPROGRAM = "e_usedownloaded_wechatminiprogram";
static final String WXMINI_ADD_HISTORY = "WXMINI_ADD_HISTORY";
static final String WXMINI_NEED_BACK = "WXMINI_NEED_BACK";
static final String WXMINI_NOT_NEED_BACK = "WXMINI_NOT_NEED_BACK";
static WeChatMiniProgramServiceImpl instance;
private static IAccount sAccountModule;
public static boolean sOptLoadMiniSwitch;
private WxaApi mApi;
private int mCurrentUserType;
private CancellationTokenSource mDebugPauseCancellationToken;
public boolean mDebuggable;
boolean mIsAuthed;
volatile boolean mIsInAuth;
private volatile boolean mIsInLoadSoProgress;
private volatile Boolean mMiniSwitch;
private MiniProgramMonitorMgr mMonitorMgr;
volatile WxAppLaunchParam mWxParam;
private Map<String, ScheduledExecutorService> mMiniProgramTimeScheduledMap = new HashMap();
private Map<String, IUnitTimeHelper> mMiniTimeHelper = new HashMap();
private Map<String, String> mOpenUrlMap = new HashMap();
Map<String, MiniProgramUploadEntity> mUploadData = new HashMap();
private Map<String, Integer> mAuthTimes = new HashMap();
private HashSet<String> mAuthRecordIds = new HashSet<>();
private CopyOnWriteArrayList<SoDownloadPluginShowListener> mPluginListeners = new CopyOnWriteArrayList<>();
private CopyOnWriteArrayList<LoadSoCallback> mLoadSoCallbacks = new CopyOnWriteArrayList<>();
private int mPluginMode = 3;
private volatile boolean mIsNeedToGoOn = false;
private boolean mEnable = true;
boolean mIsAlreadyPreload = false;
private AtomicBoolean mCheckAuthStateCallbackState = new AtomicBoolean(true);
private Map<String, CancellationTokenSource> mUploadCancellationTokenMap = new HashMap();
private volatile CopyOnWriteArrayList<WidgetMiniEntity> mWidgetMiniEntities = new CopyOnWriteArrayList<>();
private boolean mIsWeChatVersionInit = false;
private boolean mIsWeChatVersionEnable = false;
private boolean mDonePrepareSoStep = false;
private CopyOnWriteArrayList<MiniProgramHistoryRefreshListener> mListeners = new CopyOnWriteArrayList<>();
FlowCtrlHelper mFlowCtrlHelper = new FlowCtrlHelper(2, this, true);
public class AnonymousClass25 implements Runnable {
final OnGoToSendAuthListener val$listener;
final String val$subTitle;
final String val$title;
AnonymousClass25(String str, String str2, OnGoToSendAuthListener onGoToSendAuthListener) {
this.val$title = str;
this.val$subTitle = str2;
this.val$listener = onGoToSendAuthListener;
}
@Override
public void run() {
GuideAuthDialog guideAuthDialog = new GuideAuthDialog(this.val$title, this.val$subTitle, ActivityHandler.b().a());
guideAuthDialog.setOnShowListener(new DialogInterface.OnShowListener() {
@Override
public void onShow(final DialogInterface dialogInterface) {
new Handler().postDelayed(new Runnable() {
@Override
public void run() {
dialogInterface.dismiss();
AnonymousClass25.this.val$listener.go();
}
}, MMTipsBar.DURATION_SHORT);
}
});
guideAuthDialog.show();
}
}
public static class AnonymousClass55 {
static final int[] $SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState;
static final int[] $SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType = new int[QuerySocialTypeCallback.SocialType.values().length];
static {
try {
$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[QuerySocialTypeCallback.SocialType.CONNECT.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[QuerySocialTypeCallback.SocialType.QQ.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[QuerySocialTypeCallback.SocialType.UNKNOWN.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
try {
$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[QuerySocialTypeCallback.SocialType.NONE.ordinal()] = 4;
} catch (NoSuchFieldError unused4) {
}
try {
$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[QuerySocialTypeCallback.SocialType.WX.ordinal()] = 5;
} catch (NoSuchFieldError unused5) {
}
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState = new int[TdiAuthState.values().length];
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState[TdiAuthState.WechatTdi_Auth_State_OK.ordinal()] = 1;
} catch (NoSuchFieldError unused6) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState[TdiAuthState.WechatTdi_Auth_State_NoAuth.ordinal()] = 2;
} catch (NoSuchFieldError unused7) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState[TdiAuthState.WechatTdi_Auth_State_Expired.ordinal()] = 3;
} catch (NoSuchFieldError unused8) {
}
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode = new int[MiniAuthErrCode.values().length];
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_OK.ordinal()] = 1;
} catch (NoSuchFieldError unused9) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_UserCanceled.ordinal()] = 2;
} catch (NoSuchFieldError unused10) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_UserDenied.ordinal()] = 3;
} catch (NoSuchFieldError unused11) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_System.ordinal()] = 4;
} catch (NoSuchFieldError unused12) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_InvalidArgs.ordinal()] = 5;
} catch (NoSuchFieldError unused13) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_NormalErr.ordinal()] = 6;
} catch (NoSuchFieldError unused14) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_WechatNotInstalled.ordinal()] = 7;
} catch (NoSuchFieldError unused15) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_WechatVersionTooLow.ordinal()] = 8;
} catch (NoSuchFieldError unused16) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_ActiveDeviceFailed.ordinal()] = 9;
} catch (NoSuchFieldError unused17) {
}
try {
$SwitchMap$com$tencent$mtt$wechatminiprogram$MiniAuthErrCode[MiniAuthErrCode.Auth_Err_Dynamic_Pkg_Not_Loaded.ordinal()] = 10;
} catch (NoSuchFieldError unused18) {
}
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode = new int[TdiAuthErrCode.values().length];
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_OK.ordinal()] = 1;
} catch (NoSuchFieldError unused19) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_UserCanceled.ordinal()] = 2;
} catch (NoSuchFieldError unused20) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_UserDenied.ordinal()] = 3;
} catch (NoSuchFieldError unused21) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_System.ordinal()] = 4;
} catch (NoSuchFieldError unused22) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_InvalidArgs.ordinal()] = 5;
} catch (NoSuchFieldError unused23) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_NormalErr.ordinal()] = 6;
} catch (NoSuchFieldError unused24) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_WechatNotInstalled.ordinal()] = 7;
} catch (NoSuchFieldError unused25) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_WechatVersionTooLow.ordinal()] = 8;
} catch (NoSuchFieldError unused26) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_ActiveDeviceFailed.ordinal()] = 9;
} catch (NoSuchFieldError unused27) {
}
try {
$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthErrCode[TdiAuthErrCode.WechatTdi_Auth_Err_Dynamic_Pkg_Not_Loaded.ordinal()] = 10;
} catch (NoSuchFieldError unused28) {
}
}
}
public class LaunchResultListener implements LaunchWxaAppResultListener, LaunchWxaAppResultListenerEx {
private long mResourceLoadFinishTime;
private WxAppLaunchParam param;
private HashSet<String> recordMap = new HashSet<>();
private long mStartTime = SystemClock.elapsedRealtime();
LaunchResultListener(WxAppLaunchParam wxAppLaunchParam) {
this.param = wxAppLaunchParam;
}
@Override
public void onLaunchResourcePrepareCompleted(String str, int i, long j) {
this.mResourceLoadFinishTime = SystemClock.elapsedRealtime();
this.recordMap.add(this.param.uuid);
}
@Override
public void onLaunchResult(String str, int i, long j, LaunchWxaAppResult launchWxaAppResult) {
MiniLogUtil.log("launchWxaApp result: " + launchWxaAppResult.name() + " appId: " + str + " id: " + j);
DebugDialogUtil.getInstance().printLog("launchWxaApp 回调：" + launchWxaAppResult.name() + " 耗时：" + (SystemClock.elapsedRealtime() - this.mStartTime) + "毫秒");
WeChatMiniProgramServiceImpl.this.recordStep(this.param.uuid, 10, launchWxaAppResult.name());
WeChatMiniProgramServiceImpl.this.recordHistoryWeChatMiniProgram(str);
String str2 = this.recordMap.contains(this.param.uuid) ? "1" : "2";
String name = (this.recordMap.remove(this.param.uuid) && launchWxaAppResult == LaunchWxaAppResult.Cancel) ? "CancelWithLoadSuccess" : launchWxaAppResult.name();
long j2 = this.mResourceLoadFinishTime;
if (j2 == 0) {
j2 = SystemClock.elapsedRealtime();
}
long j3 = j2 - this.param.startTime;
DebugDialogUtil.getInstance().printLog("launchWxaApp 回调：" + launchWxaAppResult.name() + " 框架耗时：" + j3 + "毫秒");
UploadUtil.uploadMiniActionEvent(UploadUtil.OPEN, str2, name, "", this.param.uuid, j3, this.param.extras);
UploadUtil.uploadMiniActionEvent(UploadUtil.FIRST_FRAME, str2, name, "", this.param.uuid, SystemClock.elapsedRealtime() - this.mStartTime, this.param.extras);
if (launchWxaAppResult == LaunchWxaAppResult.OK) {
WeChatMiniProgramServiceImpl weChatMiniProgramServiceImpl = WeChatMiniProgramServiceImpl.this;
weChatMiniProgramServiceImpl.mWxParam = this.param;
weChatMiniProgramServiceImpl.checkKingCard();
WeChatMiniProgramServiceImpl.this.preloadMiniProgramEnv(1);
WeChatMiniProgramServiceImpl.this.backHistory(this.param);
this.param.callback.onSuccess(str, this.param.uuid);
WeChatMiniProgramServiceImpl.this.emitMiniEvent("MINI_PROGRAM_ACTIVITY_OPEN", this.param.appId, this.param.extras.get("sourceUrl"));
WeChatMiniProgramServiceImpl.this.mOpenUrlMap.put(this.param.appId, this.param.extras.get("sourceUrl"));
} else if (launchWxaAppResult == LaunchWxaAppResult.Fail) {
this.param.callback.onFailed(1003, launchWxaAppResult.name(), this.param.uuid);
ErrorPageDialog.showErrorPage(this.param.appId, "微信内部错误，无法正常使用小程序");
UploadUtil.uploadXLogSdk();
} else if (launchWxaAppResult == LaunchWxaAppResult.FailNotLoadDynamicPkg) {
this.param.callback.onFailed(1004, "插件加载失败，无法正常使用小程序", this.param.uuid);
ErrorPageDialog.showErrorPage(this.param.appId, "插件加载失败，无法正常使用小程序");
} else if (launchWxaAppResult == LaunchWxaAppResult.Cancel) {
this.param.callback.onFailed(1003, launchWxaAppResult.name(), this.param.uuid);
}
if (WeChatMiniProgramServiceImpl.this.mDebuggable) {
WeChatMiniProgramServiceImpl.this.displayDebugDialog();
}
}
}
class MainActivityListener extends SimpleActivityLifeCycle {
MainActivityListener() {
}
@Override
public void onActivityPaused(Activity activity) {
if (activity.getComponentName().getClassName().contains("com.tencent.mtt.MainActivity") && WeChatMiniProgramServiceImpl.this.mDebugPauseCancellationToken != null) {
WeChatMiniProgramServiceImpl.this.mDebugPauseCancellationToken.c();
}
}
@Override
public void onActivityResumed(Activity activity) {
if (activity.getComponentName().getClassName().contains("com.tencent.mtt.MainActivity") && WeChatMiniProgramServiceImpl.this.mIsInAuth) {
WeChatMiniProgramServiceImpl.this.detectCallback();
}
}
}
public interface OnGoToSendAuthListener {
void go();
}
private WeChatMiniProgramServiceImpl() {
if (!sOptLoadMiniSwitch) {
loadMiniSwitch();
}
getAccountModule().addUserSwitchListener(this);
}
private void addMiniProgramHis(final String str) {
MiniDetailUtil.requestMiniDetail(str, new MiniDetailUtil.DetailCallback() {
final String urlPrefix = "qb://wxapp/?appid=";
final String endFix = "&source=100034";
public void add2HistoryDB(String str2, String str3, String str4, String str5, String str6) {
((IHistory) SDKContext.getInstance().getService(IHistory.class)).addHistory(str2, str3, str4, 0L, 1014, str5, str6);
}
@Override
public void onSuccess(WxAppletDetail wxAppletDetail) {
add2HistoryDB(wxAppletDetail.sName, "qb://wxapp/?appid=" + str + "&source=100034", wxAppletDetail.sIcon, "", wxAppletDetail.sWording);
}
@Override
public void onSuccess(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
add2HistoryDB(wxAppletDetail.getName(), "qb://wxapp/?appid=" + str + "&source=100034", wxAppletDetail.getIcon(), "", wxAppletDetail.getWording());
}
});
}
private void backHistoryImpl() {
((IFrameworkDelegate) QBContext.getInstance().getService(IFrameworkDelegate.class)).handleMttMessage(5, 0, 0, null, 0L);
}
public boolean baseCheckResponse(WUPResponseBase wUPResponseBase) {
String str;
if (wUPResponseBase == null) {
str = "no response";
} else {
Integer returnCode = wUPResponseBase.getReturnCode();
if (returnCode != null && returnCode.intValue() == 0) {
return true;
}
str = "returnCode =" + returnCode;
}
MiniLogUtil.log(str);
return false;
}
public void callbackLoadSoResult(boolean z, String str) {
Iterator<LoadSoCallback> it = this.mLoadSoCallbacks.iterator();
while (it.hasNext()) {
LoadSoCallback next = it.next();
if (z) {
next.success();
} else {
next.failed(str);
}
}
this.mLoadSoCallbacks.clear();
}
private void checkAuthStateInner(final WxAppLaunchParam wxAppLaunchParam) {
recordStep(wxAppLaunchParam.uuid, 4);
DebugDialogUtil.getInstance().printLog("开始检测授权态");
this.mApi.checkAuthState(new TdiAuthCheckStateListener() {
@Override
public void onStateChecked(TdiAuthState tdiAuthState, String str) {
DebugDialogUtil debugDialogUtil = DebugDialogUtil.getInstance();
StringBuilder sb = new StringBuilder();
sb.append("授权态：");
sb.append(tdiAuthState == TdiAuthState.WechatTdi_Auth_State_OK ? "已授权" : "未授权");
debugDialogUtil.printLog(sb.toString());
WeChatMiniProgramServiceImpl.this.recordStep(wxAppLaunchParam.uuid, 5);
WeChatMiniProgramServiceImpl.this.checkAuthStateCallback(tdiAuthState, wxAppLaunchParam);
}
});
}
public void checkKingCard() {
if (PublicSettingManager.a().getBoolean(WeChatMiniProgramConstant.FIRST_OPEN_MINI_KEY, true) && QBNetworkInfo.isQueenEnable()) {
MttToaster.show("小程序暂不支持免流，请注意流量消耗", 3500);
PublicSettingManager.a().setBoolean(WeChatMiniProgramConstant.FIRST_OPEN_MINI_KEY, false);
}
}
private void checkWxAppByPackageInfo() {
PackageInfo b2 = PackageUtils.b("com.tencent.mm", ContextHolder.getAppContext());
if (b2 != null) {
if ((Build.VERSION.SDK_INT >= 28 ? b2.getLongVersionCode() : b2.versionCode) >= 1780) {
this.mIsWeChatVersionEnable = true;
return;
}
}
this.mIsWeChatVersionEnable = false;
}
private boolean checkWxAppEnableImpl() {
WxaApi wxaApi = this.mApi;
if (wxaApi == null) {
return false;
}
return wxaApi.checkIfWechatSupportWxaApi();
}
private boolean checkWxAppVersion(WxAppLaunchParam wxAppLaunchParam) {
DebugDialogUtil.getInstance().printLog("检测微信客户端版本");
if (checkWxAppEnable()) {
DebugDialogUtil.getInstance().printLog("微信版本客户端版本符合要求");
return true;
}
MiniLogUtil.log("launchWxaApp wx app not support");
wxAppLaunchParam.callback.onFailed(1002, "微信版本过低，无法正常使用小程序", wxAppLaunchParam.uuid);
checkWxApp(wxAppLaunchParam);
if (H5FallbackUtils.handleBackToH5(wxAppLaunchParam.extras)) {
return false;
}
ErrorPageDialog.showErrorPage(wxAppLaunchParam.appId, PackageUtils.b("com.tencent.mm", ContextHolder.getAppContext()) != null ? "您微信版本过低，无法正常使用小程序" : "您未安装微信，无法正常使用小程序");
return false;
}
private String checkWxaPackageStatus(WxAppLaunchParam wxAppLaunchParam) {
File file = new File(String.format("%s%s%s", ContextHolder.getAppContext().getFilesDir(), File.separator, "wxapkg"));
if (!file.exists()) {
return OPEN_WITHOUT_PACKAGE;
}
for (File file2 : file.listFiles()) {
if (!TextUtils.isEmpty(file2.getName()) && file2.exists() && file2.getName().contains(wxAppLaunchParam.appId)) {
return OPEN_WITH_PACKAGE;
}
}
return OPEN_WITHOUT_PACKAGE;
}
public void displayDebugDialog() {
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public void run() {
AlertDialog.Builder title = new AlertDialog.Builder(ActivityHandler.b().a()).setIcon(R.drawable.a3k).setTitle("插件加载情况");
StringBuilder sb = new StringBuilder();
sb.append("插件加载完成：");
sb.append(WeChatMiniProgramServiceImpl.this.isSoZipLoaded() ? "是" : "否");
sb.append("\nXWeb加载完成：");
sb.append(WeChatMiniProgramServiceImpl.this.isXWebLoadFinish() ? "是" : "否");
title.setMessage(sb.toString()).setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
}).create().show();
}
});
}
private void doPrepareSo(String str, String str2) {
if (str.equals(str2)) {
new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
@Override
public void run() {
if (PublicSettingManager.a().getBoolean(MiniPreLoadIPrefer.MINIPROGRAM_PRELOAD_IN_APPINIT, false) && PrivacyAPI.isPrivacyGranted()) {
PlatformStatUtils.a(WeChatMiniProgramServiceImpl.CALLLOAD_WECHATMINIPROGRAM);
WeChatMiniProgramServiceImpl.this.doPrepareSoStep();
}
}
}, 15000L);
}
}
public void doWxLoginFailedLogic(int i, String str, boolean[] zArr) {
MiniLogUtil.log("WeChatMiniProgram｜showWxLoginDialog onLoginFailed code=" + i + ", s=" + str);
if (zArr[0] || i == 0) {
return;
}
zArr[0] = true;
MiniLogUtil.log("WeChatMiniProgram｜showWxLoginDialog onLoginFailed doReport code=" + i + ", s=" + str);
StatManager.b().c("XCX80001");
}
public void doWxLoginSuccessLogic(boolean[] zArr, final WxAppLaunchParam wxAppLaunchParam) {
MiniLogUtil.log("WeChatMiniProgram｜showWxLoginDialog onLoginSuccess");
if (!zArr[0]) {
zArr[0] = true;
StatManager.b().c("XCX80001");
}
sendAuth(new AuthStateCallback() {
@Override
public final void onSendAuthFinish(MiniAuthErrCode miniAuthErrCode, String str) {
WeChatMiniProgramServiceImpl.this.lambda$doWxLoginSuccessLogic$1$WeChatMiniProgramServiceImpl(wxAppLaunchParam, miniAuthErrCode, str);
}
});
}
public void emitMiniEvent(final String str, String str2, final String str3) {
MiniDetailUtil.requestMiniDetail(str2, new MiniDetailUtil.DetailCallback() {
@Override
public void onSuccess(WxAppletDetail wxAppletDetail) {
}
@Override
public void onSuccess(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
WeChatMiniProgramServiceImpl.this.emitDetail(str, wxAppletDetail, str3);
}
});
}
protected static long fixTimestamp(HashSet<MiniProgramHistoryEntity> hashSet) {
if (hashSet == null || hashSet.size() == 0) {
return System.currentTimeMillis();
}
long currentTimeMillis = System.currentTimeMillis();
Iterator<MiniProgramHistoryEntity> it = hashSet.iterator();
while (it.hasNext()) {
currentTimeMillis = Math.max(it.next().getTimeSpan(), currentTimeMillis);
}
return currentTimeMillis + 1;
}
static IAccount getAccountModule() {
IAccount iAccount = sAccountModule;
return iAccount != null ? iAccount : (IAccount) SDKContext.getInstance().getService(IAccount.class);
}
private String getHistorySoDir() {
File a2 = FileUtils.a(StorageDirs.b("mini_so"), "history");
return a2 == null ? "" : a2.getAbsolutePath();
}
public static WeChatMiniProgramServiceImpl getInstance() {
if (instance == null) {
synchronized (WeChatMiniProgramServiceImpl.class) {
if (instance == null) {
instance = new WeChatMiniProgramServiceImpl();
}
}
}
return instance;
}
private boolean getMiniSwitchImpl() {
if (this.mMiniSwitch == null) {
synchronized (WeChatMiniProgramServiceImpl.class) {
if (this.mMiniSwitch == null) {
loadMiniSwitch();
}
}
}
return Boolean.TRUE.equals(this.mMiniSwitch);
}
private MiniProgramMonitorMgr getMonitorMgr() {
if (this.mMonitorMgr == null) {
this.mMonitorMgr = new MiniProgramMonitorMgr();
}
return this.mMonitorMgr;
}
public void handleBlackListProto(List<String> list) {
MiniLogUtil.log("handleBlackListProto...");
if (list == null || list.size() == 0) {
MiniLogUtil.log("black list is empty...");
return;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < list.size(); i++) {
sb.append(list.get(i));
if (i != list.size() - 1) {
sb.append(Constants.ACCEPT_TIME_SEPARATOR_SP);
}
}
MiniLogUtil.log("black list: " + sb.toString());
PublicSettingManager.a().setString(WeChatMiniProgramConstant.BLACK_LIST, sb.toString());
}
private void handleBlackListResponse(GetWxAppletBlackListRsp getWxAppletBlackListRsp) {
MiniLogUtil.log("handleBlackListResponse...");
if (getWxAppletBlackListRsp.vBlackList == null || getWxAppletBlackListRsp.vBlackList.size() == 0) {
MiniLogUtil.log("black list is empty...");
return;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < getWxAppletBlackListRsp.vBlackList.size(); i++) {
sb.append(getWxAppletBlackListRsp.vBlackList.get(i));
if (i != getWxAppletBlackListRsp.vBlackList.size() - 1) {
sb.append(Constants.ACCEPT_TIME_SEPARATOR_SP);
}
}
MiniLogUtil.log("black list: " + sb.toString());
MiniLogUtil.log("black list Md5: " + getWxAppletBlackListRsp.sMd5);
PublicSettingManager.a().setString(WeChatMiniProgramConstant.BLACK_LIST, sb.toString());
PublicSettingManager.a().setString(WeChatMiniProgramConstant.BLACK_LIST_MD5, getWxAppletBlackListRsp.sMd5);
}
private void handlePauseEvent(String str) {
MiniLogUtil.log("onActivityPaused: " + Thread.currentThread().getName());
MiniProgramUploadEntity miniProgramUploadEntity = this.mUploadData.get(str);
if (miniProgramUploadEntity == null) {
return;
}
miniProgramUploadEntity.setEndTimeSpan(SystemClock.elapsedRealtime());
appendUseTimeToSourceUrl(str, miniProgramUploadEntity);
TimeLogUtils.onUnitTimeStop(this.mMiniTimeHelper.remove(str));
FeedsLogUtils.uploadCloseEvent(miniProgramUploadEntity);
UploadUtil.uploadMiniActionEvent(UploadUtil.CLOSE, "", miniProgramUploadEntity.getUuid(), SystemClock.elapsedRealtime() - miniProgramUploadEntity.getStartTimeSpan(), miniProgramUploadEntity.getExtras());
ScheduledExecutorService remove = this.mMiniProgramTimeScheduledMap.remove(str);
if (remove != null) {
remove.shutdown();
MiniLogUtil.log("shutdown IntervalUpload componentName: " + str);
}
}
private void handleResumeEvent(String str) {
MiniLogUtil.log("onActivityResumed: " + Thread.currentThread().getName());
MiniProgramUploadEntity miniProgramUploadEntity = this.mUploadData.get(str);
if (miniProgramUploadEntity == null) {
miniProgramUploadEntity = new MiniProgramUploadEntity();
this.mUploadData.put(str, miniProgramUploadEntity);
}
miniProgramUploadEntity.setStartTimeSpan(SystemClock.elapsedRealtime());
miniProgramUploadEntity.setComponentName(str);
TimeUploadEntity andClearUploadData = TimeLogUtils.getAndClearUploadData();
if (andClearUploadData != null) {
miniProgramUploadEntity.setExtras(andClearUploadData.getExtras());
miniProgramUploadEntity.setAppId(andClearUploadData.getAppId());
miniProgramUploadEntity.setUuid(andClearUploadData.getUuid());
PublicSettingManager.a().setString("CURRENT_MINI_APP_ID", andClearUploadData.getAppId());
}
startTimeUnit(miniProgramUploadEntity);
}
private void handleSocialTypeImpl(WxAppLaunchParam wxAppLaunchParam, QuerySocialTypeCallback.SocialType socialType) {
MiniLogUtil.log("current Social Type: " + socialType);
int i = AnonymousClass55.$SwitchMap$com$tencent$mtt$base$account$facade$QuerySocialTypeCallback$SocialType[socialType.ordinal()];
if (i != 1 && i != 2 && i != 3) {
if (i == 4) {
sendCombineAuthAndLoginQB(wxAppLaunchParam);
return;
} else if (i == 5 && PublicSettingManager.a().getBoolean("NEW_MINI_AUTH_WAY", false)) {
sendCombineAuth(wxAppLaunchParam);
return;
}
}
sendAuthOldWay(wxAppLaunchParam);
}
private void initApiAndDoPreStepInMainProcess(Context context, String str, boolean z, String str2, String str3) {
if (!str2.equals(str3) || z) {
initApiImpl(context, str);
PlatformStatUtils.a(INITAPP_WECHATMINIPROGRAM);
if (str2.equals(str3)) {
doPrepareSoStep();
}
}
}
private void initApiImpl(Context context, String str) {
int i = PlatformUtils.isCurrentProcess64Bit() ? 2 : 1;
this.mApi = WxaApi.Factory.createApi(context, str, i);
this.mApi.updateTuringOAID("");
this.mApi.addWxaAppCloseEventListener(new WxaAppCloseEventListener() {
@Override
public void onWxaAppClose(long j, String str2) {
WeChatMiniProgramServiceImpl.this.clearLocalParam(str2);
}
});
MiniLogUtil.log("is 64: " + i);
}
private void initUserTypeState(AccountInfo accountInfo) {
int i;
if (accountInfo == null) {
return;
}
if (accountInfo.isLogined()) {
byte b2 = accountInfo.mType;
if (b2 != 1) {
if (b2 == 2) {
this.mCurrentUserType = 1;
return;
} else if (b2 != 4) {
if (b2 != 8) {
return;
} else {
i = 3;
}
}
}
this.mCurrentUserType = 2;
return;
}
i = 0;
this.mCurrentUserType = i;
}
public static void injectAccountModule(IAccount iAccount) {
sAccountModule = iAccount;
}
private void installLocalFileInner(final LoadSoCallback loadSoCallback) {
BrowserExecutorSupplier.getInstance().getIoExecutor().execute(new Runnable() {
@Override
public void run() {
WeChatMiniProgramServiceImpl.this.installLocalFileInnerImpl(loadSoCallback);
}
});
}
private boolean isHistoryFileExists() {
return new File(String.format("%s%s%s", getHistorySoDir(), File.separator, WeChatMiniProgramConstant.HISTORY_SO_FILE_NAME)).exists();
}
public boolean isXWebLoadFinish() {
File file = new File(ContextHolder.getAppContext().getFilesDir().getParent());
if (!file.exists() || file.listFiles().length == 0) {
return false;
}
for (File file2 : file.listFiles()) {
if (file2.getName().contains("app_xwalk_")) {
return true;
}
}
return false;
}
public void launchDebugMiniProgram() {
this.mApi.checkAuthState(new TdiAuthCheckStateListener() {
@Override
public void onStateChecked(TdiAuthState tdiAuthState, String str) {
WeChatMiniProgramServiceImpl.this.launchDebugMiniProgramInner(tdiAuthState);
}
});
}
private void launchDebugMiniProgramReal() {
this.mApi.launchByQRScanCode(null, new LaunchWxaAppResultListener() {
@Override
public void onLaunchResult(String str, int i, long j, LaunchWxaAppResult launchWxaAppResult) {
if (LaunchWxaAppResult.OK != launchWxaAppResult) {
MttToaster.show("打开失败：" + launchWxaAppResult.name() + " 请联系开发人员", 1500);
}
}
});
}
private void loadMiniSwitch() {
this.mMiniSwitch = Boolean.valueOf(TextUtils.equals(PublicSettingManager.a().getString(MiniSwitchIPrefer.ADR_MTT_MINIPROGRAM_FLAG, "1"), "1"));
}
public void loadSoInner(final String str) {
BrowserExecutorSupplier.getInstance().getIoExecutor().execute(new Runnable() {
@Override
public void run() {
WeChatMiniProgramServiceImpl.this.mIsInLoadSoProgress = true;
InitDynamicPkgResult initDynamicPkg = WeChatMiniProgramServiceImpl.this.mApi.initDynamicPkg(str);
MiniLogUtil.log("loadSo so file: " + initDynamicPkg.toString());
boolean z = initDynamicPkg == InitDynamicPkgResult.OK;
if (z) {
((IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class)).init();
WeChatMiniProgramServiceImpl.this.sinkCurrentVersionSo(str);
MiniProgramSoState.getInstance().setSoSupported();
}
WeChatMiniProgramServiceImpl.this.mIsInLoadSoProgress = false;
if (z) {
WeChatMiniProgramServiceImpl.this.mApi.preloadWxaProcessEnv(1, new PreloadWxaProcessEnvResultListener() {
@Override
public void onPreloadResult(PreloadWxaProcessEnvResult preloadWxaProcessEnvResult) {
WeChatMiniProgramServiceImpl.this.callbackLoadSoResult(true, null);
}
});
} else {
WeChatMiniProgramServiceImpl.this.callbackLoadSoResult(false, initDynamicPkg.name());
}
}
});
}
public void preloadImpl(final int i) {
BrowserExecutorSupplier.getInstance().getIoExecutor().execute(new Runnable() {
@Override
public void run() {
WeChatMiniProgramServiceImpl.this.mApi.preloadWxaProcessEnv(i, new PreloadWxaProcessEnvResultListener() {
@Override
public void onPreloadResult(PreloadWxaProcessEnvResult preloadWxaProcessEnvResult) {
MiniLogUtil.log("preloadMiniProgramEnv onPreloadResult: " + preloadWxaProcessEnvResult.name());
}
});
}
});
}
public void realNewDownloadDialog(final WxAppLaunchParam wxAppLaunchParam) {
MiniDetailUtil.requestMiniDetail(wxAppLaunchParam.appId, new MiniDetailUtil.DetailCallback() {
@Override
public void onSuccess(WxAppletDetail wxAppletDetail) {
PluginUtils.getInstance().startDownload(wxAppLaunchParam, wxAppletDetail);
}
@Override
public void onSuccess(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
PluginUtils.getInstance().startDownload(wxAppLaunchParam, WeChatMiniProgramServiceImpl.wrap2PBAppletDetail(wxAppletDetail));
}
});
}
public void recordAuth(String str, String str2, String str3) {
UploadUtil.uploadMiniActionEvent(str, str3, str2, 0L, new HashMap());
}
public void recordAuthByCombine(boolean z) {
if (z) {
((IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class)).auth();
}
PublicSettingManager.a().setBoolean("IS_FROM_COMBINE_AUTH", z);
}
public void recordHistoryWeChatMiniProgram(String str) {
MiniDetailUtil.requestMiniDetail(str, new MiniDetailUtil.DetailCallback() {
@Override
public void onSuccess(WxAppletDetail wxAppletDetail) {
HashSet<MiniProgramHistoryEntity> sourceHistoryList = HistoryUtils.sourceHistoryList();
MiniProgramHistoryEntity miniProgramHistoryEntity = new MiniProgramHistoryEntity(wxAppletDetail.sAppId, wxAppletDetail.sName, wxAppletDetail.sIcon, true, WeChatMiniProgramServiceImpl.fixTimestamp(sourceHistoryList));
miniProgramHistoryEntity.setWording(wxAppletDetail.sWording);
sourceHistoryList.remove(miniProgramHistoryEntity);
sourceHistoryList.add(miniProgramHistoryEntity);
HistoryUtils.sinkHistoryList(sourceHistoryList);
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public void run() {
Iterator it = WeChatMiniProgramServiceImpl.this.mListeners.iterator();
while (it.hasNext()) {
((MiniProgramHistoryRefreshListener) it.next()).c();
}
}
});
}
@Override
public void onSuccess(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
WeChatMiniProgramServiceImpl.sinkTop1000History(wxAppletDetail);
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public void run() {
Iterator it = WeChatMiniProgramServiceImpl.this.mListeners.iterator();
while (it.hasNext()) {
((MiniProgramHistoryRefreshListener) it.next()).c();
}
}
});
}
});
}
private void recordPreloadAction(MiniPreloadParams miniPreloadParams, int i) {
for (MiniPreloadParams.MiniAppInfo miniAppInfo : miniPreloadParams.f74958a) {
uploadPreloadAction(miniAppInfo.f74962a, miniAppInfo.f74963b, i, miniPreloadParams.f74959b, miniPreloadParams.f74960c, miniPreloadParams.f74961d);
}
}
private void recordPreloadStatus(String str) {
Set<String> stringSet = PublicSettingManager.a().getStringSet("MINI_PRELOAD_APP_ID", new HashSet());
stringSet.add(str);
PublicSettingManager.a().putStringSet("MINI_PRELOAD_APP_ID", stringSet);
}
public void recordStep(String str, int i) {
recordStep(str, i, "");
}
public void recordStep(String str, int i, String str2) {
((IWeChatMiniActionCheckerService) SDKContext.getInstance().getService(IWeChatMiniActionCheckerService.class)).recordOpenStep(str, i, str2);
}
public void refreshAuthState(TdiAuthState tdiAuthState) {
int i;
if (tdiAuthState == TdiAuthState.WechatTdi_Auth_State_OK) {
((IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class)).trySetAuth();
return;
}
if (tdiAuthState == TdiAuthState.WechatTdi_Auth_State_Expired) {
i = 6;
} else if (tdiAuthState != TdiAuthState.WechatTdi_Auth_State_NoAuth) {
return;
} else {
i = 2;
}
refreshLocalAuthState(i);
}
public void refreshLocalAuthState(int i) {
IMiniAuthStateService iMiniAuthStateService = (IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class);
if (i == -3) {
iMiniAuthStateService.refuseOrCancel();
return;
}
if (i == 6) {
iMiniAuthStateService.expire();
} else if (i == 1) {
iMiniAuthStateService.auth();
} else {
if (i != 2) {
return;
}
iMiniAuthStateService.needAuth();
}
}
private void requestBlackListProto() {
weappBaseInfoPortal.GetWxAppletBlackListReq.Builder newBuilder = weappBaseInfoPortal.GetWxAppletBlackListReq.newBuilder();
newBuilder.setGuid(AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_GUID));
newBuilder.setQua2(AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_QUA2_3));
weappBaseInfoPortal.GetWxAppletBlackListReq build = newBuilder.build();
WUPRequest wUPRequest = new WUPRequest(SEVER_NAME, GET_BLACK_LIST_FUN_NAME);
wUPRequest.setDataType(1);
wUPRequest.a(build.toByteArray());
wUPRequest.setRequestCallBack(new IWUPRequestCallBack() {
@Override
public void onWUPTaskFail(WUPRequestBase wUPRequestBase) {
MiniLogUtil.log("requestBlackList failed: " + wUPRequestBase.getFailedReason());
}
@Override
public void onWUPTaskSuccess(WUPRequestBase wUPRequestBase, WUPResponseBase wUPResponseBase) {
if (WeChatMiniProgramServiceImpl.this.baseCheckResponse(wUPResponseBase)) {
weappBaseInfoPortal.GetWxAppletBlackListRsp getWxAppletBlackListRsp = (weappBaseInfoPortal.GetWxAppletBlackListRsp) wUPResponseBase.get(weappBaseInfoPortal.GetWxAppletBlackListRsp.class);
if (getWxAppletBlackListRsp == null) {
MiniLogUtil.log("Parsing data is empty");
} else {
WeChatMiniProgramServiceImpl.this.handleBlackListProto(getWxAppletBlackListRsp.getBlacklistList());
}
}
}
});
WUPTaskProxy.send(wUPRequest);
}
static boolean requestDiff(String str, final String str2, final String str3, String str4) {
byte[] byteArray = diffpkg.diffpkgReq.newBuilder().setPkgName(str).setBasePkgMd5(str2).setTargetPkgVer(str3).setGuid(str4).build().toByteArray();
WUPRequest wUPRequest = new WUPRequest("trpc.PF.DiffPkgServer.Greeter", "/trpc.PF.DiffPkgServer.Greeter/getDiffpkgUrl", new IWUPRequestCallBack() {
@Override
public void onWUPTaskFail(WUPRequestBase wUPRequestBase) {
}
@Override
public void onWUPTaskSuccess(WUPRequestBase wUPRequestBase, WUPResponseBase wUPResponseBase) {
diffpkg.diffpkgRsp diffpkgrsp = (diffpkg.diffpkgRsp) wUPResponseBase.get(diffpkg.diffpkgRsp.class);
String diffPkgUrl = diffpkgrsp.getDiffPkgUrl();
if (diffpkgrsp.getRet() == 0) {
WeChatMiniProgramServiceImpl.setPatchInfo(diffpkgrsp.getDiffPkgMd5(), diffpkgrsp.getTargetPkgMd5(), diffPkgUrl, str2, str3);
}
}
});
wUPRequest.setDataType(1);
wUPRequest.a(byteArray);
return WUPTaskProxy.send(wUPRequest);
}
private void requestRecommendListProto(final HashSet<MiniProgramHistoryEntity> hashSet, final RecentCallback recentCallback) {
weappBaseInfoPortal.GetWxAppletOpListReq.Builder newBuilder = weappBaseInfoPortal.GetWxAppletOpListReq.newBuilder();
newBuilder.setQua2(AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_QUA2_3));
newBuilder.setGuid(AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_GUID));
weappBaseInfoPortal.GetWxAppletOpListReq build = newBuilder.build();
WUPRequest wUPRequest = new WUPRequest(SEVER_NAME, GET_OP_LIST_FUN_NAME);
wUPRequest.setDataType(1);
wUPRequest.a(build.toByteArray());
wUPRequest.setRequestCallBack(new IWUPRequestCallBack() {
@Override
public void onWUPTaskFail(WUPRequestBase wUPRequestBase) {
recentCallback.d();
MiniLogUtil.log("requestRecentUseList failed");
}
@Override
public void onWUPTaskSuccess(WUPRequestBase wUPRequestBase, WUPResponseBase wUPResponseBase) {
String str;
if (WeChatMiniProgramServiceImpl.this.baseCheckResponse(wUPResponseBase)) {
weappBaseInfoPortal.GetWxAppletOpListRsp getWxAppletOpListRsp = (weappBaseInfoPortal.GetWxAppletOpListRsp) wUPResponseBase.get(weappBaseInfoPortal.GetWxAppletOpListRsp.class);
if (getWxAppletOpListRsp == null) {
str = "Parsing data is empty";
} else {
List<weappBaseInfoPortal.WxAppletDetail> opListList = getWxAppletOpListRsp.getOpListList();
ArrayList arrayList = new ArrayList(hashSet);
Collections.sort(arrayList);
if (opListList != null && opListList.size() > 0) {
for (weappBaseInfoPortal.WxAppletDetail wxAppletDetail : opListList) {
MiniProgramHistoryEntity miniProgramHistoryEntity = new MiniProgramHistoryEntity(wxAppletDetail.getAppID(), wxAppletDetail.getName(), wxAppletDetail.getIcon(), true, SystemClock.elapsedRealtime());
if (!hashSet.contains(miniProgramHistoryEntity)) {
arrayList.add(miniProgramHistoryEntity);
}
}
}
recentCallback.a(arrayList);
str = "requestRecentUseList success";
}
MiniLogUtil.log(str);
}
}
});
WUPTaskProxy.send(wUPRequest);
requestBlackListProto();
}
public void sendAuthAndOpenMiniProgram(WxAppLaunchParam wxAppLaunchParam) {
if (enableMiniProgramMode()) {
sendAuthImpl(wxAppLaunchParam);
}
}
private void sendAuthOldWay(final WxAppLaunchParam wxAppLaunchParam) {
MiniLogUtil.log("sendAuthOldWay");
wxAppLaunchParam.isFromNewAuthWay = false;
UploadUtil.uploadMiniActionEvent(wxAppLaunchParam.isFromRetryAuth ? UploadUtil.RETRY_AUTH_ACTION : UploadUtil.AUTH_ACTION, "", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
if (wxAppLaunchParam.needShowDialog) {
displayGuideAuthDialogInMainThread("", "", new OnGoToSendAuthListener() {
@Override
public void go() {
WeChatMiniProgramServiceImpl.this.sendAuthOldWayImpl(wxAppLaunchParam);
}
});
} else {
sendAuthOldWayImpl(wxAppLaunchParam);
}
}
public void sendAuthOldWayImpl(final WxAppLaunchParam wxAppLaunchParam) {
recordStep(wxAppLaunchParam.uuid, 6, "OLD");
DebugDialogUtil.getInstance().printLog("即将开始 sendAuth（老授权模式）");
if (this.mApi == null) {
MiniLogUtil.log("sendAuthOldWayImpl mApi is null");
} else {
detectAuthState();
this.mApi.sendAuth(new TdiAuthListener() {
@Override
public void onAuthFinish(TdiAuthErrCode tdiAuthErrCode, String str) {
DebugDialogUtil.getInstance().printLog("授权结果：" + tdiAuthErrCode.name());
if (tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_OK) {
WeChatMiniProgramServiceImpl.this.recordAuthByCombine(false);
}
WeChatMiniProgramServiceImpl.this.recordStep(wxAppLaunchParam.uuid, 8, String.format("%s_%s", "OLD", tdiAuthErrCode.name()));
WeChatMiniProgramServiceImpl.this.handleAuthResult(tdiAuthErrCode, str, wxAppLaunchParam);
}
});
}
}
private void sendCombineAuth(WxAppLaunchParam wxAppLaunchParam) {
MiniLogUtil.log("sendCombineAuth");
SendAuth.Req req = new SendAuth.Req();
req.scope = "snsapi_userinfo";
req.state = String.valueOf(System.currentTimeMillis());
req.transaction = String.format("%d%s", Long.valueOf(System.currentTimeMillis()), "MiniCombine");
PublicSettingManager.a().setString("MINI_AUTH_TRANSACTION", req.transaction);
wxAppLaunchParam.isFromNewAuthWay = true;
UploadUtil.uploadMiniActionEvent(wxAppLaunchParam.isFromRetryAuth ? UploadUtil.COMBINE_RETRY_AUTH_ACTION : UploadUtil.COMBINE_AUTH_ACTION, "1", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
sendCombineAuthImpl(wxAppLaunchParam, req);
}
private void sendCombineAuthAndLoginQB(final WxAppLaunchParam wxAppLaunchParam) {
if (wxAppLaunchParam.needShowDialog) {
displayGuideAuthDialogInMainThread("即将跳转去微信登录", "登录后即可体验小程序服务", new OnGoToSendAuthListener() {
@Override
public void go() {
WeChatMiniProgramServiceImpl.this.sendCombineAuthAndLoginQBImpl(wxAppLaunchParam);
}
});
} else {
sendCombineAuthAndLoginQBImpl(wxAppLaunchParam);
}
}
public void sendCombineAuthAndLoginQBImpl(final WxAppLaunchParam wxAppLaunchParam) {
wxAppLaunchParam.isFromNewAuthWay = true;
UploadUtil.uploadMiniActionEvent(wxAppLaunchParam.isFromRetryAuth ? UploadUtil.COMBINE_RETRY_AUTH_ACTION : UploadUtil.COMBINE_AUTH_ACTION, "2", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
recordStep(wxAppLaunchParam.uuid, 6, String.format("%s_%s", "NEW", "2"));
detectAuthState();
IAccountService iAccountService = (IAccountService) SDKContext.getInstance().getService(IAccountService.class);
Bundle bundle = new Bundle();
bundle.putString(AccountConst.FROM_HOST, "10101");
DebugDialogUtil.getInstance().printLog("即将开始 sendCombineAuth（新授权模式并微信登录QB）");
iAccountService.doQuickLoginMiniProgram(bundle, new AuthStateCallback() {
@Override
public void onSendAuthFinish(MiniAuthErrCode miniAuthErrCode, String str) {
DebugDialogUtil.getInstance().printLog("授权结果：" + miniAuthErrCode.name());
TdiAuthErrCode parseErrorCode = WeChatMiniProgramServiceImpl.this.parseErrorCode(miniAuthErrCode);
WeChatMiniProgramServiceImpl.this.recordStep(wxAppLaunchParam.uuid, 8, String.format("%s_%s", "NEW", miniAuthErrCode.name()));
WeChatMiniProgramServiceImpl.this.handleAuthResult(parseErrorCode, str, wxAppLaunchParam);
}
});
}
private void sendCombineAuthImpl(final WxAppLaunchParam wxAppLaunchParam, SendAuth.Req req) {
recordStep(wxAppLaunchParam.uuid, 6, String.format("%s_%s", "NEW", "1"));
DebugDialogUtil.getInstance().printLog("即将开始 sendCombineAuth（新授权模式）");
if (this.mApi == null) {
MiniLogUtil.log("sendCombineAuthImpl mApi is null");
} else {
detectAuthState();
this.mApi.sendCombineAuth(req, new IWXAPIEventHandler() {
@Override
public void onReq(BaseReq baseReq) {
}
@Override
public void onResp(BaseResp baseResp) {
}
}, new TdiAuthListener() {
@Override
public void onAuthFinish(TdiAuthErrCode tdiAuthErrCode, String str) {
DebugDialogUtil.getInstance().printLog("授权结果：" + tdiAuthErrCode.name());
WeChatMiniProgramServiceImpl.this.recordAuthByCombine(tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_OK);
WeChatMiniProgramServiceImpl.this.recordStep(wxAppLaunchParam.uuid, 8, String.format("%s_%s", "NEW", tdiAuthErrCode.name()));
WeChatMiniProgramServiceImpl.this.handleAuthResult(tdiAuthErrCode, str, wxAppLaunchParam);
}
});
}
}
static void setPatchInfo(String str, String str2, String str3, String str4, String str5) {
if (MiniProgramPatchPreferenceReceiver.hasEmptyString(str4, str2, str, str3, str5)) {
return;
}
MiniProgramPatchConfigCacheHolder.getInstance().setBaseMd5(str4);
MiniProgramPatchConfigCacheHolder.getInstance().setTargetMd5(str2);
MiniProgramPatchConfigCacheHolder.getInstance().setPatchMd5(str);
MiniProgramPatchConfigCacheHolder.getInstance().setPatchUrl(str3);
MiniProgramPatchConfigCacheHolder.getInstance().setUpdateVersion(str5);
MiniProgramPatchConfigCacheHolder.getInstance().setWifiTask(true);
MiniProgramPatchPreferenceReceiver.updateIfNeed(str4, str2, str, str3, str5, true);
}
private void showEducationDialog(String str, WxAppLaunchParam wxAppLaunchParam) {
EducationUserUtil.updateTimeStamp();
String str2 = wxAppLaunchParam.extras.get("source");
if (EducationUserUtil.canShowDialog(str2)) {
showEducationDialog(str2, str, wxAppLaunchParam);
} else {
wxAppLaunchParam.callback.onFailed(1005, str, wxAppLaunchParam.uuid);
}
}
private void showWxLoginDialog(final WxAppLaunchParam wxAppLaunchParam) {
MiniLogUtil.log("WeChatMiniProgram｜showWxLoginDialog showWxLoginDialog start");
StatManager.b().c("XCX80000");
final Bundle bundle = new Bundle();
bundle.putBoolean("param_key_force_weapp_way", true);
bundle.putInt(QQShareActivity.KEY_FROM_WHERE, 10119);
final boolean[] zArr = {false};
if (QBUIAppEngine.getInstance().getCurrentActivity() != null) {
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public final void run() {
WeChatMiniProgramServiceImpl.this.lambda$showWxLoginDialog$0$WeChatMiniProgramServiceImpl(bundle, zArr, wxAppLaunchParam);
}
});
}
}
private void sinkSoInner(String str) {
String historySoDir = getHistorySoDir();
try {
FileUtils.c(new File(historySoDir));
} catch (IOException | IllegalArgumentException unused) {
}
MiniLogUtil.log("sink so result: " + FileUtils.b(str, String.format("%s%s%s", historySoDir, File.separator, WeChatMiniProgramConstant.HISTORY_SO_FILE_NAME)));
}
protected static void sinkTop1000History(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
List arrayList = new ArrayList(HistoryUtils.sourceHistoryList());
Collections.sort(arrayList);
if (arrayList.size() > 1000) {
arrayList = arrayList.subList(0, 999);
}
HashSet hashSet = new HashSet(arrayList);
MiniProgramHistoryEntity miniProgramHistoryEntity = new MiniProgramHistoryEntity(wxAppletDetail.getAppID(), wxAppletDetail.getName(), wxAppletDetail.getIcon(), true, fixTimestamp(hashSet), wxAppletDetail.getExtJson(), wxAppletDetail.getWording());
hashSet.remove(miniProgramHistoryEntity);
hashSet.add(miniProgramHistoryEntity);
HistoryUtils.sinkHistoryList(hashSet);
}
private Set<MiniProgramHistoryEntity> sourceBlackList() {
HashSet hashSet = new HashSet();
String string = PublicSettingManager.a().getString(WeChatMiniProgramConstant.BLACK_LIST, "");
if (!TextUtils.isEmpty(string)) {
String[] split = string.split(Constants.ACCEPT_TIME_SEPARATOR_SP);
if (split.length != 0) {
for (String str : split) {
hashSet.add(new MiniProgramHistoryEntity(str));
}
}
}
return hashSet;
}
private void startIntervalUpload(String str, final MiniProgramUploadEntity miniProgramUploadEntity) {
Runnable runnable = new Runnable() {
@Override
public void run() {
FeedsLogUtils.uploadTimeInterval(miniProgramUploadEntity);
}
};
ScheduledExecutorService newSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
newSingleThreadScheduledExecutor.scheduleAtFixedRate(runnable, 300L, 300L, TimeUnit.SECONDS);
this.mMiniProgramTimeScheduledMap.put(str, newSingleThreadScheduledExecutor);
MiniLogUtil.log("start IntervalUpload componentName: " + str);
}
private void startTimeUnit(MiniProgramUploadEntity miniProgramUploadEntity) {
if (miniProgramUploadEntity == null) {
return;
}
startIntervalUpload(miniProgramUploadEntity.getComponentName(), miniProgramUploadEntity);
IUnitTimeHelper unitTimeHelper = TimeLogUtils.getUnitTimeHelper();
this.mMiniTimeHelper.put(miniProgramUploadEntity.getComponentName(), unitTimeHelper);
TimeLogUtils.onUnitTimeStart(miniProgramUploadEntity.getAppId(), miniProgramUploadEntity.getExtras(), unitTimeHelper);
}
private void uploadAndShowErrorPage(String str, String str2, TdiAuthErrCode tdiAuthErrCode, MiniProgramOpenCallback miniProgramOpenCallback) {
if (tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_System || tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_NormalErr) {
UploadUtil.uploadXLogSdk();
}
miniProgramOpenCallback.onFailed(1005, tdiAuthErrCode.name(), str2);
ErrorPageDialog.showErrorPage(str, "微信授权失败，无法正常使用小程序");
}
private void uploadClickEvent(WxAppLaunchParam wxAppLaunchParam) {
FeedsLogUtils.uploadClickEvent((Object) wxAppLaunchParam.extras, true);
UploadUtil.uploadClickEvent(wxAppLaunchParam);
}
private void uploadOpenSdkAction() {
UploadUtil.uploadMiniActionEvent("jump", "", this.mWxParam.uuid, 0L, this.mWxParam.extras);
UploadUtil.uploadMiniActionEvent(a.ad, "", this.mWxParam.uuid, 0L, this.mWxParam.extras);
}
private void uploadPreloadAction(String str, String str2, int i, String str3, String str4, String str5) {
HashMap hashMap = new HashMap();
hashMap.put("sub_eventcode", "preload");
hashMap.put("user_type", MiniAuthStateServiceImpl.getInstance().getAuthState() == 1 ? "1" : "2");
hashMap.put("start_time", String.valueOf(System.currentTimeMillis() / 1000));
hashMap.put("resultCode", String.valueOf(i));
hashMap.put(QQShare.SHARE_TO_QQ_MINI_PROGRAM_TYPE, "wx_app");
hashMap.put("mini_program_id", str);
hashMap.put("path", str2);
hashMap.put("source", str3);
hashMap.put("scene_id", str4);
hashMap.put("c_scene_id", str5);
hashMap.put("login_status", String.valueOf(getInstance().getUserType()));
StatManager.b().b("mini_program", hashMap);
}
protected static WxAppletDetail wrap2PBAppletDetail(weappBaseInfoPortal.WxAppletDetail wxAppletDetail) {
WxAppletDetail wxAppletDetail2 = new WxAppletDetail();
wxAppletDetail2.sAppId = wxAppletDetail.getAppID();
wxAppletDetail2.sIcon = wxAppletDetail.getIcon();
wxAppletDetail2.sName = wxAppletDetail.getName();
wxAppletDetail2.sWording = wxAppletDetail.getWording();
return wxAppletDetail2;
}
@Override
public void addOnHistoryChangedListener(MiniProgramHistoryRefreshListener miniProgramHistoryRefreshListener) {
this.mListeners.add(miniProgramHistoryRefreshListener);
}
@Override
public void addSoPluginListener(SoDownloadPluginShowListener soDownloadPluginShowListener) {
this.mPluginListeners.add(soDownloadPluginShowListener);
}
void appendUseTimeToSourceUrl(String str, MiniProgramUploadEntity miniProgramUploadEntity) {
if (miniProgramUploadEntity.getExtras() instanceof Map) {
Map map = (Map) miniProgramUploadEntity.getExtras();
String sourceUrl = getSourceUrl(str);
if (!TextUtils.isEmpty(sourceUrl)) {
sourceUrl = UrlUtils.addParamsToUrl(sourceUrl, String.format("useTime=%d", Long.valueOf((miniProgramUploadEntity.getEndTimeSpan() - miniProgramUploadEntity.getStartTimeSpan()) / 1000)));
}
map.put("sourceUrl", sourceUrl);
}
}
void backHistory(WxAppLaunchParam wxAppLaunchParam) {
if (wxAppLaunchParam.isNeedBackStack) {
backHistoryImpl();
}
}
void cancelUploadOpenSdkLog(QBTask<Void> qBTask, WxAppLaunchParam wxAppLaunchParam) {
this.mUploadCancellationTokenMap.remove(wxAppLaunchParam.uuid);
if (qBTask.c()) {
MiniLogUtil.log("upload auth log canceled");
} else {
MiniLogUtil.log("upload auth log");
UploadUtil.uploadAuthLogCat();
}
}
void checkAuthStateCallback(TdiAuthState tdiAuthState, WxAppLaunchParam wxAppLaunchParam) {
this.mCheckAuthStateCallbackState.set(true);
UploadUtil.uploadMiniActionEvent(UploadUtil.AUTH_STATE, tdiAuthState == TdiAuthState.WechatTdi_Auth_State_OK ? "1" : "2", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
MiniLogUtil.log("auth state: " + tdiAuthState.name());
boolean z = false;
if (tdiAuthState == TdiAuthState.WechatTdi_Auth_State_OK) {
tryRecordHistory(wxAppLaunchParam.extras, wxAppLaunchParam.appId);
wxAppLaunchParam.isFromSendAuth = false;
openMiniProgramInner(wxAppLaunchParam);
} else {
AccountInfo currentUserInfo = ((IAccount) SDKContext.getInstance().getService(IAccount.class)).getCurrentUserInfo();
if (currentUserInfo != null) {
z = currentUserInfo.isLogined();
} else {
MiniLogUtil.log("WeChatMiniProgram｜getCurrentUserInfo is null");
}
boolean a2 = FeatureToggle.a(BuildConfig.FEATURE_TOGGLE_869483217);
MiniLogUtil.log("WeChatMiniProgram｜checkAuthStateCallback: isLogined=" + z + ",featureIsOn=" + a2);
if (!a2 || z || wxAppLaunchParam.extras == null || !MiniProgramSource.USER_CENTER_RECENTLY_USED.equals(wxAppLaunchParam.extras.get("source"))) {
wxAppLaunchParam.needShowDialog = true;
sendAuthAndOpenMiniProgram(wxAppLaunchParam);
} else {
showWxLoginDialog(wxAppLaunchParam);
}
}
refreshAuthState(tdiAuthState);
}
void checkAuthStateImpl(WxAppLaunchParam wxAppLaunchParam) {
UploadUtil.uploadMiniActionEvent(UploadUtil.CHECK_AUTH_STATE, "", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
MiniLogUtil.log("prepare checkAuthState");
if (!this.mCheckAuthStateCallbackState.get()) {
UploadUtil.uploadXLogSdk();
}
this.mCheckAuthStateCallbackState.set(false);
checkAuthStateInner(wxAppLaunchParam);
}
void checkMiniSoResultInOpenAction(boolean z, WxAppLaunchParam wxAppLaunchParam) {
DebugDialogUtil debugDialogUtil = DebugDialogUtil.getInstance();
StringBuilder sb = new StringBuilder();
sb.append("测插件状态：");
sb.append(z ? "已安装" : "未安装");
debugDialogUtil.printLog(sb.toString());
UploadUtil.uploadMiniActionEvent(UploadUtil.SO_STATE_ACTION, isHistoryFileExists() ? "3" : z ? "1" : "2", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
recordStep(wxAppLaunchParam.uuid, 3);
if (z) {
checkAuthStateImpl(wxAppLaunchParam);
} else {
MiniLogUtil.log("so file is not exist");
displayNewDownloadSoDialog(wxAppLaunchParam);
}
}
void checkSoInner() {
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
if (z) {
return;
}
WeChatMiniProgramServiceImpl.this.tryInstallLocalFile(new LoadSoCallback() {
@Override
public void failed(String str) {
WeChatMiniProgramServiceImpl.this.downloadSoInner();
}
@Override
public void success() {
MiniLogUtil.log("本地插件安装成功");
}
});
}
});
}
void checkSocialType(final WxAppLaunchParam wxAppLaunchParam, IAccountService iAccountService) {
final CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
iAccountService.querySocialType(new QuerySocialTypeCallback() {
@Override
public void onResult(QuerySocialTypeCallback.SocialType socialType) {
MiniLogUtil.log("query social type result: " + socialType.name());
cancellationTokenSource.c();
WeChatMiniProgramServiceImpl.this.handleSocialType(wxAppLaunchParam, socialType);
}
});
QBTask.a(3000L).a((Continuation<Void, TContinuationResult>) new Continuation<Void, Object>() {
@Override
public Object then(QBTask<Void> qBTask) throws Exception {
MiniLogUtil.log("query social type timeout");
WeChatMiniProgramServiceImpl.this.handleSocialType(wxAppLaunchParam, QuerySocialTypeCallback.SocialType.UNKNOWN);
return null;
}
}, cancellationTokenSource.b());
}
void checkWxApp(WxAppLaunchParam wxAppLaunchParam) {
String str;
long elapsedRealtime;
Map<String, String> map;
String str2;
String str3;
if (PackageUtils.b("com.tencent.mm", ContextHolder.getAppContext()) != null) {
DebugDialogUtil.getInstance().printLog("微信版本客户端版本低于7.0.15");
str = wxAppLaunchParam.uuid;
elapsedRealtime = SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime;
map = wxAppLaunchParam.extras;
str2 = UploadUtil.CHECK_WECHAT_ACTION;
str3 = "2";
} else {
DebugDialogUtil.getInstance().printLog("未安装微信客户端");
str = wxAppLaunchParam.uuid;
elapsedRealtime = SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime;
map = wxAppLaunchParam.extras;
str2 = UploadUtil.CHECK_WECHAT_ACTION;
str3 = "3";
}
UploadUtil.uploadMiniActionEvent(str2, str3, str, elapsedRealtime, map);
}
@Override
public boolean checkWxAppEnable() {
if (!this.mIsWeChatVersionInit) {
this.mIsWeChatVersionInit = true;
if (FeatureToggle.a(BuildConfig.BUG_TOGGLE_MINI_PRIVACY_94762837) || BootFeatureToggle.c()) {
checkWxAppByPackageInfo();
} else {
this.mIsWeChatVersionEnable = checkWxAppEnableImpl();
}
}
return this.mIsWeChatVersionEnable;
}
@Override
public boolean clearAuth() {
WxaApi wxaApi;
if (!enableMiniProgramMode() || (wxaApi = this.mApi) == null) {
return false;
}
wxaApi.clearAuth();
return true;
}
void clearLocalParam(String str) {
if (this.mWxParam == null || !TextUtils.equals(this.mWxParam.appId, str)) {
return;
}
this.mWxParam = null;
}
MiniAuthErrCode convertErrorCode(TdiAuthErrCode tdiAuthErrCode) {
if (tdiAuthErrCode == null) {
return MiniAuthErrCode.Auth_Err_NULL;
}
switch (tdiAuthErrCode) {
case WechatTdi_Auth_Err_OK:
return MiniAuthErrCode.Auth_Err_OK;
case WechatTdi_Auth_Err_UserCanceled:
return MiniAuthErrCode.Auth_Err_UserCanceled;
case WechatTdi_Auth_Err_UserDenied:
return MiniAuthErrCode.Auth_Err_UserDenied;
case WechatTdi_Auth_Err_System:
return MiniAuthErrCode.Auth_Err_System;
case WechatTdi_Auth_Err_InvalidArgs:
return MiniAuthErrCode.Auth_Err_InvalidArgs;
case WechatTdi_Auth_Err_NormalErr:
return MiniAuthErrCode.Auth_Err_NormalErr;
case WechatTdi_Auth_Err_WechatNotInstalled:
return MiniAuthErrCode.Auth_Err_WechatNotInstalled;
case WechatTdi_Auth_Err_WechatVersionTooLow:
return MiniAuthErrCode.Auth_Err_WechatVersionTooLow;
case WechatTdi_Auth_Err_ActiveDeviceFailed:
return MiniAuthErrCode.Auth_Err_ActiveDeviceFailed;
case WechatTdi_Auth_Err_Dynamic_Pkg_Not_Loaded:
return MiniAuthErrCode.Auth_Err_Dynamic_Pkg_Not_Loaded;
default:
return MiniAuthErrCode.Auth_Err_UNKOWN;
}
}
MiniAuthState convertTdiAuthState(TdiAuthState tdiAuthState) {
if (tdiAuthState == null) {
return MiniAuthState.Auth_State_API_NULL;
}
int i = AnonymousClass55.$SwitchMap$com$tencent$luggage$wxaapi$TdiAuthState[tdiAuthState.ordinal()];
return i != 1 ? i != 2 ? i != 3 ? MiniAuthState.Auth_State_UNKOWN : MiniAuthState.Auth_State_Expired : MiniAuthState.Auth_State_NoAuth : MiniAuthState.Auth_State_OK;
}
void detectAuthState() {
if (PublicSettingManager.a().getInt(WeChatMiniProgramConstant.DEBUG_AUTH_MODE_KEY, 0) != 1) {
return;
}
this.mDebugPauseCancellationToken = new CancellationTokenSource();
QBTask.a(3000L).a((Continuation<Void, TContinuationResult>) new Continuation<Void, Object>() {
@Override
public Object then(QBTask<Void> qBTask) throws Exception {
WeChatMiniProgramServiceImpl.this.displayAlertDialog();
return null;
}
}, 6, this.mDebugPauseCancellationToken.b());
}
void detectCallback() {
if (PublicSettingManager.a().getInt(WeChatMiniProgramConstant.DEBUG_AUTH_MODE_KEY, 0) != 1) {
return;
}
QBTask.a(3000L).a((Continuation<Void, TContinuationResult>) new Continuation<Void, Object>() {
@Override
public Object then(QBTask<Void> qBTask) throws Exception {
if (!WeChatMiniProgramServiceImpl.this.mIsInAuth) {
return null;
}
WeChatMiniProgramServiceImpl weChatMiniProgramServiceImpl = WeChatMiniProgramServiceImpl.this;
weChatMiniProgramServiceImpl.mIsInAuth = false;
weChatMiniProgramServiceImpl.displayAlertDialog();
return null;
}
}, 6);
}
void displayAlertDialog() {
ICommonDialogBuilder a2 = SimpleDialogBuilder.a();
a2.e("中奖啦，快去上传日志吧");
a2.f("联系 aliciazhang/pushengshen 领取奖励吧");
a2.a((CharSequence) "上传日志");
a2.b(false);
a2.a(new IDialogBuilder.BackListener() {
@Override
public boolean handleBack(DialogBase dialogBase) {
dialogBase.dismiss();
return true;
}
});
a2.a_(new ViewOnClickListener() {
@Override
public void onClick(View view, DialogBase dialogBase) {
MttToaster.show("快去领取奖励吧。", 1);
dialogBase.dismiss();
}
});
a2.a(new DialogInterface.OnShowListener() {
@Override
public void onShow(DialogInterface dialogInterface) {
UploadUtil.uploadXlogAndLog();
}
});
a2.e();
}
void displayGuideAuthDialogInMainThread(String str, String str2, OnGoToSendAuthListener onGoToSendAuthListener) {
if (onGoToSendAuthListener == null) {
return;
}
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new AnonymousClass25(str, str2, onGoToSendAuthListener));
}
void displayNewDownloadSoDialog(final WxAppLaunchParam wxAppLaunchParam) {
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public void run() {
boolean z = PublicSettingManager.a().getBoolean(WeChatMiniProgramConstant.FIRST_SHOW_SO_MINI, true);
if (!DownLoadSoUtils.isInDownloadProgress() || z) {
WeChatMiniProgramServiceImpl.this.displayNewGuideDialog(wxAppLaunchParam);
} else {
WeChatMiniProgramServiceImpl.this.realNewDownloadDialog(wxAppLaunchParam);
}
}
});
}
void displayNewGuideDialog(final WxAppLaunchParam wxAppLaunchParam) {
ICommonDialogBuilder a2 = SimpleDialogBuilder.a();
a2.e("首次使用小程序需要后台准备插件");
a2.f("插件大小：35MB");
a2.a((CharSequence) "好");
a2.c("取消");
a2.b(false);
a2.a(new IDialogBuilder.BackListener() {
@Override
public boolean handleBack(DialogBase dialogBase) {
StatManager.b().c("XCX00034");
H5FallbackUtils.handleBackToH5(wxAppLaunchParam.extras);
dialogBase.dismiss();
return true;
}
});
a2.a_(new ViewOnClickListener() {
@Override
public void onClick(View view, DialogBase dialogBase) {
dialogBase.dismiss();
StatManager.b().c("XCX00033");
WeChatMiniProgramServiceImpl.this.realNewDownloadDialog(wxAppLaunchParam);
}
});
a2.c(new ViewOnClickListener() {
@Override
public void onClick(View view, DialogBase dialogBase) {
H5FallbackUtils.handleBackToH5(wxAppLaunchParam.extras);
StatManager.b().c("XCX00034");
dialogBase.dismiss();
}
});
a2.a(new DialogInterface.OnShowListener() {
@Override
public void onShow(DialogInterface dialogInterface) {
StatManager.b().c("XCX00032");
}
});
a2.e();
PublicSettingManager.a().setBoolean(WeChatMiniProgramConstant.FIRST_SHOW_SO_MINI, false);
}
@Override
public void doPrepareSoStep() {
if (this.mDonePrepareSoStep) {
return;
}
if (BootFeatureToggle.c()) {
MiniProgramSoState.getInstance().reInit();
}
PlatformStatUtils.a(DOLOAD_WECHATMINIPROGRAM);
initMiniProgramBlackList();
downloadSo();
preloadMiniProgramEnv(1);
initUserInfo();
((IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class)).init();
uploadUgaData();
initCloseEvent();
if (FeatureToggle.a(BuildConfig.BUG_TOGGLE_MINI_OAS_VENUS_89682005)) {
uploadOasToVenus();
}
requestWidgetMiniProgramList();
this.mDonePrepareSoStep = true;
}
@Override
public void downloadSo() {
MiniLogUtil.log("downloadSo...");
if (enableMiniProgramMode()) {
if (Build.VERSION.SDK_INT < 21) {
MiniLogUtil.log("downloadSo system api less than 21");
} else {
checkSoInner();
}
}
}
void downloadSoImpl() {
SoDownloadManager.getInstance().startDownloadSo(true);
}
int downloadSoInner() {
if (this.mApi == null) {
return 0;
}
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
WeChatMiniProgramServiceImpl.this.downloadSoInnerImpl(z);
}
});
return 1;
}
void downloadSoInnerImpl(boolean z) {
String str;
if (z) {
str = PREPARED_WECHATMINIPROGRAM;
} else {
if (!PreDownloadUtils.tryLoadPreloadDownloadSo()) {
if (FeatureSwitcher.a(qb.javaswitch.BuildConfig.FEATURE_SWITCHER_DIFF_APPLIER)) {
MiniProgramPatchTask miniProgramPatchTask = new MiniProgramPatchTask();
if (PatchTaskManager.Companion.getInstance(miniProgramPatchTask.getPatchConfig().getBusinessTag()).executeTask(miniProgramPatchTask)) {
return;
}
}
PlatformStatUtils.a(STAT_WXMINI_FLOWCTRL_REQ);
this.mFlowCtrlHelper.a(WeChatMiniProgramConstant.SO_DOWNLOAD_URL);
PreDownloadUtils.tryPreDownloadSo(PreDownloadUtils.sourcePreDownloadInfo());
}
str = USEDOWNLOADED_WECHATMINIPROGRAM;
}
PlatformStatUtils.a(str);
PreDownloadUtils.tryPreDownloadSo(PreDownloadUtils.sourcePreDownloadInfo());
}
JSONObject emitDetail(String str, weappBaseInfoPortal.WxAppletDetail wxAppletDetail, String str2) {
JSONObject jSONObject = new JSONObject();
try {
jSONObject.put("qbUrl", str2);
jSONObject.put("iconUrl", wxAppletDetail.getIcon());
jSONObject.put("name", wxAppletDetail.getName());
} catch (JSONException unused) {
}
EventEmiter.getDefault().emit(new EventMessage(str, jSONObject.toString()));
return jSONObject;
}
@Override
public void enableDebug() {
this.mDebuggable = true;
}
@Override
public boolean enableMiniProgramMode() {
return this.mEnable && getMiniSwitchImpl();
}
@Override
public void getAuthState(final GetAuthStateCallback getAuthStateCallback) {
if (!enableMiniProgramMode()) {
if (getAuthStateCallback != null) {
getAuthStateCallback.onGetAuthState(MiniAuthState.Auth_State_NO_SDK);
return;
}
return;
}
WxaApi wxaApi = this.mApi;
if (wxaApi != null) {
wxaApi.checkAuthState(new TdiAuthCheckStateListener() {
@Override
public void onStateChecked(TdiAuthState tdiAuthState, String str) {
WeChatMiniProgramServiceImpl.this.mIsAuthed = tdiAuthState == TdiAuthState.WechatTdi_Auth_State_OK;
WeChatMiniProgramServiceImpl.this.refreshAuthState(tdiAuthState);
GetAuthStateCallback getAuthStateCallback2 = getAuthStateCallback;
if (getAuthStateCallback2 != null) {
getAuthStateCallback2.onGetAuthState(WeChatMiniProgramServiceImpl.this.convertTdiAuthState(tdiAuthState));
}
}
});
} else if (getAuthStateCallback != null) {
getAuthStateCallback.onGetAuthState(MiniAuthState.Auth_State_API_NULL);
}
}
@Override
public List<MiniProgramHistoryEntity> getHistoryList() {
ArrayList arrayList = new ArrayList();
HashSet<MiniProgramHistoryEntity> sourceHistoryList = HistoryUtils.sourceHistoryList();
Set<MiniProgramHistoryEntity> sourceBlackList = sourceBlackList();
Iterator<MiniProgramHistoryEntity> it = sourceHistoryList.iterator();
while (it.hasNext()) {
MiniProgramHistoryEntity next = it.next();
if (!sourceBlackList.contains(next)) {
arrayList.add(next);
}
}
Collections.sort(arrayList);
return arrayList;
}
@Override
public String getMiniSdkVersion() {
WxaApi wxaApi;
return (enableMiniProgramMode() && (wxaApi = this.mApi) != null) ? wxaApi.getSDKVersion() : "";
}
public CopyOnWriteArrayList<SoDownloadPluginShowListener> getPluginListeners() {
return this.mPluginListeners;
}
@Override
public int getPluginMode() {
return this.mPluginMode;
}
String getSourceUrl(String str) {
MiniProgramUploadEntity miniProgramUploadEntity = this.mUploadData.get(str);
return (miniProgramUploadEntity == null || miniProgramUploadEntity.getExtras() == null) ? "" : (String) ((Map) miniProgramUploadEntity.getExtras()).get("sourceUrl");
}
@Override
public String getTdiUserId() {
WxaApi wxaApi = this.mApi;
return wxaApi == null ? "" : wxaApi.getTdiUserId();
}
public int getUserType() {
return this.mCurrentUserType;
}
@Override
public List<WidgetMiniEntity> getWidgetMiniProgramList() {
if (this.mWidgetMiniEntities.size() == 0) {
handleWidgetResult(new ArrayList());
}
return this.mWidgetMiniEntities;
}
void handleAuthFailed(TdiAuthErrCode tdiAuthErrCode, WxAppLaunchParam wxAppLaunchParam) {
MiniLogUtil.log("handleAuthFailed: " + tdiAuthErrCode.name());
if ((tdiAuthErrCode != TdiAuthErrCode.WechatTdi_Auth_Err_UserCanceled && tdiAuthErrCode != TdiAuthErrCode.WechatTdi_Auth_Err_UserDenied) || wxAppLaunchParam.extras == null) {
uploadAndShowErrorPage(wxAppLaunchParam.appId, wxAppLaunchParam.uuid, tdiAuthErrCode, wxAppLaunchParam.callback);
return;
}
if (TextUtils.equals(wxAppLaunchParam.extras.get(WeChatMiniProgramConstant.NEED_BACKUP), "1")) {
PlatformStatUtils.a(WXMINI_NEED_BACK);
wxAppLaunchParam.callback.onFailed(1005, tdiAuthErrCode.name(), wxAppLaunchParam.uuid);
} else {
MiniLogUtil.log("handleAuthFailed: can not open dialog");
showEducationDialog(tdiAuthErrCode.name(), wxAppLaunchParam);
PlatformStatUtils.a(WXMINI_NOT_NEED_BACK);
}
refreshLocalAuthState(-3);
}
void handleAuthResult(TdiAuthErrCode tdiAuthErrCode, String str, WxAppLaunchParam wxAppLaunchParam) {
int i;
this.mIsInAuth = false;
MiniLogUtil.log("auth result: " + tdiAuthErrCode.name() + " message: " + str);
UploadUtil.uploadAuthResult(wxAppLaunchParam, tdiAuthErrCode.name());
CancellationTokenSource remove = this.mUploadCancellationTokenMap.remove(wxAppLaunchParam.uuid);
if (remove != null) {
remove.c();
}
if (tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_OK) {
tryRecordHistory(wxAppLaunchParam.extras, wxAppLaunchParam.appId);
i = 1;
wxAppLaunchParam.isFromSendAuth = true;
openMiniProgramInner(wxAppLaunchParam);
} else {
handleAuthFailed(tdiAuthErrCode, wxAppLaunchParam);
i = 2;
}
refreshLocalAuthState(i);
}
@Override
public boolean handleIntent(Context context, Intent intent) {
WxaApi wxaApi;
if (enableMiniProgramMode() && (wxaApi = this.mApi) != null) {
return wxaApi.handleIntent(context, intent);
}
return false;
}
void handleSocialType(WxAppLaunchParam wxAppLaunchParam, QuerySocialTypeCallback.SocialType socialType) {
if (this.mAuthRecordIds.contains(wxAppLaunchParam.uuid)) {
MiniLogUtil.log("handleSocialType prevent");
} else {
this.mAuthRecordIds.add(wxAppLaunchParam.uuid);
handleSocialTypeImpl(wxAppLaunchParam, socialType);
}
}
void handleWidgetResult(List<appletGeneralInfoSvr.AppletWidgetInfo> list) {
if (list == null) {
MiniLogUtil.log("WidgetMiniProgramList data is empty");
return;
}
try {
MiniLogUtil.log("requestWidgetMiniProgramList success");
this.mWidgetMiniEntities.clear();
ArrayList arrayList = new ArrayList();
for (appletGeneralInfoSvr.AppletWidgetInfo appletWidgetInfo : list) {
WidgetMiniEntity widgetMiniEntity = new WidgetMiniEntity();
widgetMiniEntity.f74966c = appletWidgetInfo.getJumpUrl();
widgetMiniEntity.f74965b = appletWidgetInfo.getIcon();
widgetMiniEntity.f74964a = appletWidgetInfo.getName();
widgetMiniEntity.f74967d = appletWidgetInfo.getAppid();
MiniLogUtil.log("add recommend entity: " + widgetMiniEntity.toString());
arrayList.add(widgetMiniEntity);
}
List<MiniProgramHistoryEntity> historyList = getHistoryList();
ArrayList arrayList2 = new ArrayList();
for (MiniProgramHistoryEntity miniProgramHistoryEntity : historyList) {
WidgetMiniEntity widgetMiniEntity2 = new WidgetMiniEntity();
widgetMiniEntity2.f74966c = String.format("qb://wxapp/?appid=%s&source=100040", miniProgramHistoryEntity.getAppId());
widgetMiniEntity2.f74965b = miniProgramHistoryEntity.getPortrait();
widgetMiniEntity2.f74964a = miniProgramHistoryEntity.getName();
widgetMiniEntity2.f74967d = miniProgramHistoryEntity.getAppId();
MiniLogUtil.log("add history entity: " + widgetMiniEntity2.toString());
arrayList2.add(widgetMiniEntity2);
}
MiniLogUtil.log("history size: " + arrayList2.size());
this.mWidgetMiniEntities.addAll(historyMergeRecommend(arrayList2, arrayList));
WidgetMiniEntity widgetMiniEntity3 = new WidgetMiniEntity();
widgetMiniEntity3.f74966c = "qb://ext/rn?module=mptab&component=mptab&page=home&coverToolbar=true&orientation=1&shortcut=true&title=服务大厅&isfrom=200003";
widgetMiniEntity3.f74965b = "https://m4.publicimg.browser.qq.com/publicimg/nav/user_center.png";
widgetMiniEntity3.f74964a = "服务大厅";
widgetMiniEntity3.f74967d = "mptab";
this.mWidgetMiniEntities.add(widgetMiniEntity3);
Iterator<WidgetMiniEntity> it = this.mWidgetMiniEntities.iterator();
while (it.hasNext()) {
WidgetMiniEntity next = it.next();
MiniLogUtil.log("widget item: " + next.toString());
ImageHub.a().a(ImageRequester.a(Uri.parse(next.f74965b)));
}
} catch (Exception e) {
MiniLogUtil.log("handleWidgetResult error: " + e.getMessage());
}
}
List<WidgetMiniEntity> historyMergeRecommend(List<WidgetMiniEntity> list, List<WidgetMiniEntity> list2) {
HashSet hashSet = new HashSet();
hashSet.addAll(list);
hashSet.addAll(list2);
ArrayList arrayList = new ArrayList(hashSet);
return arrayList.size() > 3 ? arrayList.subList(0, 3) : arrayList;
}
@Override
public void initApi(Context context, String str, boolean z) {
String str2;
if (enableMiniProgramMode()) {
if (Build.VERSION.SDK_INT < 21) {
str2 = "system api less than 21";
} else {
MiniLogUtil.log("initApi");
String currentProcessName = ThreadUtils.getCurrentProcessName(context);
MiniLogUtil.log("initApi current progress: " + currentProcessName);
String packageName = ContextHolder.getAppContext().getPackageName();
MiniLogUtil.log("initApi packageName: " + packageName);
if ((TextUtils.isEmpty(currentProcessName) || !currentProcessName.equals(packageName)) && !currentProcessName.contains(":wxa_container") && !currentProcessName.contains("com.tencent.ilink")) {
return;
}
MiniLogUtil.log("initApi inner");
if (!TextUtils.isEmpty(str)) {
MiniLogUtil.log("appId: " + str);
if (BootFeatureToggle.c()) {
initApiAndDoPreStepInMainProcess(context, str, z, currentProcessName, packageName);
} else {
initApiImpl(context, str);
}
WeChatMiniProgramConstant.SO_DOWNLOAD_URL = PlatformUtils.isCurrentProcess64Bit() ? "https://dldir1v6.qq.com/invc/tt/QB/Public/plugin/open-sdk-v8a-release-1.6.4.9.zip" : "https://dldir1v6.qq.com/invc/tt/QB/Public/plugin/open-sdk-armeabi-release-1.6.4.9.zip";
MiniLogUtil.log("initApi finished");
if (currentProcessName.contains(":wxa_container")) {
((Application) context).registerActivityLifecycleCallbacks(this);
RqdSdkProxy.a().a(true);
}
if (currentProcessName.equals(packageName) && PublicSettingManager.a().getInt(WeChatMiniProgramConstant.DEBUG_AUTH_MODE_KEY, 0) == 1) {
((Application) context).registerActivityLifecycleCallbacks(new MainActivityListener());
}
if (BootFeatureToggle.c()) {
return;
}
PlatformStatUtils.a(INITAPP_WECHATMINIPROGRAM);
doPrepareSo(currentProcessName, packageName);
return;
}
str2 = "appId is empty";
}
MiniLogUtil.log(str2);
}
}
void initCloseEvent() {
WxaApi wxaApi = this.mApi;
if (wxaApi == null) {
MiniLogUtil.log("initCloseEvent mApi is null...");
} else {
wxaApi.addWxaAppCloseEventListener(new WxaAppCloseEventListener() {
@Override
public void onWxaAppClose(long j, String str) {
WeChatMiniProgramServiceImpl.this.emitMiniEvent("MINI_PROGRAM_ACTIVITY_CLOSE", str, (String) WeChatMiniProgramServiceImpl.this.mOpenUrlMap.remove(str));
}
});
}
}
@Override
public void initMiniProgramBlackList() {
if (enableMiniProgramMode()) {
requestBlackListProto();
((IWeChatMiniActionCheckerService) SDKContext.getInstance().getService(IWeChatMiniActionCheckerService.class)).performCheck();
}
}
void initUserInfo() {
AccountInfo currentUserInfo = getAccountModule().getCurrentUserInfo();
if (currentUserInfo == null) {
return;
}
initUserTypeState(currentUserInfo);
if (this.mIsAuthed) {
this.mCurrentUserType += 10;
}
}
int installLocalFileInnerImpl(LoadSoCallback loadSoCallback) {
if (loadSoCallback == null) {
return -1;
}
File file = new File(StorageDirs.b(), WeChatMiniProgramConstant.LOCAL_SO_FILE_NAME);
try {
file.delete();
MiniLogUtil.log("开始拷贝插件");
if (FileUtils.a(ContextHolder.getAppContext(), WeChatMiniProgramConstant.LOCAL_SO_FILE_NAME, file)) {
MiniLogUtil.log("拷贝插件结束，准备安装...");
loadSo(loadSoCallback, file.getAbsolutePath());
return 1;
}
MiniLogUtil.log("拷贝插件失败");
loadSoCallback.failed("file not exist");
return -1;
} catch (IOException unused) {
loadSoCallback.failed("file not exist");
return 1;
}
}
@Override
public boolean isCloudKeyOpen() {
return getMiniSwitchImpl();
}
@Override
public void isMiniCombineAuthEnable(final MiniCombineAuthEnvCheckCallback miniCombineAuthEnvCheckCallback) {
if (miniCombineAuthEnvCheckCallback == null) {
return;
}
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
IWXAPI createWXAPI = WXAPIFactory.createWXAPI(ContextHolder.getAppContext(), IHostService.APPID_WX, true);
MiniLogUtil.log("so support: " + z);
StringBuilder sb = new StringBuilder();
sb.append("weChat version support: ");
sb.append(createWXAPI.getWXAppSupportAPI() >= 671089426);
MiniLogUtil.log(sb.toString());
if (WeChatMiniProgramServiceImpl.this.mApi != null) {
miniCombineAuthEnvCheckCallback.a(z && createWXAPI.getWXAppSupportAPI() >= 671089426);
} else {
miniCombineAuthEnvCheckCallback.a(false);
}
}
});
}
@Override
public boolean isSoFileExists() {
File file = new File(WeChatMiniProgramConstant.SO_PATCH_FOLDER, WeChatMiniProgramConstant.SO_PATCH_FILE_NAME);
return file.exists() && file.length() > 0;
}
@Override
public boolean isSoZipLoaded() {
if (!enableMiniProgramMode()) {
return false;
}
WxaApi wxaApi = this.mApi;
return wxaApi == null ? PublicSettingManager.a().getBoolean("MINI_SO_STATE", false) : wxaApi.isDynamicPkgLoaded();
}
@Override
public boolean isWxSupport() {
WxaApi wxaApi;
if (enableMiniProgramMode() && (wxaApi = this.mApi) != null) {
return wxaApi.checkIfWechatSupportWxaApi();
}
return false;
}
@Override
public boolean isXwebEnable() {
return isXWebLoadFinish();
}
public void lambda$doWxLoginSuccessLogic$1$WeChatMiniProgramServiceImpl(WxAppLaunchParam wxAppLaunchParam, MiniAuthErrCode miniAuthErrCode, String str) {
if (miniAuthErrCode == MiniAuthErrCode.Auth_Err_OK) {
wxAppLaunchParam.needShowDialog = true;
sendAuthAndOpenMiniProgram(wxAppLaunchParam);
}
}
public void lambda$showWxLoginDialog$0$WeChatMiniProgramServiceImpl(Bundle bundle, final boolean[] zArr, final WxAppLaunchParam wxAppLaunchParam) {
((IAccount) SDKContext.getInstance().getService(IAccount.class)).callUserLogin(QBUIAppEngine.getInstance().getCurrentActivity(), bundle, new UserLoginListener() {
@Override
public void onLoginFailed(int i, String str) {
WeChatMiniProgramServiceImpl.this.doWxLoginFailedLogic(i, str, zArr);
}
@Override
public void onLoginSuccess() {
WeChatMiniProgramServiceImpl.this.doWxLoginSuccessLogic(zArr, wxAppLaunchParam);
}
});
}
void launchDebugMiniProgramInner(TdiAuthState tdiAuthState) {
if (TdiAuthState.WechatTdi_Auth_State_OK == tdiAuthState) {
launchDebugMiniProgramReal();
} else {
MttToaster.show("请用开发者微信账号授权使用小程序", 1500);
}
}
@Override
public void launchDebugWxaApp() {
if (enableMiniProgramMode() && this.mApi != null) {
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
if (z) {
WeChatMiniProgramServiceImpl.this.launchDebugMiniProgram();
} else {
MttToaster.show("请先安装插件！", 1500);
}
}
});
}
}
@Override
public void launchWxaApp(String str, MiniProgramOpenCallback miniProgramOpenCallback) {
WeChatMiniProgramHandler.getInstance().handleQBUrl(str, miniProgramOpenCallback);
}
@Override
public void loadSo(LoadSoCallback loadSoCallback, final String str) {
MiniLogUtil.log("loadSo...");
if (enableMiniProgramMode()) {
if (isSoZipLoaded()) {
if (loadSoCallback != null) {
loadSoCallback.success();
return;
}
return;
}
if (loadSoCallback != null) {
this.mLoadSoCallbacks.add(loadSoCallback);
}
if (this.mIsInLoadSoProgress) {
return;
}
if (this.mApi == null) {
MiniLogUtil.log("loadSo api is null...");
} else {
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
if (z) {
MiniLogUtil.log("loadSo already load....");
} else {
WeChatMiniProgramServiceImpl.this.loadSoInner(str);
}
}
});
}
}
}
public void miniSoCheckImpl(final WxAppLaunchParam wxAppLaunchParam) {
if (wxAppLaunchParam.isNeedUploadClickAction) {
uploadClickEvent(wxAppLaunchParam);
DebugDialogUtil.getInstance().printLog("上报点击事件");
}
UploadUtil.uploadMiniActionEvent(UploadUtil.CHECK_WECHAT_ACTION, "1", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
if (checkWxAppVersion(wxAppLaunchParam)) {
UploadUtil.uploadMiniActionEvent(UploadUtil.START_CHECK_SO, "", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
recordStep(wxAppLaunchParam.uuid, 2);
if (this.mApi == null && enableMiniProgramMode() && Build.VERSION.SDK_INT >= 21) {
initApiImpl(ContextHolder.getAppContext(), AccountConst.WX_APPID);
MiniProgramSoState.getInstance().isSoSupportedNoCache(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
WeChatMiniProgramServiceImpl.this.checkMiniSoResultInOpenAction(z, wxAppLaunchParam);
}
});
} else {
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
WeChatMiniProgramServiceImpl.this.checkMiniSoResultInOpenAction(z, wxAppLaunchParam);
}
});
}
getMonitorMgr().checkMonitorSo();
}
}
@Override
public void onActivityCreated(Activity activity, Bundle bundle) {
getMonitorMgr().onActivityCreated();
}
@Override
public void onActivityDestroyed(Activity activity) {
}
@Override
public void onActivityPaused(Activity activity) {
String componentName = activity.getComponentName().toString();
if (TextUtils.isEmpty(componentName) || !componentName.contains(WeChatMiniProgramConstant.WX_ACTIVITY_PREFIX)) {
return;
}
handlePauseEvent(componentName);
ActivityLifeCycleHandler.getInstance().onActivityPaused(getSourceUrl(componentName));
getMonitorMgr().onMiniPageExitStopAnalyzer();
}
@Override
public void onActivityResumed(Activity activity) {
String componentName = activity.getComponentName().toString();
if (TextUtils.isEmpty(componentName) || !componentName.contains(WeChatMiniProgramConstant.WX_ACTIVITY_PREFIX)) {
return;
}
handleResumeEvent(componentName);
ActivityLifeCycleHandler.getInstance().onActivityResumed(getSourceUrl(componentName));
getMonitorMgr().onMiniPageStartAnalyzer(activity, "onActivityResumed");
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
}
@Override
public void onActivityStarted(Activity activity) {
String componentName = activity.getComponentName().toString();
if (TextUtils.isEmpty(componentName) || !componentName.contains(WeChatMiniProgramConstant.WX_ACTIVITY_PREFIX)) {
return;
}
activity.overridePendingTransition(R.anim.r, R.anim.n);
getMonitorMgr().onMiniPageStartAnalyzer(activity, "onActivityStarted");
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onFlowCtrlDelayed(int i, long j) {
if (i == 2) {
PlatformStatUtils.a(STAT_WXMINI_FLOWCTRL_DELAY);
MiniLogUtil.log("预加载受流控控制，delay");
}
}
@Override
public boolean onFlowCtrlStartDownload(int i) {
if (i != 2) {
return false;
}
PlatformStatUtils.a(STAT_WXMINI_FLOWCTRL_PASS);
PlatformStatUtils.a(BEGINDOWNLOAD_WECHATMINIPROGRAM);
downloadSoImpl();
return false;
}
@Override
public void onUserSwitch(String str, String str2) {
initUserInfo();
}
void openMiniProgramInner(WxAppLaunchParam wxAppLaunchParam) {
if (enableMiniProgramMode()) {
TimeLogUtils.saveUploadData(wxAppLaunchParam.appId, wxAppLaunchParam.uuid, wxAppLaunchParam.extras);
LoadingDialogUtil.getInstance().showLoadingDialog(QBUIAppEngine.getInstance().getCurrentActivity());
boolean z = !getHistoryList().contains(new MiniProgramHistoryEntity(wxAppLaunchParam.appId));
boolean contains = PublicSettingManager.a().getStringSet("MINI_PRELOAD_APP_ID", new HashSet()).contains(wxAppLaunchParam.appId);
wxAppLaunchParam.extras.put("first_open", z ? "1" : "2");
wxAppLaunchParam.extras.put("preload_status", contains ? "1" : "2");
UploadUtil.uploadMiniActionEvent(UploadUtil.PREPARE_OPEN, wxAppLaunchParam.isFromSendAuth ? "2" : "1", checkWxaPackageStatus(wxAppLaunchParam), "", wxAppLaunchParam.uuid, SystemClock.elapsedRealtime() - wxAppLaunchParam.startTime, wxAppLaunchParam.extras);
wxAppLaunchParam.callback.preLaunchWxaApp(wxAppLaunchParam.uuid);
recordStep(wxAppLaunchParam.uuid, 9);
DebugDialogUtil.getInstance().printLog("开始调用launchWxaApp 方法");
PublicSettingManager.a().setString("MINI_CURRENT_OPENED_URL", wxAppLaunchParam.extras.get("sourceUrl"));
DebugDialogUtil.getInstance().printLog("versionType: " + wxAppLaunchParam.versionType + " path: " + wxAppLaunchParam.path + " externalParams: " + wxAppLaunchParam.externalParams);
this.mApi.launchWxaApp(null, wxAppLaunchParam.appId, wxAppLaunchParam.versionType, wxAppLaunchParam.path, wxAppLaunchParam.externalParams, new LaunchResultListener(wxAppLaunchParam));
getMonitorMgr().launchSaveMonitorData(wxAppLaunchParam);
}
}
TdiAuthErrCode parseErrorCode(MiniAuthErrCode miniAuthErrCode) {
if (miniAuthErrCode == null) {
return TdiAuthErrCode.WechatTdi_Auth_Err_InvalidArgs;
}
switch (miniAuthErrCode) {
case Auth_Err_OK:
return TdiAuthErrCode.WechatTdi_Auth_Err_OK;
case Auth_Err_UserCanceled:
return TdiAuthErrCode.WechatTdi_Auth_Err_UserCanceled;
case Auth_Err_UserDenied:
return TdiAuthErrCode.WechatTdi_Auth_Err_UserDenied;
case Auth_Err_System:
return TdiAuthErrCode.WechatTdi_Auth_Err_System;
case Auth_Err_InvalidArgs:
return TdiAuthErrCode.WechatTdi_Auth_Err_InvalidArgs;
case Auth_Err_NormalErr:
return TdiAuthErrCode.WechatTdi_Auth_Err_NormalErr;
case Auth_Err_WechatNotInstalled:
return TdiAuthErrCode.WechatTdi_Auth_Err_WechatNotInstalled;
case Auth_Err_WechatVersionTooLow:
return TdiAuthErrCode.WechatTdi_Auth_Err_WechatVersionTooLow;
case Auth_Err_ActiveDeviceFailed:
return TdiAuthErrCode.WechatTdi_Auth_Err_ActiveDeviceFailed;
case Auth_Err_Dynamic_Pkg_Not_Loaded:
return TdiAuthErrCode.WechatTdi_Auth_Err_Dynamic_Pkg_Not_Loaded;
default:
return TdiAuthErrCode.WechatTdi_Auth_Err_InvalidArgs;
}
}
@Override
public void preloadMiniProgram(MiniPreloadParams miniPreloadParams, MiniPreloadCallback miniPreloadCallback) {
int i;
if (FeatureToggle.a(BuildConfig.FEATURE_TOGGLE_868750295) && miniPreloadCallback != null) {
if (miniPreloadParams == null || !miniPreloadParams.a()) {
MiniLogUtil.log("preloadMiniProgram params invalid");
i = 1001;
} else {
int authState = MiniAuthStateServiceImpl.getInstance().getAuthState();
MiniLogUtil.log("preloadMiniProgram auth state: " + authState);
if (authState == 2) {
i = 1005;
} else if (authState == 0) {
i = 1004;
} else {
for (MiniPreloadParams.MiniAppInfo miniAppInfo : miniPreloadParams.f74958a) {
MiniLogUtil.log("preloadMiniProgram execute: " + miniAppInfo.f74962a + " " + miniAppInfo.f74963b);
WxaApi wxaApi = this.mApi;
if (wxaApi != null) {
wxaApi.getPrefetchApi().prefetchForAppIdAndPath(miniAppInfo.f74962a, miniAppInfo.f74963b);
}
recordPreloadStatus(miniAppInfo.f74962a);
}
i = 1000;
}
}
miniPreloadCallback.result(i);
recordPreloadAction(miniPreloadParams, i);
}
}
@Override
public void preloadMiniProgramEnv(final int i) {
MiniLogUtil.log("preloadMiniProgramEnv env: " + i);
if (enableMiniProgramMode()) {
if (this.mApi == null) {
MiniLogUtil.log("preloadMiniProgramEnv api is null...");
return;
}
if (!BootFeatureToggle.c()) {
((IMiniAuthStateService) SDKContext.getInstance().getService(IMiniAuthStateService.class)).init();
}
MiniProgramSoState.getInstance().isSoSupported(new MiniProgramSoState.CheckEnvCallback() {
@Override
public void result(boolean z) {
if (z) {
WeChatMiniProgramServiceImpl.this.preloadImpl(i);
} else {
MiniLogUtil.log("preloadMiniProgramEnv isDynamicPkgLoaded is false...");
}
}
});
}
}
void prepareUploadAuthLog(final WxAppLaunchParam wxAppLaunchParam) {
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
this.mUploadCancellationTokenMap.put(wxAppLaunchParam.uuid, cancellationTokenSource);
QBTask.a(DateUtils.ONE_MINUTE, cancellationTokenSource.b()).a((Continuation<Void, TContinuationResult>) new Continuation<Void, Object>() {
@Override
public Object then(QBTask<Void> qBTask) throws Exception {
WeChatMiniProgramServiceImpl.this.cancelUploadOpenSdkLog(qBTask, wxAppLaunchParam);
return null;
}
}, 1);
}
@Override
public boolean recordCallbackIntent(BaseResp baseResp) {
if (baseResp == null || this.mWxParam == null) {
return false;
}
uploadOpenSdkAction();
return true;
}
@Override
public void removeOnHistoryChangedListener(MiniProgramHistoryRefreshListener miniProgramHistoryRefreshListener) {
this.mListeners.remove(miniProgramHistoryRefreshListener);
}
@Override
public void removeSoPluginListener(SoDownloadPluginShowListener soDownloadPluginShowListener) {
this.mPluginListeners.remove(soDownloadPluginShowListener);
}
@Override
public void requestRecentUseList(RecentCallback recentCallback) {
HashSet<MiniProgramHistoryEntity> sourceHistoryList = HistoryUtils.sourceHistoryList();
ArrayList arrayList = new ArrayList(sourceHistoryList);
if (arrayList.size() < 5) {
requestRecommendListProto(sourceHistoryList, recentCallback);
return;
}
Collections.sort(arrayList);
recentCallback.a(arrayList.subList(0, 5));
MiniLogUtil.log("requestRecentUseList success");
}
@Override
public void requestWidgetMiniProgramList() {
appletGeneralInfoSvr.GetAppletWidgetInfoReq build = appletGeneralInfoSvr.GetAppletWidgetInfoReq.newBuilder().setGuid("12").build();
WUPRequest wUPRequest = new WUPRequest("trpc.qb_weapp.applet_general_info_svr.AppletGeneralInfoSvr", "/trpc.qb_weapp.applet_general_info_svr.AppletGeneralInfoSvr/GetAppletWidgetInfo");
wUPRequest.setDataType(1);
wUPRequest.a(build.toByteArray());
wUPRequest.setRequestCallBack(new IWUPRequestCallBack() {
@Override
public void onWUPTaskFail(WUPRequestBase wUPRequestBase) {
MiniLogUtil.log("requestWidgetMiniProgramList failed：" + wUPRequestBase.getFailedReason());
}
@Override
public void onWUPTaskSuccess(WUPRequestBase wUPRequestBase, WUPResponseBase wUPResponseBase) {
appletGeneralInfoSvr.GetAppletWidgetInfoRsp getAppletWidgetInfoRsp = (appletGeneralInfoSvr.GetAppletWidgetInfoRsp) wUPResponseBase.get(appletGeneralInfoSvr.GetAppletWidgetInfoRsp.class);
if (getAppletWidgetInfoRsp == null) {
MiniLogUtil.log("WidgetMiniProgramList data is null");
return;
}
appletGeneralInfoSvr.AppletWidgetInfoList list = getAppletWidgetInfoRsp.getList();
if (list == null) {
return;
}
WeChatMiniProgramServiceImpl.this.handleWidgetResult(list.getListList());
}
});
WUPTaskProxy.send(wUPRequest);
Iterator<WidgetMiniEntity> it = this.mWidgetMiniEntities.iterator();
while (it.hasNext()) {
ImageHub.a().a(ImageRequester.a(Uri.parse(it.next().f74965b)));
}
}
@Override
public void sendAuth(final AuthStateCallback authStateCallback) {
if (!enableMiniProgramMode()) {
if (authStateCallback != null) {
authStateCallback.onSendAuthFinish(MiniAuthErrCode.Auth_Err_NO_SDK, "");
}
} else if (this.mApi != null) {
displayGuideAuthDialogInMainThread("", "", new OnGoToSendAuthListener() {
@Override
public void go() {
WeChatMiniProgramServiceImpl.this.mApi.sendAuth(new TdiAuthListener() {
@Override
public void onAuthFinish(TdiAuthErrCode tdiAuthErrCode, String str) {
WeChatMiniProgramServiceImpl weChatMiniProgramServiceImpl;
int i;
if (tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_OK) {
weChatMiniProgramServiceImpl = WeChatMiniProgramServiceImpl.this;
i = 1;
} else {
weChatMiniProgramServiceImpl = WeChatMiniProgramServiceImpl.this;
i = 2;
}
weChatMiniProgramServiceImpl.refreshLocalAuthState(i);
if (tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_UserDenied || tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_UserCanceled) {
WeChatMiniProgramServiceImpl.this.refreshLocalAuthState(-3);
}
if (authStateCallback != null) {
authStateCallback.onSendAuthFinish(WeChatMiniProgramServiceImpl.this.convertErrorCode(tdiAuthErrCode), str);
}
}
});
}
});
} else if (authStateCallback != null) {
authStateCallback.onSendAuthFinish(MiniAuthErrCode.Auth_Err_API, "");
}
}
void sendAuthImpl(WxAppLaunchParam wxAppLaunchParam) {
if (FeatureToggle.a(BuildConfig.BUG_TOGGLE_MINI_OPEN_SDK_AUTH_89682005) && MiniOpenSdkUploadLogIPrefer.mIsOpen) {
prepareUploadAuthLog(wxAppLaunchParam);
}
sendAuthNewWay(wxAppLaunchParam);
}
void sendAuthNewWay(WxAppLaunchParam wxAppLaunchParam) {
this.mIsInAuth = true;
IAccountService iAccountService = (IAccountService) SDKContext.getInstance().getService(IAccountService.class);
if (iAccountService.isWxSupportMiniProgramLogin()) {
checkSocialType(wxAppLaunchParam, iAccountService);
} else {
sendAuthOldWay(wxAppLaunchParam);
}
}
@Override
public void sendCombineAuth(IWXAPIEventHandler iWXAPIEventHandler, final AuthStateCallback authStateCallback) {
if (iWXAPIEventHandler == null) {
return;
}
if (this.mApi == null) {
if (authStateCallback != null) {
authStateCallback.onSendAuthFinish(MiniAuthErrCode.Auth_Err_API, null);
return;
}
return;
}
MiniLogUtil.log("sendCombineAuth");
final SendAuth.Req req = new SendAuth.Req();
req.scope = "snsapi_userinfo";
req.state = String.valueOf(System.currentTimeMillis());
req.transaction = String.format("%d%s", Long.valueOf(System.currentTimeMillis()), "MiniCombine");
PublicSettingManager.a().setString("MINI_AUTH_TRANSACTION", req.transaction);
recordAuth("request_sendcombine_auth_qb", req.transaction, "");
this.mApi.sendCombineAuth(req, iWXAPIEventHandler, new TdiAuthListener() {
@Override
public void onAuthFinish(TdiAuthErrCode tdiAuthErrCode, String str) {
AuthStateCallback authStateCallback2 = authStateCallback;
if (authStateCallback2 != null) {
authStateCallback2.onSendAuthFinish(WeChatMiniProgramServiceImpl.this.convertErrorCode(tdiAuthErrCode), str);
}
WeChatMiniProgramServiceImpl.this.recordAuth("sendcombine_auth_result_qb", req.transaction, tdiAuthErrCode.name());
WeChatMiniProgramServiceImpl.this.recordAuthByCombine(tdiAuthErrCode == TdiAuthErrCode.WechatTdi_Auth_Err_OK);
}
});
}
@Override
public void setPluginMode(int i) {
this.mPluginMode = i;
}
void showEducationDialog(final String str, final String str2, final WxAppLaunchParam wxAppLaunchParam) {
BrowserExecutorSupplier.getInstance().getMainThreadExecutor().execute(new Runnable() {
@Override
public void run() {
EducationParamsEntity educationDialogParams = EducationUserUtil.getEducationDialogParams(str);
if (wxAppLaunchParam.isFromNewAuthWay) {
educationDialogParams.subTitle.replaceAll("授权", "登录");
}
ICommonDialogBuilder a2 = SimpleDialogBuilder.a();
a2.b(false);
a2.e(String.format("%s\n%s", educationDialogParams.title, educationDialogParams.subTitle));
a2.a((CharSequence) educationDialogParams.ok);
a2.c(educationDialogParams.cancel);
a2.a(QBUIAppEngine.getInstance().getMainActivity());
a2.a_(new ViewOnClickListener() {
@Override
public void onClick(View view, DialogBase dialogBase) {
dialogBase.dismiss();
StatManager.b().c("XCX00025");
wxAppLaunchParam.needShowDialog = false;
wxAppLaunchParam.isFromRetryAuth = true;
WeChatMiniProgramServiceImpl.this.mAuthRecordIds.remove(wxAppLaunchParam.uuid);
WeChatMiniProgramServiceImpl.this.sendAuthAndOpenMiniProgram(wxAppLaunchParam);
}
});
a2.c(new ViewOnClickListener() {
@Override
public void onClick(View view, DialogBase dialogBase) {
dialogBase.dismiss();
wxAppLaunchParam.callback.onFailed(1005, str2, wxAppLaunchParam.uuid);
}
});
a2.a(new IDialogBuilder.BackListener() {
@Override
public boolean handleBack(DialogBase dialogBase) {
return true;
}
});
a2.a(new DialogInterface.OnShowListener() {
@Override
public void onShow(DialogInterface dialogInterface) {
EducationUserUtil.updateTimes(str);
StatManager.b().c("XCX00024");
}
});
a2.e();
}
});
}
int sinkCurrentVersionSo(final String str) {
BrowserExecutorSupplier.getInstance().getIoExecutor().execute(new Runnable() {
@Override
public void run() {
WeChatMiniProgramServiceImpl.this.sinkCurrentVersionSoInnerInner(str);
}
});
return 2;
}
void sinkCurrentVersionSoInnerInner(String str) {
MiniLogUtil.log("sink so from: " + str);
if (TextUtils.isEmpty(str)) {
return;
}
sinkSoInner(str);
}
void tryInstallLocalFile(LoadSoCallback loadSoCallback) {
if (WeChatMiniProgramConstant.CHANNEL_LIST.contains(AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_CURRENT_CHANNEL_ID))) {
installLocalFileInner(loadSoCallback);
} else {
loadSoCallback.failed("channel failed");
}
}
void tryRecordHistory(Object obj, String str) {
if (PublicSettingManager.a().getBoolean("key_incongnito", false)) {
return;
}
addMiniProgramHis(str);
Map map = (Map) obj;
String str2 = (String) map.get("history");
if (TextUtils.isEmpty(str2)) {
return;
}
JSONObject stringToJson = TimeLogUtils.stringToJson(str2, ContainerUtils.FIELD_DELIMITER);
String decode = UrlUtils.decode(stringToJson.optString("title", ""));
String decode2 = UrlUtils.decode(stringToJson.optString("coverurl", ""));
String decode3 = UrlUtils.decode(stringToJson.optString("author", ""));
int optInt = stringToJson.optInt("restype", 0);
((IHistory) SDKContext.getInstance().getService(IHistory.class)).addHistory(decode, (String) map.get("sourceUrl"), decode2, 0L, optInt, decode3, "");
PlatformStatUtils.a(WXMINI_ADD_HISTORY);
}
public void uploadAuthState() {
uploadOasToVenus();
uploadUgaData();
}
HashMap<String, String> uploadOasToVenus() {
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("sdk_version", this.mApi.getSDKVersion());
hashMap.put("user_type", String.valueOf(MiniAuthStateServiceImpl.getInstance().getAuthState()));
StatManager.b().b("MTT_MINIPROGRAM_AUTH_STATUS", hashMap);
return hashMap;
}
ArrayList<String> uploadUgaData() {
String str;
WUPRequestBase wUPRequestBase = new WUPRequestBase("UGDataBusProxy", "dataReport", new IWUPRequestCallBack() {
@Override
public void onWUPTaskFail(WUPRequestBase wUPRequestBase2) {
MiniLogUtil.log("uploadUgaData error: " + wUPRequestBase2.getFailedReason());
}
@Override
public void onWUPTaskSuccess(WUPRequestBase wUPRequestBase2, WUPResponseBase wUPResponseBase) {
UGDataReportResp uGDataReportResp;
if (wUPResponseBase == null || (uGDataReportResp = (UGDataReportResp) wUPResponseBase.get("resp")) == null) {
return;
}
MiniLogUtil.log("uploadUgaData: " + uGDataReportResp.eStatus);
}
});
ArrayList<String> arrayList = new ArrayList<>();
AccountInfo currentUserInfo = getAccountModule().getCurrentUserInfo();
if (currentUserInfo == null || !currentUserInfo.isLogined()) {
str = "0";
} else {
byte b2 = currentUserInfo.mType;
if (b2 == 1) {
str = "1";
} else if (b2 == 2) {
str = "2";
} else {
if (b2 != 4) {
if (b2 == 8) {
str = "5";
}
arrayList.add(String.valueOf(MiniAuthStateServiceImpl.getInstance().getAuthState()));
wUPRequestBase.put(HiAnalyticsConstant.Direction.REQUEST, new UGDataReportReq(133, AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_GUID), 0, AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_QUA2_3), arrayList));
WUPTaskProxy.send(wUPRequestBase);
return arrayList;
}
str = "4";
}
}
arrayList.add(str);
arrayList.add(String.valueOf(MiniAuthStateServiceImpl.getInstance().getAuthState()));
wUPRequestBase.put(HiAnalyticsConstant.Direction.REQUEST, new UGDataReportReq(133, AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_GUID), 0, AppInfoHolder.getAppInfoByID(AppInfoHolder.AppInfoID.APP_INFO_QUA2_3), arrayList));
WUPTaskProxy.send(wUPRequestBase);
return arrayList;
}
}