Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/glu/plugins/gluanalytics/Analytics.java

@@ -0,0 +1,384 @@
+package com.glu.plugins.gluanalytics;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.text.TextUtils;
+import androidx.core.app.NotificationCompat;
+import com.glu.plugins.gluanalytics.kvstore.StringStore;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.EventBus;
+import com.glu.plugins.gluanalytics.util.GluActivityLifecycleCallbacks;
+import com.glu.plugins.gluanalytics.util.IAction2;
+import com.glu.plugins.gluanalytics.util.Subscriber;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class Analytics implements IAnalytics, IAnalyticsParametersGetter {
+    private GluActivityLifecycleCallbacks mActivityLifeCycleCallbacks;
+    private Application mContext;
+    private final EventBus mEventBus;
+    private final IAnalyticsParametersGetter mGetter;
+    private GluFirebase mGluFirebase;
+    private Subscriber mSubscriber;
+    private final UUID mSubscriberKey;
+    private final YLogger mLog = YLogger.create(getClass());
+    private final Collection<IAnalytics> mAnalytics = new ArrayList();
+
+    public Analytics(Iterable<IAnalytics> iterable, IAnalyticsParametersGetter iAnalyticsParametersGetter, EventBus eventBus, Context context) {
+        this.mEventBus = eventBus;
+        this.mContext = (Application) context;
+        Iterator<IAnalytics> it = iterable.iterator();
+        while (it.hasNext()) {
+            this.mAnalytics.add(it.next());
+        }
+        this.mGetter = iAnalyticsParametersGetter;
+        this.mSubscriberKey = UUID.randomUUID();
+        this.mGluFirebase = new GluFirebase(context);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void init(IAnalyticsCallback iAnalyticsCallback) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().init(iAnalyticsCallback);
+        }
+        EventBus eventBus = this.mEventBus;
+        if (eventBus != null) {
+            this.mSubscriber = AnalyticsSubscriber.subscribe(eventBus, this.mSubscriberKey, this);
+        }
+        this.mActivityLifeCycleCallbacks = new GluActivityLifecycleCallbacks(this.mContext, new IAction2<String, Activity>() { // from class: com.glu.plugins.gluanalytics.Analytics.1
+            @Override // com.glu.plugins.gluanalytics.util.IAction2
+            public void apply(String str, Activity activity) {
+                Analytics.this.mLog.i("ACTIVITY", NotificationCompat.CATEGORY_EVENT, str);
+                if ("onApplicationResumed".equals(str)) {
+                    Analytics.this.onResume();
+                } else if ("onApplicationPaused".equals(str)) {
+                    Analytics.this.onPause();
+                }
+            }
+        });
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void destroy() {
+        EventBus eventBus = this.mEventBus;
+        if (eventBus != null) {
+            eventBus.unsubscribe(this.mSubscriberKey);
+        }
+        doPause(this.mAnalytics);
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().destroy();
+        }
+        this.mAnalytics.clear();
+        StringStore.destroy();
+        this.mActivityLifeCycleCallbacks.destroy();
+        this.mContext = null;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void onResume() {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().onResume();
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void onPause() {
+        doPause(this.mAnalytics);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void perfSampleStart(String str, int i, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().perfSampleStart(str, i, map);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void perfSampleEnd(String str, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().perfSampleEnd(str, map);
+        }
+    }
+
+    private IAnalytics getGluAnalytics() {
+        for (IAnalytics iAnalytics : this.mAnalytics) {
+            if (iAnalytics instanceof GluAnalytics) {
+                return iAnalytics;
+            }
+        }
+        return null;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public PerfMeasure perfGetValues() {
+        return getGluAnalytics().perfGetValues();
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public boolean perfSampleAction(String str, int i) {
+        return getGluAnalytics().perfSampleAction(str, i);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+        doLogEvent(str, str2, str3, str4, l, l2, map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logCpuEvent(Map<String, ?> map) {
+        doLogCpuEvent(map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+        internal_doLogEvent(str, str2, str3, str4, l, l2, map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logEvent_adImpression(String str, String str2, String str3, String str4, BigDecimal bigDecimal, Long l, Map<String, ?> map) {
+        doLogEvent(str, str2, str3, str4, bigDecimal, l, map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public GeoLocation getGeoLocation() {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            GeoLocation geoLocation = it.next().getGeoLocation();
+            if (geoLocation != null) {
+                return geoLocation;
+            }
+        }
+        return null;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_updatePSValue(String str, boolean z, String str2, String str3, String str4, String str5, String str6, String str7) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_updatePSValue(str, z, str2, str3, str4, str5, str6, str7);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_pinpointAttribute(String str, String str2, String str3, Map<String, Object> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_pinpointAttribute(str, str2, str3, map);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_setRevID(String str, String str2, boolean z) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_setRevID(str, str2, z);
+        }
+        this.mGluFirebase.internal_SetRevID(str);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_trackRevenueInUsd(double d, String str, String str2, String str3, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_trackRevenueInUsd(d, Common.emptyToNull(str), Common.emptyToNull(str2), Common.emptyToNull(str3), map);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_perfEvent(String str, String str2, String str3, String str4, String str5, Map<String, Object> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_perfEvent(str, str2, str3, str4, str5, map);
+        }
+    }
+
+    public void logInAppPurchaseInUsd(double d, String str, String str2, String str3, String str4, long j, long j2, long j3, Map<String, ?> map) {
+        AnalyticsHelper.logInAppPurchaseInUsd(this, d, str, str2, str3, str4, j, j2, j3, map);
+    }
+
+    public void logInAppPurchaseInCents(long j, String str, String str2, String str3, String str4, long j2, long j3, long j4, Map<String, ?> map) {
+        AnalyticsHelper.logInAppPurchaseInCents(this, j, str, str2, str3, str4, j2, j3, j4, map);
+    }
+
+    public void logTutorialStepCompleted(String str, long j, String str2, long j2, Map<String, ?> map) {
+        AnalyticsHelper.logTutorialStepCompleted(this, str, j, str2, j2, map);
+    }
+
+    public void logMissionStarted(String str, String str2, String str3, long j, long j2, long j3, Map<String, ?> map) {
+        AnalyticsHelper.logMissionStarted(this, str, str2, str3, j, j2, j3, map);
+    }
+
+    public void logMissionFailed(String str, String str2, String str3, String str4, long j, long j2, long j3, Map<String, ?> map) {
+        AnalyticsHelper.logMissionFailed(this, str, str2, str3, str4, j, j2, j3, map);
+    }
+
+    public void logMissionCompleted(String str, String str2, String str3, long j, long j2, long j3, Map<String, ?> map) {
+        AnalyticsHelper.logMissionCompleted(this, str, str2, str3, j, j2, j3, map);
+    }
+
+    public void logCurrencySink(long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, Map<String, ?> map) {
+        AnalyticsHelper.logCurrencySink(this, j, str, str2, str3, str4, str5, str6, j2, j3, j4, map);
+        if (TextUtils.isEmpty(str) || TextUtils.isEmpty(str2)) {
+            return;
+        }
+        HashMap hashMap = new HashMap();
+        hashMap.put("virtual_currency_name", str);
+        hashMap.put("item_name", str2);
+        hashMap.put("value", Long.valueOf(j));
+        internal_logFirebaseEvent("spend_virtual_currency", hashMap);
+    }
+
+    public void logCurrencySource(long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, Map<String, ?> map) {
+        AnalyticsHelper.logCurrencySource(this, j, str, str2, str3, str4, str5, str6, j2, j3, j4, map);
+        if (TextUtils.isEmpty(str)) {
+            return;
+        }
+        HashMap hashMap = new HashMap();
+        hashMap.put("virtual_currency_name", str);
+        hashMap.put("value", Long.valueOf(j));
+        internal_logFirebaseEvent("earn_virtual_currency", hashMap);
+    }
+
+    public void logAdvertisementOpportunity(String str, String str2, long j, boolean z, Map<String, ?> map) {
+        AnalyticsHelper.logAdvertisementOpportunity(this, str, str2, j, z, map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setUserIdentifier(String str) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().setUserIdentifier(str);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setCustomProperties(Map<String, Object> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().setCustomProperties(map);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics, com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public Map<String, Object> getCustomProperties() {
+        return this.mGetter.getCustomProperties();
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public String getAnalyticsDeviceIdentifier() {
+        String analyticsDeviceIdentifier = this.mGetter.getAnalyticsDeviceIdentifier();
+        return analyticsDeviceIdentifier != null ? analyticsDeviceIdentifier : "";
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public String getAnalyticsApplicationName() {
+        String analyticsApplicationName = this.mGetter.getAnalyticsApplicationName();
+        return analyticsApplicationName != null ? analyticsApplicationName : "";
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public String getAnalyticsEnvironment() {
+        String analyticsEnvironment = this.mGetter.getAnalyticsEnvironment();
+        return analyticsEnvironment != null ? analyticsEnvironment : "";
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public String getRevenueIdentifier() {
+        String revenueIdentifier = this.mGetter.getRevenueIdentifier();
+        return revenueIdentifier != null ? revenueIdentifier : "";
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public String getSessionIdentifier() {
+        String sessionIdentifier = this.mGetter.getSessionIdentifier();
+        return sessionIdentifier != null ? sessionIdentifier : "";
+    }
+
+    private static void doPause(Iterable<IAnalytics> iterable) {
+        Iterator<IAnalytics> it = iterable.iterator();
+        while (it.hasNext()) {
+            it.next().onPause();
+        }
+    }
+
+    private void doLogEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().logEvent(str, Common.emptyToNull(str2), Common.emptyToNull(str3), Common.emptyToNull(str4), l, l2, map);
+        }
+    }
+
+    private void internal_doLogEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_logEvent(str, Common.emptyToNull(str2), Common.emptyToNull(str3), Common.emptyToNull(str4), l, l2, map);
+        }
+    }
+
+    private void doLogCpuEvent(Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_logCpuEvent(map);
+        }
+    }
+
+    private void doLogEvent(String str, String str2, String str3, String str4, BigDecimal bigDecimal, Long l, Map<String, ?> map) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().internal_logEvent_adImpression(str, Common.emptyToNull(str2), Common.emptyToNull(str3), Common.emptyToNull(str4), bigDecimal, l, map);
+        }
+    }
+
+    public void internal_firebaseInitialize(Map<String, Object> map, IAnalyticsCallback iAnalyticsCallback) {
+        this.mGluFirebase.initialize(map, iAnalyticsCallback);
+    }
+
+    public void internal_firebaseUpdateUnderAgeUserStatus(boolean z) {
+        this.mGluFirebase.updateUnderAgeUserStatus(z);
+    }
+
+    public void internal_firebaseAllowPersonalizedAds(boolean z) {
+        this.mGluFirebase.allowPersonalizedAds(z);
+    }
+
+    public void internal_logFirebaseEvent(String str, Map<String, Object> map) {
+        this.mGluFirebase.logEvent(str, map);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void shortcircuitEATargetedMarketingOff() {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().shortcircuitEATargetedMarketingOff();
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void userAgedUp() {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().userAgedUp();
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setEATargetedMarketing(boolean z) {
+        Iterator<IAnalytics> it = this.mAnalytics.iterator();
+        while (it.hasNext()) {
+            it.next().setEATargetedMarketing(z);
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/AnalyticsData.java

@@ -0,0 +1,156 @@
+package com.glu.plugins.gluanalytics;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.SystemClock;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+import androidx.annotation.NonNull;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.google.android.gms.ads.identifier.AdvertisingIdClient;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes2.dex */
+public class AnalyticsData {
+    public static final String S_APPLICATION_VERSION = "applicationVersion";
+    public static final String S_APPLICATION_VERSION_CODE = "applicationVersionCode";
+    public static final String S_CARRIER_NAME = "carrierName";
+    public static final String S_CPU_CORE_COUNT = "cpuCoreCount";
+    public static final String S_DEVICE_MANUFACTURER = "deviceManufacturer";
+    public static final String S_DEVICE_MODEL = "deviceModel";
+    public static final String S_DEVICE_NAME = "deviceName";
+    public static final String S_DEVICE_TIER = "deviceTier";
+    public static final String S_DEVICE_TIER_FALLBACK = "deviceTierFallback";
+    public static final String S_GPU_RENDERER = "gpuDeviceName";
+    public static final String S_GPU_VENDOR = "gpuDeviceVendor";
+    public static final String S_LOCALE_COUNTRY_CODE = "localeCountryCode";
+    public static final String S_LOCALE_LANGUAGE_CODE = "localeLanguageCode";
+    public static final String S_LONG_SDK_VERSION = "longSdkVersion";
+    public static final String S_OS_VERSION = "osVersion";
+    public static final String S_PRE_INIT_TIME = "preInitTime";
+    public static final String S_SDK_VERSION = "sdkVersion";
+    public static final String S_SUPPORTED_ABIS = "supportedABIs";
+    public static final String S_UNITY_VERSION = "unityVer";
+    public static final String S_USER_ID = "userIdentifier";
+    private static final YLogger sLog = YLogger.create((Class<?>) AnalyticsData.class);
+
+    private static boolean hasGooglePlayServices() {
+        return true;
+    }
+
+    private AnalyticsData() {
+    }
+
+    public static Map<String, Object> buildDefault(Context context) {
+        Map createMap = CollectionUtil.createMap();
+        try {
+            createMap.put(S_APPLICATION_VERSION, context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName);
+            createMap.put(S_APPLICATION_VERSION_CODE, Long.valueOf(Common.packageVersionCode(context)));
+        } catch (PackageManager.NameNotFoundException e) {
+            sLog.e("BUILD_ANALYTICS_DATA.ERROR", InneractiveMediationDefs.GENDER_MALE, "no package version", "e", e);
+        }
+        createMap.put(S_LOCALE_COUNTRY_CODE, Locale.getDefault().getCountry());
+        createMap.put(S_LOCALE_LANGUAGE_CODE, Locale.getDefault().getLanguage());
+        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService("phone");
+        if (telephonyManager != null) {
+            createMap.put(S_CARRIER_NAME, telephonyManager.getNetworkOperatorName());
+        }
+        createMap.put(S_OS_VERSION, Build.VERSION.RELEASE);
+        createMap.put("deviceModel", Build.MODEL);
+        createMap.put("deviceManufacturer", Build.MANUFACTURER);
+        createMap.put(S_DEVICE_NAME, Build.PRODUCT);
+        createMap.put(S_LONG_SDK_VERSION, BuildConfig.VERSION_NAME);
+        Matcher matcher = Pattern.compile("^[\\d\\.]+").matcher(BuildConfig.VERSION_NAME);
+        if (matcher.find()) {
+            createMap.put("sdkVersion", matcher.group());
+        }
+        createMap.put(S_SUPPORTED_ABIS, abis21());
+        return cleanEmpty(createMap);
+    }
+
+    public static String getAndroidId(Context context) {
+        try {
+            return Settings.Secure.getString(context.getContentResolver(), "android_id");
+        } catch (Exception e) {
+            sLog.e("BUILD_ANALYTICS_DATA.ERROR", InneractiveMediationDefs.GENDER_MALE, "no Android ID", "e", e);
+            return null;
+        }
+    }
+
+    public static AdvertisingIdInfo getAdvertisingIdInfo(Context context) {
+        if (!hasGooglePlayServices()) {
+            return null;
+        }
+        try {
+            long nanoTime = System.nanoTime();
+            AdvertisingIdClient.Info advertisingIdInfo = AdvertisingIdClient.getAdvertisingIdInfo(context);
+            sLog.i("getAdvertisingIdInfo.timer", "delta", Long.valueOf(System.nanoTime() - nanoTime));
+            return new AdvertisingIdInfo(advertisingIdInfo.getId(), advertisingIdInfo.isLimitAdTrackingEnabled());
+        } catch (Exception e) {
+            sLog.i("getAdvertisingIdInfo.exception", "e", e);
+            return null;
+        }
+    }
+
+    public static long getDeviceBootTimeSec(Long[] lArr) {
+        lArr[0] = Long.valueOf(System.currentTimeMillis() / 1000);
+        lArr[1] = Long.valueOf(SystemClock.elapsedRealtime() / 1000);
+        return lArr[0].longValue() - lArr[1].longValue();
+    }
+
+    private static Map<String, Object> cleanEmpty(Map<String, Object> map) {
+        Map<String, Object> createMap = CollectionUtil.createMap();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            if (entry.getValue() != null) {
+                createMap.put(entry.getKey(), entry.getValue());
+            }
+        }
+        return createMap;
+    }
+
+    @NonNull
+    @TargetApi(21)
+    private static List<String> abis21() {
+        String[] strArr = Build.SUPPORTED_ABIS;
+        if (strArr == null) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(strArr);
+    }
+
+    @NonNull
+    private static List<String> abis4() {
+        ArrayList arrayList = new ArrayList();
+        String str = Build.CPU_ABI;
+        if (str != null) {
+            arrayList.add(str);
+        }
+        String str2 = Build.CPU_ABI2;
+        if (str2 != null) {
+            arrayList.add(str2);
+        }
+        return arrayList;
+    }
+
+    public static class AdvertisingIdInfo {
+        public final boolean adTrackingLimited;
+        public final String advertisingId;
+
+        public AdvertisingIdInfo(String str, boolean z) {
+            this.advertisingId = str;
+            this.adTrackingLimited = z;
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/AnalyticsFactory.java

@@ -0,0 +1,205 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Context;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.share.internal.ShareConstants;
+import com.glu.plugins.gluanalytics.eventbus.ConfigGetterEventHandler;
+import com.glu.plugins.gluanalytics.eventbus.GluAnalyticsEventHandler;
+import com.glu.plugins.gluanalytics.eventbus.GluEventBus;
+import com.glu.plugins.gluanalytics.kvstore.StringStore;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.ConfigUtil;
+import com.glu.plugins.gluanalytics.util.DummyEventBus;
+import com.glu.plugins.gluanalytics.util.EventBus;
+import com.glu.plugins.gluanalytics.util.IAction2;
+import com.glu.plugins.gluanalytics.util.JsonUtil;
+import com.glu.plugins.gluanalytics.util.LocalBroadcastManagerEventBus;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.UUID;
+import org.json.JSONException;
+
+/* loaded from: classes2.dex */
+public class AnalyticsFactory {
+    private static final String SPKEY_APP_LAUNCH_TICK = "AppLaunchSampleTick";
+    private static final Looper sSharedLooper = Common.createLooper("glu-analytics-" + UUID.randomUUID());
+    private static final Looper sSharedLooperPps = Common.createLooper("glu-analytics-pps-" + UUID.randomUUID());
+    private final Context mApplicationContext;
+    private final YLogger mLog;
+
+    public AnalyticsFactory(Context context) {
+        YLogger create = YLogger.create(getClass());
+        this.mLog = create;
+        Common.require(context != null, "context == null");
+        this.mApplicationContext = context.getApplicationContext();
+        create.i("SDK.VERSION", nb.q, "GluAnalytics", Consts.KEY_TAPJOY_USER_ID_VERSION, BuildConfig.VERSION_NAME);
+    }
+
+    public Analytics createAnalytics(@NonNull String str, @Nullable Map<String, Object> map) {
+        IAnalyticsParametersGetter dummyAnalyticsParametersGetters;
+        EventBus eventBus;
+        Common.require(str != null, "jsonConfig can't be null.");
+        try {
+            final Map<String, Object> parseJsonObject = CollectionUtil.parseJsonObject(str);
+            String json = JsonUtil.toJson(parseJsonObject);
+            if (ConfigUtil.getBoolean(parseJsonObject, "csdk.disabled.gluAnalytics")) {
+                Analytics analytics = new Analytics(Collections.emptyList(), new DummyAnalyticsParametersGetters(), null, null);
+                analytics.init(new IAnalyticsCallback() { // from class: com.glu.plugins.gluanalytics.AnalyticsFactory.1
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void internalTargetedAdsChanged(boolean z) {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void onDestroy() {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void onInit(String str2, String str3, String str4, String str5, String str6, String str7) {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void onUpdateSessionId() {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void onUserIdChanged(String str2, String str3) {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void recordAnalyticsRequest(String str2, String str3, String str4, String str5, String str6, String str7, String str8) {
+                    }
+
+                    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+                    public void setPushToken(String str2) {
+                    }
+                });
+                analytics.internal_firebaseInitialize(null, null);
+                return analytics;
+            }
+            StringStore.init();
+            GluEventBus gluEventBus = ConfigUtil.getBoolean(parseJsonObject, "csdk.gluAnalytics.disabled.eventBus", false) ? GluEventBus.DISCONNECTED : GluEventBus.SHARED;
+            Map<String, Object> buildDefault = AnalyticsData.buildDefault(this.mApplicationContext);
+            CollectionUtil.putAll(buildDefault, (Map<String, ?>) map);
+            ArrayList arrayList = new ArrayList();
+            IAnalytics createGluAnalyticsImpl = createGluAnalyticsImpl(parseJsonObject, buildDefault, gluEventBus);
+            arrayList.add(createGluAnalyticsImpl);
+            if (ConfigUtil.getBoolean(parseJsonObject, "csdk.gluAnalytics.sharedPreferencesAnalytics.enabled")) {
+                arrayList.add(new SharedPreferencesAnalytics(this.mApplicationContext, this.mApplicationContext.getSharedPreferences("glushared", 0)));
+            }
+            if (createGluAnalyticsImpl instanceof IAnalyticsParametersGetter) {
+                dummyAnalyticsParametersGetters = (IAnalyticsParametersGetter) createGluAnalyticsImpl;
+            } else {
+                dummyAnalyticsParametersGetters = new DummyAnalyticsParametersGetters();
+            }
+            if (LocalBroadcastManagerEventBus.isSupported()) {
+                eventBus = LocalBroadcastManagerEventBus.getInstance(this.mApplicationContext);
+            } else {
+                eventBus = DummyEventBus.INSTANCE;
+            }
+            final Analytics analytics2 = new Analytics(arrayList, dummyAnalyticsParametersGetters, eventBus, this.mApplicationContext);
+            Object obj = GluEventBus.GLOBAL_TOKEN;
+            final GluAnalyticsEventHandler subscribe = GluAnalyticsEventHandler.subscribe(gluEventBus, obj, analytics2, getRevSDKVersion(this.mApplicationContext));
+            analytics2.init(subscribe);
+            boolean z = ConfigUtil.getBoolean(parseJsonObject, "csdk.gluAnalytics.disabled.configUpdate", false);
+            long j = (long) (ConfigUtil.getDouble(parseJsonObject, "csdk.gluAnalytics.configUpdate.timeoutInSec", 3.0d) * 1000.0d);
+            if (gluEventBus.isConnected() && !z) {
+                ConfigGetterEventHandler.subscribe(gluEventBus, obj, new IAction2<String, String>() { // from class: com.glu.plugins.gluanalytics.AnalyticsFactory.2
+                    @Override // com.glu.plugins.gluanalytics.util.IAction2
+                    public void apply(String str2, String str3) {
+                        YLogger yLogger = AnalyticsFactory.this.mLog;
+                        Object[] objArr = new Object[4];
+                        objArr[0] = "sdk";
+                        objArr[1] = "GluAnalytics";
+                        objArr[2] = ShareConstants.FEED_SOURCE_PARAM;
+                        objArr[3] = str3 != null ? str3.toUpperCase(Locale.US) : null;
+                        yLogger.i("CONFIG.RECONFIGURE", objArr);
+                        try {
+                            Map<String, Object> parseJsonObject2 = CollectionUtil.parseJsonObject(str2);
+                            if (parseJsonObject2 != null) {
+                                analytics2.internal_firebaseInitialize(parseJsonObject2, subscribe);
+                            } else {
+                                analytics2.internal_firebaseInitialize(parseJsonObject, subscribe);
+                            }
+                        } catch (JSONException e) {
+                            throw Common.propagate(e);
+                        }
+                    }
+                }, json).requestConfig(j);
+            } else {
+                this.mLog.i("CONFIG.RECONFIGURE", "sdk", "GluAnalytics", ShareConstants.FEED_SOURCE_PARAM, "APP-NO-EB");
+                analytics2.internal_firebaseInitialize(parseJsonObject, subscribe);
+            }
+            return analytics2;
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:46:0x022f  */
+    /* JADX WARN: Removed duplicated region for block: B:50:0x024d  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private com.glu.plugins.gluanalytics.IAnalytics createGluAnalyticsImpl(java.util.Map<java.lang.String, java.lang.Object> r44, java.util.Map<java.lang.String, java.lang.Object> r45, com.glu.plugins.gluanalytics.eventbus.GluEventBus r46) {
+        /*
+            Method dump skipped, instructions count: 698
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.glu.plugins.gluanalytics.AnalyticsFactory.createGluAnalyticsImpl(java.util.Map, java.util.Map, com.glu.plugins.gluanalytics.eventbus.GluEventBus):com.glu.plugins.gluanalytics.IAnalytics");
+    }
+
+    public static class DummyAnalyticsParametersGetters implements IAnalyticsParametersGetter {
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public String getAnalyticsApplicationName() {
+            return null;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public String getAnalyticsDeviceIdentifier() {
+            return null;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public String getAnalyticsEnvironment() {
+            return null;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public Map<String, Object> getCustomProperties() {
+            return null;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public String getRevenueIdentifier() {
+            return null;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+        public String getSessionIdentifier() {
+            return null;
+        }
+
+        private DummyAnalyticsParametersGetters() {
+        }
+    }
+
+    private static String getRevSDKVersion(Context context) {
+        try {
+            Properties properties = new Properties();
+            properties.load(context.getAssets().open("revsdk.properties"));
+            return properties.getProperty("revSDKVersion");
+        } catch (Exception unused) {
+            return "";
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/AnalyticsHelper.java

@@ -0,0 +1,199 @@
+package com.glu.plugins.gluanalytics;
+
+import com.facebook.share.internal.ShareConstants;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.Conversion;
+import com.ironsource.ad;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.mbbid.out.BidResponsed;
+import com.unity3d.services.ads.gmascar.utils.ScarConstants;
+import csdk.gluads.Consts;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class AnalyticsHelper {
+    private static final String REWARDED_AD_TYPE = "rewardedInterstitial";
+
+    public static void logInAppPurchaseInUsd(IAnalytics iAnalytics, double d, String str, String str2, String str3, String str4, long j, long j2, long j3, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "iap_pack", str);
+        putMission(createMap, str2, str3, str4);
+        putBalance(createMap, j, j2);
+        putSecondsInGame(createMap, j3);
+        iAnalytics.internal_logEvent(null, "IAP", "IAP_SUCCESS", null, Long.valueOf(Conversion.usdToCents(d)), null, createMap);
+        Map<String, ?> createMap2 = CollectionUtil.createMap();
+        createMap2.put("iap_pack", str);
+        if (map != null) {
+            CollectionUtil.putIfNotNull(createMap2, "amt", map.get("amt"));
+            CollectionUtil.putIfNotNull(createMap2, "catalog_amt", map.get("catalog_amt"));
+            CollectionUtil.putIfNotNull(createMap2, "ft", map.get("ft"));
+            CollectionUtil.putIfNotNull(createMap2, "testPurchase", map.get("testPurchase"));
+        }
+        iAnalytics.internal_trackRevenueInUsd(d, null, null, null, createMap2);
+    }
+
+    public static void logInAppPurchaseInCents(IAnalytics iAnalytics, long j, String str, String str2, String str3, String str4, long j2, long j3, long j4, Map<String, ?> map) {
+        logInAppPurchaseInUsd(iAnalytics, Conversion.centsToUsd(j), str, str2, str3, str4, j2, j3, j4, map);
+    }
+
+    public static void logTutorialStepCompleted(IAnalytics iAnalytics, String str, long j, String str2, long j2, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        createMap.put(ScarConstants.TOKEN_ID_KEY, String.format(Locale.ENGLISH, "%03d_%s", Long.valueOf(j), str));
+        putSecondsInGame(createMap, j2);
+        iAnalytics.internal_logEvent(Common.emptyToNull(str), "PROG", "TUTORIAL_STEP_COMPLETED", null, null, j != Long.MIN_VALUE ? Long.valueOf(j) : null, createMap);
+    }
+
+    public static void logMissionStarted(IAnalytics iAnalytics, String str, String str2, String str3, long j, long j2, long j3, Map<String, ?> map) {
+        logMissionResolution(iAnalytics, "MISSION_STARTED", null, str, str2, str3, j, j2, j3, map);
+    }
+
+    public static void logMissionFailed(IAnalytics iAnalytics, String str, String str2, String str3, String str4, long j, long j2, long j3, Map<String, ?> map) {
+        logMissionResolution(iAnalytics, "MISSION_FAILED", str, str2, str3, str4, j, j2, j3, map);
+    }
+
+    public static void logMissionCompleted(IAnalytics iAnalytics, String str, String str2, String str3, long j, long j2, long j3, Map<String, ?> map) {
+        logMissionResolution(iAnalytics, "MISSION_COMPLETED", null, str, str2, str3, j, j2, j3, map);
+    }
+
+    public static void logCurrencySink(IAnalytics iAnalytics, long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "item", str2);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "item_category", str3);
+        CollectionUtil.putIf(createMap, isTC(str), BidResponsed.KEY_CUR, str);
+        putMission(createMap, str4, str5, str6);
+        putBalance(createMap, j2, j3);
+        putSecondsInGame(createMap, j4);
+        iAnalytics.internal_logEvent(null, "ECO", currencyToSink(str), null, Long.valueOf(j), null, createMap);
+    }
+
+    public static void logCurrencySource(IAnalytics iAnalytics, long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, ShareConstants.FEED_SOURCE_PARAM, str2);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "source_type", str3);
+        CollectionUtil.putIf(createMap, isTC(str), BidResponsed.KEY_CUR, str);
+        putMission(createMap, str4, str5, str6);
+        putBalance(createMap, j2, j3);
+        putSecondsInGame(createMap, j4);
+        iAnalytics.internal_logEvent(null, "ECO", currencyToSource(str), null, Long.valueOf(j), null, createMap);
+    }
+
+    public static void logAdvertisementLoaded(IAnalytics iAnalytics, String str, String str2, boolean z, String str3, String str4, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, str2, str3);
+        createMap.put("filled", z ? "1" : "0");
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "errorCode", str4);
+        iAnalytics.internal_logEvent(str, "AD", "AD_REQUEST", str3, null, null, createMap);
+    }
+
+    public static void logAdvertisementShown(IAnalytics iAnalytics, String str, String str2, String str3, Double d, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, str2, str3);
+        iAnalytics.internal_logEvent_adImpression(str, "AD", "AD_IMPRESSION", str3, d != null ? Conversion.usdToCentsInDecimal(d.doubleValue()) : null, null, createMap);
+    }
+
+    public static void logAdvertisementClicked(IAnalytics iAnalytics, String str, String str2, String str3, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, str2, str3);
+        iAnalytics.internal_logEvent(str, "AD", "AD_CLICKED", str3, null, null, createMap);
+    }
+
+    public static void logAdvertisementShowAttempt(IAnalytics iAnalytics, String str, String str2, String str3, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, str2, str3);
+        iAnalytics.internal_logEvent(str, "AD", "AD_SHOW_ATTEMPT", str3, null, null, createMap);
+    }
+
+    public static void logAdvertisementDismissed(IAnalytics iAnalytics, String str, String str2, String str3, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, str2, str3);
+        iAnalytics.internal_logEvent(str, "AD", "AD_DISMISSED", str3, null, null, createMap);
+    }
+
+    public static void logAdvertisementOpportunity(IAnalytics iAnalytics, String str, String str2, long j, boolean z, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putAdInfo(createMap, str, Consts.SDK_MOPUB, "rewardedInterstitial");
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "reward_item", str2);
+        CollectionUtil.putIfNotNull(createMap, CampaignEx.JSON_KEY_REWARD_AMOUNT, Long.valueOf(j));
+        createMap.put("missed", z ? "1" : "0");
+        iAnalytics.internal_logEvent(str, "AD", "AD_OPPORTUNITY", "rewardedInterstitial", null, null, createMap);
+    }
+
+    public static void logInAppPurchaseEvent(IAnalytics iAnalytics, String str, Map<String, ?> map) {
+        iAnalytics.internal_logEvent("PURCHASE_FLOW", "IAP", str, null, null, null, map);
+    }
+
+    public static void logCrossPromoBlocked(IAnalytics iAnalytics, String str, String str2, Map<String, Object> map) {
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, Consts.KEY_NAME_ADTYPE, str2);
+        iAnalytics.internal_logEvent(str, "SDK", "CROSS_PROMO", "BLOCKED", null, null, map);
+    }
+
+    public static void logCrossPromoShown(IAnalytics iAnalytics, String str, Map<String, ?> map) {
+        iAnalytics.internal_logEvent(str, "SDK", "CROSS_PROMO", "IMPRESSION", null, null, map);
+    }
+
+    public static void logCrossPromoClicked(IAnalytics iAnalytics, String str, Map<String, ?> map) {
+        iAnalytics.internal_logEvent(str, "SDK", "CROSS_PROMO", "CLICKED", null, null, map);
+    }
+
+    private static void putMission(Map<String, Object> map, String str, String str2, String str3) {
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, "mid", str);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, ad.I0, str2);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, "tier", str3);
+    }
+
+    private static void putBalance(Map<String, Object> map, long j, long j2) {
+        CollectionUtil.putIf(map, j != Long.MIN_VALUE, "hc", Long.valueOf(j));
+        CollectionUtil.putIf(map, j2 != Long.MIN_VALUE, "sc", Long.valueOf(j2));
+    }
+
+    private static void putSecondsInGame(Map<String, Object> map, long j) {
+        CollectionUtil.putIf(map, j >= 0, "tig", Long.valueOf(j));
+    }
+
+    private static boolean isHC(String str) {
+        return "hc".equals(str);
+    }
+
+    private static boolean isSC(String str) {
+        return "sc".equals(str);
+    }
+
+    private static boolean isTC(String str) {
+        return (isHC(str) || isSC(str)) ? false : true;
+    }
+
+    private static String currencyToSink(String str) {
+        return isHC(str) ? "HC_SINK" : isSC(str) ? "SC_SINK" : "TC_SINK";
+    }
+
+    private static String currencyToSource(String str) {
+        return isHC(str) ? "HC_SOURCE" : isSC(str) ? "SC_SOURCE" : "TC_SOURCE";
+    }
+
+    private static void putAdInfo(Map<String, Object> map, String str, String str2, String str3) {
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, "game_placement", str);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, "network", str2);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) map, "ad_type", str3);
+    }
+
+    private static void logMissionResolution(IAnalytics iAnalytics, String str, String str2, String str3, String str4, String str5, long j, long j2, long j3, Map<String, ?> map) {
+        Map<String, ?> createMap = CollectionUtil.createMap();
+        CollectionUtil.putAll(createMap, map);
+        putMission(createMap, str3, str4, str5);
+        putBalance(createMap, j, j2);
+        putSecondsInGame(createMap, j3);
+        iAnalytics.internal_logEvent(null, "PROG", str, Common.emptyToNull(str2), null, null, createMap);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/AnalyticsSubscriber.java

@@ -0,0 +1,67 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.EventBus;
+import com.glu.plugins.gluanalytics.util.Subscriber;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.ironsource.nb;
+import csdk.gluads.Consts;
+import java.util.Collections;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class AnalyticsSubscriber implements Subscriber {
+    private static final String ACTION_LOG_EVENT = "com.glu.intent.action.LOG_EVENT";
+    private static final String ACTION_TRACK_REVENUE = "com.glu.intent.action.TRACK_REVENUE";
+    private final IAnalytics mAnalytics;
+    private final YLogger mLog = YLogger.create(getClass());
+
+    private AnalyticsSubscriber(IAnalytics iAnalytics) {
+        this.mAnalytics = iAnalytics;
+    }
+
+    public static Subscriber subscribe(EventBus eventBus, UUID uuid, IAnalytics iAnalytics) {
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(ACTION_LOG_EVENT);
+        intentFilter.addAction(ACTION_TRACK_REVENUE);
+        AnalyticsSubscriber analyticsSubscriber = new AnalyticsSubscriber(iAnalytics);
+        eventBus.subscribe(uuid, analyticsSubscriber, Collections.singleton(intentFilter));
+        return analyticsSubscriber;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.Subscriber
+    public void onReceive(EventBus eventBus, Intent intent) {
+        String action = intent.getAction();
+        if (ACTION_LOG_EVENT.equals(action)) {
+            logEvent(intent);
+        } else if (ACTION_TRACK_REVENUE.equals(action)) {
+            trackRevenue(intent);
+        } else {
+            this.mLog.i("ANALYTICS.BROADCAST.ERROR", InneractiveMediationDefs.GENDER_MALE, "unsupported-action", Consts.KEY_TAPJOY_USER_ID_VERSION, action);
+        }
+    }
+
+    private static Number getNumber(Bundle bundle, String str, Number number) {
+        Object obj = bundle.get(str);
+        return obj != null ? (Number) obj : number;
+    }
+
+    private void logEvent(Intent intent) {
+        Bundle extras = intent.getExtras();
+        String stringExtra = intent.getStringExtra(nb.q);
+        String stringExtra2 = intent.getStringExtra("st1");
+        String stringExtra3 = intent.getStringExtra("st2");
+        String stringExtra4 = intent.getStringExtra("st3");
+        Number number = getNumber(extras, Consts.KEY_TAPJOY_USER_ID_VERSION, null);
+        Number number2 = getNumber(extras, "l", null);
+        this.mAnalytics.internal_logEvent(stringExtra, stringExtra2, stringExtra3, stringExtra4, number != null ? Long.valueOf(number.longValue()) : null, number2 != null ? Long.valueOf(number2.longValue()) : null, CollectionUtil.toMap(intent.getBundleExtra("data")));
+    }
+
+    private void trackRevenue(Intent intent) {
+        this.mAnalytics.internal_trackRevenueInUsd(getNumber(intent.getExtras(), "price-usd", Double.valueOf(0.0d)).doubleValue(), intent.getStringExtra("st1"), intent.getStringExtra("st2"), intent.getStringExtra("st3"), CollectionUtil.toMap(intent.getBundleExtra("data")));
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/AwsProperties.java

@@ -0,0 +1,18 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public class AwsProperties {
+    public final String accountId;
+    public final String authenticatedRoleArn;
+    public final String identityPoolId;
+    public final String region;
+    public final String unauthenticatedRoleArn;
+
+    public AwsProperties(String str, String str2, String str3, String str4, String str5) {
+        this.accountId = str;
+        this.identityPoolId = str2;
+        this.unauthenticatedRoleArn = str3;
+        this.authenticatedRoleArn = str4;
+        this.region = str5;
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/BuildConfig.java

@@ -0,0 +1,10 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public final class BuildConfig {
+    public static final String BUILD_TYPE = "release";
+    public static final boolean CORE_METRICS_LITE = false;
+    public static final boolean DEBUG = false;
+    public static final String LIBRARY_PACKAGE_NAME = "com.glu.plugins.gluanalytics";
+    public static final String VERSION_NAME = "7.3.0-b9f217a";
+}

decompiled/sources/com/glu/plugins/gluanalytics/CacheService.java

@@ -0,0 +1,113 @@
+package com.glu.plugins.gluanalytics;
+
+import android.os.SystemClock;
+import android.text.TextUtils;
+import com.glu.plugins.gluanalytics.network.NetworkResponse;
+import com.glu.plugins.gluanalytics.network.NetworkUtils;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.ironsource.nb;
+import java.net.URL;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public class CacheService {
+    private String mBundleId;
+    private long mCacheServiceTimeout;
+    private Map<String, String> mHeaders;
+    private String mLastGameName;
+    private String mLastRevId;
+    private String mLastS;
+    private long mLastSentTime;
+    private String mLastSessId;
+    private String mLastUid;
+    private URL mUrl;
+    private final YLogger mLog = YLogger.create(getClass());
+    private ScheduledExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();
+
+    public CacheService(String str, String str2, long j) {
+        this.mBundleId = str;
+        try {
+            this.mUrl = new URL(str2);
+        } catch (Exception e) {
+            this.mLog.i("CacheService", "URL", e.getMessage());
+        }
+        Map<String, String> createMap = CollectionUtil.createMap();
+        this.mHeaders = createMap;
+        createMap.put("Content-Type", nb.L);
+        this.mLastSentTime = -1L;
+        this.mCacheServiceTimeout = j;
+        scheduleUpdate();
+    }
+
+    public void destroy() {
+        this.mExecutor.shutdownNow();
+    }
+
+    public void putData(final String str, final String str2, final String str3, final String str4, final String str5, String str6) {
+        try {
+            this.mExecutor.execute(new Runnable() { // from class: com.glu.plugins.gluanalytics.CacheService.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    CacheService.this.doPutData(str, str2, str3, str4, str5);
+                }
+            });
+        } catch (Exception e) {
+            this.mLog.i("CacheService", "Exception", e.getMessage());
+        }
+    }
+
+    private void scheduleUpdate() {
+        try {
+            this.mExecutor.scheduleAtFixedRate(new Runnable() { // from class: com.glu.plugins.gluanalytics.CacheService.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    CacheService cacheService = CacheService.this;
+                    cacheService.doPutData(cacheService.mLastS, CacheService.this.mLastGameName, CacheService.this.mLastUid, CacheService.this.mLastRevId, CacheService.this.mLastSessId);
+                }
+            }, 1L, 1L, TimeUnit.MINUTES);
+        } catch (Exception e) {
+            this.mLog.i("CacheService", "Exception", e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void doPutData(String str, String str2, String str3, String str4, String str5) {
+        if (TextUtils.isEmpty(str) || TextUtils.isEmpty(str2) || TextUtils.isEmpty(str3) || TextUtils.isEmpty(str4) || TextUtils.isEmpty(str5)) {
+            this.mLog.i("CacheService", "Ignore", String.format("s=%s, game_name=%s, uid=%s, rev_id=%s, sess_id=%s, bundle_id=%s", str, str2, str3, str4, str5, this.mBundleId));
+            return;
+        }
+        if (!str.equals(this.mLastS) || !str2.equals(this.mLastGameName) || !str3.equals(this.mLastUid) || !str4.equals(this.mLastRevId) || !str5.equals(this.mLastSessId)) {
+            this.mLastS = str;
+            this.mLastGameName = str2;
+            this.mLastUid = str3;
+            this.mLastRevId = str4;
+            this.mLastSessId = str5;
+            this.mLastSentTime = -1L;
+        }
+        sendPutRequset(str, str2, str3, str4, str5);
+    }
+
+    private void sendPutRequset(String str, String str2, String str3, String str4, String str5) {
+        long elapsedRealtime = SystemClock.elapsedRealtime() / 1000;
+        long j = this.mLastSentTime;
+        if (j < 0 || elapsedRealtime - j >= this.mCacheServiceTimeout) {
+            String format = String.format("{\"s\":\"%s\",\"game_name\":\"%s\",\"uid\":\"%s\",\"rev_id\":\"%s\",\"sess_id\":\"%s\",\"bundle_id\":\"%s\"}", str, str2, str3, str4, str5, this.mBundleId);
+            this.mLog.i("CacheService", "Data", format);
+            NetworkResponse sendRequest = NetworkUtils.sendRequest("POST", this.mUrl, this.mHeaders, format, 0);
+            Throwable th = sendRequest.throwable;
+            if (th == null) {
+                byte[] bArr = sendRequest.body;
+                this.mLog.i("CacheService", "SendRequest", Integer.valueOf(sendRequest.code), "Body", (bArr != null ? new String(bArr) : "null").replaceAll("\\s", ""));
+                this.mLastSentTime = elapsedRealtime;
+                return;
+            }
+            this.mLog.i("CacheService", "SendRequest", th.getMessage());
+            return;
+        }
+        this.mLog.i("CacheService", "Ignore", "Not expired");
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/CustomProperties.java

@@ -0,0 +1,7 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public class CustomProperties {
+    public boolean internalTargetedAds;
+    public boolean usageSharing;
+}

decompiled/sources/com/glu/plugins/gluanalytics/DummyRecorderStream.java

@@ -0,0 +1,16 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public class DummyRecorderStream implements IRecordStream {
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void flush() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void saveRecord(String str, String str2) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void setMaxStorageSize(long j) {
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/GeoLocation.java

@@ -0,0 +1,24 @@
+package com.glu.plugins.gluanalytics;
+
+import com.ea.nimble.ApplicationEnvironment;
+import com.glu.plugins.gluanalytics.util.ISerializableJsonObject;
+import com.glu.plugins.gluanalytics.util.JsonUtil;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class GeoLocation implements ISerializableJsonObject {
+    public String countryCode;
+    public String ipAddress;
+
+    public GeoLocation(String str, String str2) {
+        this.ipAddress = str;
+        this.countryCode = str2;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.ISerializableJsonObject
+    public void write(JSONStringer jSONStringer) throws JSONException {
+        JsonUtil.optKeyValue(jSONStringer, "ipAddress", this.ipAddress);
+        JsonUtil.optKeyValue(jSONStringer, ApplicationEnvironment.NIMBLE_PARAMETER_COUNTRY_CODE, this.countryCode);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/GluAnalyticsPinpoint.java

@@ -0,0 +1,56 @@
+package com.glu.plugins.gluanalytics;
+
+import android.text.TextUtils;
+import androidx.core.app.NotificationCompat;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.glu.plugins.gluanalytics.eventbus.GluEventBus;
+import com.glu.plugins.gluanalytics.util.ConfigUtil;
+import com.ironsource.Cif;
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class GluAnalyticsPinpoint implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_SDK = "#csdk.gluAnalytics.pinpoint";
+    private static final String ID_HANDLER = "@csdk.gluAnalytics.pinpoint";
+    private GluEventBus mEventBus;
+    private WeakReference<GluAnalytics> mImpl;
+    private Object mToken;
+
+    public GluAnalyticsPinpoint(GluEventBus gluEventBus, GluAnalytics gluAnalytics) {
+        this.mEventBus = gluEventBus;
+        this.mToken = gluEventBus.subscribe(GluEventBus.GLOBAL_TOKEN, ID_HANDLER, Arrays.asList(CHANNEL_SDK), this);
+        this.mImpl = new WeakReference<>(gluAnalytics);
+    }
+
+    public void destroy() {
+        this.mImpl = null;
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) {
+        GluAnalytics gluAnalytics;
+        if (!CHANNEL_SDK.equals(event.channel) || (gluAnalytics = this.mImpl.get()) == null) {
+            return;
+        }
+        Map<String, Object> map = event.data;
+        String string = ConfigUtil.getString(map, SDKConstants.PARAM_USER_ID, null);
+        if (TextUtils.equals(event.action, "setPushToken")) {
+            gluAnalytics.internal_pinpointAttribute("devicetoken", ConfigUtil.getString(map, "val", null), string, null);
+        }
+        if (TextUtils.equals(event.action, "encryptedBase64Email")) {
+            gluAnalytics.internal_pinpointAttribute("email", ConfigUtil.getString(map, "email", null), string, null);
+        }
+        if (TextUtils.equals(event.action, Cif.j)) {
+            gluAnalytics.internal_pinpointAttribute(ConfigUtil.getString(map, "msg", null), gluAnalytics.getAnalyticsDeviceIdentifier(), string, null);
+        }
+        if (TextUtils.equals(event.action, "emailSubscriptionStatus")) {
+            gluAnalytics.internal_pinpointAttribute("emailSubscriptionStatus", ConfigUtil.getString(map, "status", null), string, null);
+        }
+        if (TextUtils.equals(event.action, "logEvent")) {
+            gluAnalytics.internal_pinpointAttribute(NotificationCompat.CATEGORY_EVENT, ConfigUtil.getString(map, NotificationCompat.CATEGORY_EVENT, null), string, ConfigUtil.getMap(map, "extra", null));
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/GluFirebase.java

@@ -0,0 +1,215 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Context;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.ConfigUtil;
+import com.glu.plugins.gluanalytics.util.IAction;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import com.google.firebase.messaging.FirebaseMessaging;
+import java.util.ArrayDeque;
+import java.util.Map;
+import java.util.Queue;
+
+/* loaded from: classes2.dex */
+public class GluFirebase {
+    private static boolean FIRAppHasBeenConfigured = false;
+    private static final String FIREBASE_PATH_PREFIX = "csdk.gluAnalytics.firebase.";
+    private IAnalyticsCallback mAnalyticsCallback;
+    private Context mContext;
+    private FirebaseAnalytics mFirebaseAnalytics;
+    private boolean mSendRevID;
+    private final YLogger mLog = YLogger.create(getClass());
+    private boolean mFirebaseInitialized = false;
+    private boolean mFirebaseEnabled = false;
+    private boolean mDisableTrackRevenue = false;
+    private boolean mUnderAgeUser = false;
+    private final Queue<IAction> mQueue = new ArrayDeque();
+
+    public void updateUnderAgeUserStatus(boolean z) {
+        this.mUnderAgeUser = z;
+    }
+
+    public GluFirebase(Context context) {
+        this.mContext = context;
+    }
+
+    public void initialize(@Nullable Map<String, Object> map, IAnalyticsCallback iAnalyticsCallback) {
+        this.mAnalyticsCallback = iAnalyticsCallback;
+        boolean z = !ConfigUtil.getBoolean(map, "csdk.gluAnalytics.disabled.firebase", false);
+        this.mFirebaseEnabled = z;
+        this.mLog.i("FirebaseApp", "Enabled", Boolean.valueOf(z));
+        boolean z2 = ConfigUtil.getBoolean(map, "csdk.gluAnalytics.firebase.skipInit", true);
+        this.mDisableTrackRevenue = ConfigUtil.getBoolean(map, "csdk.gluAnalytics.firebase.disableTrackRevenueEvent", true);
+        this.mSendRevID = ConfigUtil.getBoolean(map, "csdk.gluAnalytics.firebase.sendRevID", true);
+        if (this.mFirebaseEnabled && z2) {
+            try {
+                this.mLog.i("FirebaseApp", "initializeApp", FirebaseApp.getInstance().getName(), InneractiveMediationDefs.GENDER_MALE, "Firebase initialized outside GluAnalytics SDK");
+            } catch (Throwable th) {
+                this.mLog.i("FirebaseApp", "Throwable", th.getMessage());
+            }
+        }
+        if (this.mFirebaseEnabled && !FIRAppHasBeenConfigured && !z2) {
+            try {
+                FirebaseOptions.Builder builder = new FirebaseOptions.Builder();
+                builder.setApplicationId(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.googleAppID", null));
+                builder.setApiKey(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.APIKey", null));
+                builder.setDatabaseUrl(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.databaseURL", null));
+                builder.setStorageBucket(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.storageBucket", null));
+                builder.setGcmSenderId(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.GCMSenderID", null));
+                builder.setProjectId(ConfigUtil.getString(map, "csdk.gluAnalytics.firebase.projectID", null));
+                FirebaseApp.initializeApp(this.mContext, builder.build());
+                FIRAppHasBeenConfigured = true;
+                this.mLog.i("FirebaseApp", "initializeApp", FirebaseApp.getInstance().getName());
+            } catch (Throwable th2) {
+                this.mLog.i("FirebaseApp", "Throwable", th2.getMessage());
+            }
+        }
+        try {
+            this.mFirebaseAnalytics = FirebaseApp.getInstance() != null ? FirebaseAnalytics.getInstance(this.mContext) : null;
+        } catch (Throwable th3) {
+            this.mLog.i("FirebaseApp", "Throwable", th3.getMessage());
+        }
+        this.mFirebaseInitialized = true;
+        flushCachedQueue();
+        if (this.mFirebaseEnabled) {
+            fetchDeviceToken();
+        }
+    }
+
+    private void flushCachedQueue() {
+        IAction peek;
+        boolean z = true;
+        while (true) {
+            synchronized (this) {
+                if (!z) {
+                    try {
+                        this.mQueue.poll();
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+                if (this.mQueue.isEmpty()) {
+                    return;
+                } else {
+                    peek = this.mQueue.peek();
+                }
+            }
+            peek.apply();
+            z = false;
+        }
+    }
+
+    private Bundle getEventExtrasSkipKey(Map<String, Object> map, String str) {
+        Bundle bundle = new Bundle();
+        if (map != null) {
+            for (Map.Entry<String, Object> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key != str) {
+                    Object value = entry.getValue();
+                    if (value instanceof String) {
+                        bundle.putString(key, (String) value);
+                    } else if (value instanceof Long) {
+                        bundle.putLong(key, ((Long) value).longValue());
+                    } else if (value instanceof Double) {
+                        bundle.putDouble(key, ((Double) value).doubleValue());
+                    } else if (value instanceof Boolean) {
+                        bundle.putBoolean(key, ((Boolean) value).booleanValue());
+                    } else {
+                        this.mLog.e("getEventExtrasSkipKey", "Unknonwn value type.");
+                    }
+                }
+            }
+        }
+        return bundle;
+    }
+
+    public void logEvent(final String str, Map<String, Object> map) {
+        if (this.mFirebaseInitialized) {
+            internal_logEvent(str, map);
+            return;
+        }
+        synchronized (this) {
+            final Map shallowClone = CollectionUtil.shallowClone(map);
+            this.mQueue.add(new IAction() { // from class: com.glu.plugins.gluanalytics.GluFirebase.1
+                @Override // com.glu.plugins.gluanalytics.util.IAction
+                public void apply() {
+                    GluFirebase.this.internal_logEvent(str, shallowClone);
+                }
+            });
+        }
+    }
+
+    public void allowPersonalizedAds(final boolean z) {
+        if (this.mFirebaseInitialized) {
+            internal_allowPersonalizedAds(z);
+        } else {
+            synchronized (this) {
+                this.mQueue.add(new IAction() { // from class: com.glu.plugins.gluanalytics.GluFirebase.2
+                    @Override // com.glu.plugins.gluanalytics.util.IAction
+                    public void apply() {
+                        GluFirebase.this.internal_allowPersonalizedAds(z);
+                    }
+                });
+            }
+        }
+    }
+
+    public void internal_logEvent(String str, Map<String, Object> map) {
+        if (!this.mFirebaseEnabled || this.mFirebaseAnalytics == null || this.mUnderAgeUser) {
+            return;
+        }
+        if (this.mDisableTrackRevenue && str.equals("trackRevenue")) {
+            return;
+        }
+        this.mFirebaseAnalytics.logEvent(str, getEventExtrasSkipKey(map, str));
+    }
+
+    public void internal_allowPersonalizedAds(boolean z) {
+        FirebaseAnalytics firebaseAnalytics;
+        if (!this.mFirebaseEnabled || (firebaseAnalytics = this.mFirebaseAnalytics) == null) {
+            return;
+        }
+        String str = z ? "true" : "false";
+        firebaseAnalytics.setUserProperty("allow_personalized_ads", str);
+        this.mLog.i("allowPersonalizedAds", "state", str);
+    }
+
+    public void internal_SetRevID(String str) {
+        if (this.mFirebaseEnabled && this.mSendRevID) {
+            if (!this.mUnderAgeUser) {
+                this.mFirebaseAnalytics.setUserId(str);
+                this.mLog.i("internalsetrevid", "revid", str);
+            } else {
+                this.mFirebaseAnalytics.setUserId("");
+            }
+        }
+    }
+
+    private void fetchDeviceToken() {
+        try {
+            if (FirebaseApp.getInstance() != null) {
+                FirebaseMessaging.getInstance().getToken().addOnCompleteListener(new OnCompleteListener<String>() { // from class: com.glu.plugins.gluanalytics.GluFirebase.3
+                    @Override // com.google.android.gms.tasks.OnCompleteListener
+                    public void onComplete(@NonNull Task<String> task) {
+                        if (!task.isSuccessful()) {
+                            GluFirebase.this.mLog.i("FirebaseApp", "Fetching FCM registration token failed", task.getException().getMessage());
+                        } else {
+                            GluFirebase.this.mAnalyticsCallback.setPushToken(task.getResult());
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            this.mLog.i("FirebaseApp", "Throwable", e.getMessage());
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/GluPerformance.java

@@ -0,0 +1,436 @@
+package com.glu.plugins.gluanalytics;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.os.Process;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public class GluPerformance implements IPerformance {
+    private static long preSDKLoadStartTimeStamp;
+    private ActivityManager mActivityManager;
+    private IAnalytics mAnalytics;
+    private boolean mDevBuild;
+    private ScheduledThreadPoolExecutor mExecutor;
+    private boolean mHasVersionChanged;
+    private boolean mIsFirstLaunch;
+    private double mLatestFPS;
+    PerfSample mPreInitSample;
+    private boolean mRunning;
+    private double mSampleInterval;
+    private double mTargetFrameRate;
+    private final Object lock = new Object();
+    private final YLogger mLog = YLogger.create(getClass());
+    final String LOG_NAME_PERFORMANCE = "PERFORMANCE";
+    final String LOG_EVENT_SOURCE_SDK = "SDK_STANDARD";
+    final String APP_PERFORMANCE = "APP_PERFORMANCE";
+    private HashMap<String, PerfSample> mPerfSamples = new HashMap<>();
+    private int mFrameCount = 0;
+    private long mLastFrameTime = 0;
+    private FrameTask mFrameTask = new FrameTask();
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void internal_SetAnalytics(IAnalytics iAnalytics) {
+        this.mAnalytics = iAnalytics;
+    }
+
+    public static /* synthetic */ int access$408(GluPerformance gluPerformance) {
+        int i = gluPerformance.mFrameCount;
+        gluPerformance.mFrameCount = i + 1;
+        return i;
+    }
+
+    public GluPerformance(Context context, double d, double d2, boolean z, double d3, boolean z2, boolean z3) {
+        this.mSampleInterval = d;
+        this.mTargetFrameRate = d2;
+        this.mDevBuild = z;
+        this.mIsFirstLaunch = z2;
+        this.mHasVersionChanged = z3;
+        this.mActivityManager = (ActivityManager) context.getSystemService("activity");
+        this.mLatestFPS = d2;
+        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
+        this.mExecutor = scheduledThreadPoolExecutor;
+        scheduledThreadPoolExecutor.scheduleAtFixedRate(new SampleTask(), 0L, (long) (d * 1000.0d), TimeUnit.MILLISECONDS);
+        this.mRunning = true;
+        this.mPreInitSample = null;
+        logPreBootSample(d3);
+        perfSampleStart("APP_PERFORMANCE", 7, null);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public double getUsedMemory() {
+        return this.mActivityManager.getProcessMemoryInfo(new int[]{Process.myPid()})[0].getTotalPss() / 1024.0f;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void destroy() {
+        if (this.mRunning) {
+            perfSampleEnd("APP_PERFORMANCE", null);
+            this.mRunning = false;
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void onResume() {
+        this.mFrameCount = 0;
+        this.mLastFrameTime = 0L;
+        this.mFrameTask.start();
+        if (!this.mRunning) {
+            this.mRunning = true;
+            perfSampleStart("APP_PERFORMANCE", 7, null);
+        }
+        for (String str : this.mPerfSamples.keySet()) {
+            Map<String, ?> map = this.mPerfSamples.get(str).userData;
+            if (map != null && map.containsKey("autoPause")) {
+                perfSampleAction(str, 1);
+            }
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void onPause() {
+        if (this.mRunning) {
+            perfSampleEnd("APP_PERFORMANCE", null);
+            this.mRunning = false;
+        }
+        this.mFrameTask.end();
+        synchronized (this.lock) {
+            try {
+                for (Map.Entry<String, PerfSample> entry : this.mPerfSamples.entrySet()) {
+                    PerfSample value = entry.getValue();
+                    value.isSuspended = true;
+                    Map<String, ?> map = value.userData;
+                    if (map != null && map.containsKey("autoPause")) {
+                        perfSampleAction(entry.getKey(), 0);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void internal_LogLaunchOverhead() {
+        PerfSample perfSample = this.mPreInitSample;
+        if (perfSample != null) {
+            flush(perfSample);
+            this.mPreInitSample = null;
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void perfSampleStart(String str, int i, Map<String, ?> map) {
+        synchronized (this.lock) {
+            try {
+                if (this.mPerfSamples.containsKey(str)) {
+                    this.mLog.e("PerfSampleStart", InneractiveMediationDefs.GENDER_MALE, "placement has already exist, ignored.", "placement", str);
+                    return;
+                }
+                PerfSample perfSample = new PerfSample();
+                perfSample.placement = str;
+                perfSample.type = i;
+                perfSample.userData = map;
+                perfSample.maxMemory = 0.0d;
+                perfSample.totalMemory = 0.0d;
+                perfSample.startMemory = this.mDevBuild ? getUsedMemory() : 0.0d;
+                perfSample.endMemory = 0.0d;
+                perfSample.minFPS = this.mTargetFrameRate;
+                perfSample.maxFPS = 0.0d;
+                perfSample.totalFPS = 0.0d;
+                perfSample.lastFPS = 0.0d;
+                perfSample.sampleCount = 0L;
+                perfSample.startTimeStamp = SystemClock.uptimeMillis();
+                perfSample.isSuspended = false;
+                perfSample.isPaused = false;
+                perfSample.startPausedTimeStamp = 0.0d;
+                perfSample.pausedTimeTotal = 0.0d;
+                perfSample.preInitTime = 0.0d;
+                synchronized (this.lock) {
+                    this.mPerfSamples.put(str, perfSample);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void perfSampleEnd(String str, Map<String, ?> map) {
+        synchronized (this.lock) {
+            try {
+                if (!this.mPerfSamples.containsKey(str)) {
+                    this.mLog.e("PerfSampleEnd", InneractiveMediationDefs.GENDER_MALE, "placement is not exist, ignored.", "placement", str);
+                    return;
+                }
+                PerfSample perfSample = this.mPerfSamples.get(str);
+                this.mPerfSamples.remove(str);
+                if (map != null && map.size() != 0) {
+                    perfSample.userData = map;
+                }
+                perfSample.endMemory = this.mDevBuild ? getUsedMemory() : 0.0d;
+                flush(perfSample);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public PerfMeasure perfGetValues() {
+        PerfMeasure perfMeasure = new PerfMeasure();
+        boolean containsKey = this.mPerfSamples.containsKey("APP_PERFORMANCE");
+        PerfSample perfSample = this.mPerfSamples.get("APP_PERFORMANCE");
+        if (!containsKey || (perfSample.type & 4) == 0 || perfSample.isPaused) {
+            perfMeasure.averageFPS = -1.0d;
+            perfMeasure.lastFPS = -1.0d;
+            perfMeasure.minFPS = -1.0d;
+            perfMeasure.maxFPS = -1.0d;
+        } else {
+            perfMeasure.averageFPS = perfSample.totalFPS / perfSample.sampleCount;
+            perfMeasure.lastFPS = perfSample.lastFPS;
+            perfMeasure.minFPS = perfSample.minFPS;
+            perfMeasure.maxFPS = perfSample.maxFPS;
+        }
+        if (!containsKey || (perfSample.type & 2) == 0 || perfSample.isPaused) {
+            perfMeasure.startMem = -1.0d;
+            perfMeasure.maxMem = -1.0d;
+            perfMeasure.currentMem = -1.0d;
+        } else {
+            perfMeasure.startMem = perfSample.startMemory;
+            perfMeasure.maxMem = perfSample.maxMemory;
+            perfMeasure.currentMem = getUsedMemory();
+        }
+        if (!containsKey || (perfSample.type & 2) == 0 || perfSample.isPaused) {
+            perfMeasure.time = -1.0d;
+        } else {
+            perfMeasure.time = (SystemClock.uptimeMillis() - perfSample.startTimeStamp) - perfSample.pausedTimeTotal;
+        }
+        return perfMeasure;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public boolean perfSampleAction(String str, int i) {
+        if (!this.mPerfSamples.containsKey(str)) {
+            return false;
+        }
+        PerfSample perfSample = this.mPerfSamples.get(str);
+        if (i != 0) {
+            if (i != 1) {
+                if (i == 2) {
+                    synchronized (this.lock) {
+                        this.mPerfSamples.remove(str);
+                    }
+                }
+            } else {
+                if (!perfSample.isPaused) {
+                    return false;
+                }
+                perfSample.isPaused = false;
+                perfSample.pausedTimeTotal += SystemClock.uptimeMillis() - perfSample.startPausedTimeStamp;
+            }
+        } else {
+            if (perfSample.isPaused) {
+                return false;
+            }
+            perfSample.isPaused = true;
+            perfSample.startPausedTimeStamp = SystemClock.uptimeMillis();
+        }
+        return true;
+    }
+
+    public static void perfSampleLogLaunchOverhead() {
+        preSDKLoadStartTimeStamp = SystemClock.uptimeMillis();
+    }
+
+    public void logPreBootSample(double d) {
+        if (0 != preSDKLoadStartTimeStamp || d > 0.0d) {
+            PerfSample perfSample = new PerfSample();
+            this.mPreInitSample = perfSample;
+            perfSample.placement = "LAUNCH_OVERHEAD";
+            perfSample.userData = null;
+            perfSample.type = 1;
+            if (d > 0.0d) {
+                perfSample.preInitTime = d * 1000.0d;
+            } else {
+                perfSample.startTimeStamp = preSDKLoadStartTimeStamp;
+            }
+            perfSample.isSuspended = false;
+        }
+    }
+
+    private void flush(PerfSample perfSample) {
+        HashMap hashMap;
+        if (perfSample == null) {
+            return;
+        }
+        if (perfSample.userData == null) {
+            hashMap = new HashMap();
+        } else {
+            hashMap = new HashMap(perfSample.userData);
+        }
+        HashMap hashMap2 = hashMap;
+        if (this.mIsFirstLaunch) {
+            hashMap2.put("isFirstLaunch", "true");
+        }
+        if (this.mHasVersionChanged) {
+            hashMap2.put("wasVersionUpdated", "true");
+        }
+        if ((perfSample.type & 2) != 0) {
+            if (this.mDevBuild) {
+                hashMap2.put("start_mem", Double.valueOf(perfSample.startMemory));
+                hashMap2.put("end_mem", Double.valueOf(perfSample.endMemory));
+            }
+            if (perfSample.sampleCount != 0) {
+                hashMap2.put("max_mem", Double.valueOf(perfSample.maxMemory));
+                hashMap2.put("avg_mem", Double.valueOf(perfSample.totalMemory / perfSample.sampleCount));
+            } else if (this.mDevBuild) {
+                hashMap2.put("max_mem", Double.valueOf(Math.max(perfSample.startMemory, perfSample.endMemory)));
+                hashMap2.put("avg_mem", Double.valueOf((perfSample.startMemory + perfSample.endMemory) * 0.5d));
+            }
+        }
+        if ((perfSample.type & 4) != 0 && perfSample.sampleCount != 0) {
+            hashMap2.put("min_fps", Double.valueOf(perfSample.minFPS));
+            hashMap2.put("avg_fps", Double.valueOf(perfSample.totalFPS / perfSample.sampleCount));
+            hashMap2.put("target_fps", Double.valueOf(this.mTargetFrameRate));
+        }
+        if ((perfSample.type & 1) != 0) {
+            double d = perfSample.preInitTime;
+            if (d > 0.0d) {
+                hashMap2.put("time_ms", Double.valueOf(d));
+            } else {
+                hashMap2.put("time_ms", Double.valueOf((SystemClock.uptimeMillis() - perfSample.startTimeStamp) - perfSample.pausedTimeTotal));
+            }
+            if (perfSample.isSuspended) {
+                hashMap2.put("is_suspended", Boolean.TRUE);
+            }
+        }
+        this.mAnalytics.internal_perfEvent(perfSample.placement, "PERFORMANCE", String.valueOf(perfSample.type), null, "SDK_STANDARD", hashMap2);
+    }
+
+    @TargetApi(16)
+    public class FrameTask implements Choreographer.FrameCallback {
+        private Choreographer choreographer;
+
+        public FrameTask() {
+            try {
+                this.choreographer = Choreographer.getInstance();
+                start();
+            } catch (Exception unused) {
+                GluPerformance.this.mLog.e("PerfSample", InneractiveMediationDefs.GENDER_MALE, "GluPerformance is created in a thread without looper!");
+                Common.runOnUIThread(new Runnable() { // from class: com.glu.plugins.gluanalytics.GluPerformance.FrameTask.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        FrameTask.this.choreographer = Choreographer.getInstance();
+                        FrameTask.this.start();
+                    }
+                });
+            }
+        }
+
+        public void start() {
+            Choreographer choreographer = this.choreographer;
+            if (choreographer != null) {
+                choreographer.postFrameCallback(this);
+            }
+        }
+
+        public void end() {
+            Choreographer choreographer = this.choreographer;
+            if (choreographer != null) {
+                choreographer.removeFrameCallback(this);
+            }
+        }
+
+        @Override // android.view.Choreographer.FrameCallback
+        public void doFrame(long j) {
+            if (GluPerformance.this.mLastFrameTime == 0) {
+                GluPerformance.this.mLastFrameTime = j;
+            } else {
+                GluPerformance.access$408(GluPerformance.this);
+                double d = (j - GluPerformance.this.mLastFrameTime) * 1.0E-9d;
+                if (d >= GluPerformance.this.mSampleInterval) {
+                    GluPerformance.this.mLastFrameTime = j;
+                    GluPerformance.this.mLatestFPS = r5.mFrameCount / d;
+                    GluPerformance.this.mFrameCount = 0;
+                }
+            }
+            this.choreographer.postFrameCallback(this);
+        }
+    }
+
+    public class SampleTask implements Runnable {
+        public SampleTask() {
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            synchronized (GluPerformance.this.lock) {
+                if (GluPerformance.this.mPerfSamples.size() != 0 && GluPerformance.this.mRunning) {
+                    double usedMemory = GluPerformance.this.getUsedMemory();
+                    double min = Math.min(GluPerformance.this.mLatestFPS, GluPerformance.this.mTargetFrameRate);
+                    synchronized (GluPerformance.this.lock) {
+                        try {
+                            for (PerfSample perfSample : GluPerformance.this.mPerfSamples.values()) {
+                                if (!perfSample.isPaused) {
+                                    perfSample.sampleCount++;
+                                    int i = perfSample.type;
+                                    if ((i & 2) != 0) {
+                                        perfSample.totalMemory += usedMemory;
+                                        if (perfSample.maxMemory < usedMemory) {
+                                            perfSample.maxMemory = usedMemory;
+                                        }
+                                    }
+                                    if ((i & 4) != 0) {
+                                        perfSample.totalFPS += min;
+                                        perfSample.lastFPS = min;
+                                        if (perfSample.minFPS > min) {
+                                            perfSample.minFPS = min;
+                                        }
+                                        if (perfSample.maxFPS < min) {
+                                            perfSample.maxFPS = min;
+                                        }
+                                    }
+                                }
+                            }
+                        } finally {
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public class PerfSample {
+        double endMemory;
+        boolean isPaused;
+        boolean isSuspended;
+        double lastFPS;
+        double maxFPS;
+        double maxMemory;
+        double minFPS;
+        double pausedTimeTotal;
+        String placement;
+        double preInitTime;
+        long sampleCount;
+        double startMemory;
+        double startPausedTimeStamp;
+        double startTimeStamp;
+        double totalFPS;
+        double totalMemory;
+        int type;
+        Map<String, ?> userData;
+
+        private PerfSample() {
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/GluPerformanceDummy.java

@@ -0,0 +1,44 @@
+package com.glu.plugins.gluanalytics;
+
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class GluPerformanceDummy implements IPerformance {
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void destroy() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void internal_LogLaunchOverhead() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void internal_SetAnalytics(IAnalytics iAnalytics) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void onPause() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void onResume() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public boolean perfSampleAction(String str, int i) {
+        return true;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void perfSampleEnd(String str, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public void perfSampleStart(String str, int i, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IPerformance
+    public PerfMeasure perfGetValues() {
+        return new PerfMeasure();
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/IAnalytics.java

@@ -0,0 +1,63 @@
+package com.glu.plugins.gluanalytics;
+
+import java.math.BigDecimal;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public interface IAnalytics {
+    public static final int PerfActionDrop = 2;
+    public static final int PerfActionPause = 0;
+    public static final int PerfActionResume = 1;
+    public static final int PerfTypeAll = 7;
+    public static final int PerfTypeFPS = 4;
+    public static final int PerfTypeMemory = 2;
+    public static final int PerfTypeTime = 1;
+
+    void destroy();
+
+    Map<String, Object> getCustomProperties();
+
+    GeoLocation getGeoLocation();
+
+    void init(IAnalyticsCallback iAnalyticsCallback);
+
+    void internal_logCpuEvent(Map<String, ?> map);
+
+    void internal_logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map);
+
+    void internal_logEvent_adImpression(String str, String str2, String str3, String str4, BigDecimal bigDecimal, Long l, Map<String, ?> map);
+
+    void internal_perfEvent(String str, String str2, String str3, String str4, String str5, Map<String, Object> map);
+
+    void internal_pinpointAttribute(String str, String str2, String str3, Map<String, Object> map);
+
+    void internal_setRevID(String str, String str2, boolean z);
+
+    void internal_trackRevenueInUsd(double d, String str, String str2, String str3, Map<String, ?> map);
+
+    void internal_updatePSValue(String str, boolean z, String str2, String str3, String str4, String str5, String str6, String str7);
+
+    void logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map);
+
+    void onPause();
+
+    void onResume();
+
+    PerfMeasure perfGetValues();
+
+    boolean perfSampleAction(String str, int i);
+
+    void perfSampleEnd(String str, Map<String, ?> map);
+
+    void perfSampleStart(String str, int i, Map<String, ?> map);
+
+    void setCustomProperties(Map<String, Object> map);
+
+    void setEATargetedMarketing(boolean z);
+
+    void setUserIdentifier(String str);
+
+    void shortcircuitEATargetedMarketingOff();
+
+    void userAgedUp();
+}

decompiled/sources/com/glu/plugins/gluanalytics/IAnalyticsCallback.java

@@ -0,0 +1,18 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public interface IAnalyticsCallback {
+    void internalTargetedAdsChanged(boolean z);
+
+    void onDestroy();
+
+    void onInit(String str, String str2, String str3, String str4, String str5, String str6);
+
+    void onUpdateSessionId();
+
+    void onUserIdChanged(String str, String str2);
+
+    void recordAnalyticsRequest(String str, String str2, String str3, String str4, String str5, String str6, String str7);
+
+    void setPushToken(String str);
+}

decompiled/sources/com/glu/plugins/gluanalytics/IAnalyticsParametersGetter.java

@@ -0,0 +1,18 @@
+package com.glu.plugins.gluanalytics;
+
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public interface IAnalyticsParametersGetter {
+    String getAnalyticsApplicationName();
+
+    String getAnalyticsDeviceIdentifier();
+
+    String getAnalyticsEnvironment();
+
+    Map<String, Object> getCustomProperties();
+
+    String getRevenueIdentifier();
+
+    String getSessionIdentifier();
+}

decompiled/sources/com/glu/plugins/gluanalytics/IPerformance.java

@@ -0,0 +1,24 @@
+package com.glu.plugins.gluanalytics;
+
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public interface IPerformance {
+    void destroy();
+
+    void internal_LogLaunchOverhead();
+
+    void internal_SetAnalytics(IAnalytics iAnalytics);
+
+    void onPause();
+
+    void onResume();
+
+    PerfMeasure perfGetValues();
+
+    boolean perfSampleAction(String str, int i);
+
+    void perfSampleEnd(String str, Map<String, ?> map);
+
+    void perfSampleStart(String str, int i, Map<String, ?> map);
+}

decompiled/sources/com/glu/plugins/gluanalytics/IRecordStream.java

@@ -0,0 +1,10 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public interface IRecordStream {
+    void flush();
+
+    void saveRecord(String str, String str2);
+
+    void setMaxStorageSize(long j);
+}

decompiled/sources/com/glu/plugins/gluanalytics/KinesisRecorderStream.java

@@ -0,0 +1,89 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.mobileconnectors.kinesis.kinesisrecorder.KinesisRecorder;
+import com.amazonaws.mobileconnectors.kinesis.kinesisrecorder.KinesisRecorderConfig;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import com.ironsource.ad;
+import csdk.gluads.Consts;
+import java.io.UnsupportedEncodingException;
+import java.net.UnknownHostException;
+
+/* loaded from: classes2.dex */
+public class KinesisRecorderStream implements IRecordStream {
+    private final Handler mHandler;
+    private final YLogger mLog;
+    private KinesisRecorder mut_kinesis;
+
+    private KinesisRecorderStream(String str, Looper looper) {
+        this.mLog = YLogger.create("Kinesis-" + str);
+        this.mHandler = new Handler(looper);
+    }
+
+    public static IRecordStream create(final Context context, String str, Looper looper, final KinesisSharedCognito kinesisSharedCognito, final String str2) {
+        KinesisRecorderStream kinesisRecorderStream = new KinesisRecorderStream(str, looper);
+        kinesisRecorderStream.mHandler.post(new Runnable() { // from class: com.glu.plugins.gluanalytics.KinesisRecorderStream.1
+            @Override // java.lang.Runnable
+            public void run() {
+                KinesisRecorderStream.this.mut_kinesis = new KinesisRecorder(context.getDir(str2, 0), kinesisSharedCognito.getRegion(), kinesisSharedCognito.getAWSCredentialsProvider());
+            }
+        });
+        return kinesisRecorderStream;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void saveRecord(final String str, final String str2) {
+        final long nanoTime = System.nanoTime();
+        this.mHandler.post(new Runnable() { // from class: com.glu.plugins.gluanalytics.KinesisRecorderStream.2
+            @Override // java.lang.Runnable
+            public void run() {
+                long nanoTime2 = System.nanoTime();
+                try {
+                    KinesisRecorderStream.this.mut_kinesis.saveRecord(str2.getBytes("UTF-8"), str);
+                    KinesisRecorderStream.this.mLog.v("RECORDER.SAVE.OK", "str", str, Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "ltn", Long.valueOf((nanoTime2 - nanoTime) / 1000000));
+                } catch (UnsupportedEncodingException e) {
+                    KinesisRecorderStream.this.mLog.e("RECORDER.SAVE.ERROR", InneractiveMediationDefs.GENDER_MALE, "utf-8-unsupported", "str", str, Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "e", e);
+                } catch (RuntimeException e2) {
+                    KinesisRecorderStream.this.mLog.e("RECORDER.SAVE.ERROR", InneractiveMediationDefs.GENDER_MALE, "failed-to-save", "str", str, Consts.KEY_TAPJOY_USER_ID_VERSION, str2, "e", e2);
+                }
+            }
+        });
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void setMaxStorageSize(long j) {
+        KinesisRecorderConfig kinesisRecorderConfig;
+        KinesisRecorder kinesisRecorder = this.mut_kinesis;
+        if (kinesisRecorder == null || (kinesisRecorderConfig = kinesisRecorder.getKinesisRecorderConfig()) == null) {
+            return;
+        }
+        kinesisRecorderConfig.withMaxStorageSize(j);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IRecordStream
+    public void flush() {
+        final long nanoTime = System.nanoTime();
+        this.mHandler.post(new Runnable() { // from class: com.glu.plugins.gluanalytics.KinesisRecorderStream.3
+            @Override // java.lang.Runnable
+            public void run() {
+                long nanoTime2 = System.nanoTime();
+                try {
+                    KinesisRecorderStream.this.mut_kinesis.submitAllRecords();
+                    KinesisRecorderStream.this.mLog.v("RECORDER.SUBMIT.OK", ad.l0, Long.valueOf((System.nanoTime() - nanoTime2) / 1000000), "ltn", Long.valueOf((nanoTime2 - nanoTime) / 1000000));
+                } catch (AmazonClientException e) {
+                    UnknownHostException unknownHostCause = Common.unknownHostCause(e);
+                    if (unknownHostCause != null) {
+                        KinesisRecorderStream.this.mLog.i("RECORDER.SUBMIT.ERROR", "e", unknownHostCause.getMessage());
+                    } else {
+                        KinesisRecorderStream.this.mLog.e("RECORDER.SUBMIT.ERROR", "e", e);
+                    }
+                }
+            }
+        });
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/KinesisSharedCognito.java

@@ -0,0 +1,39 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Context;
+import com.amazonaws.auth.AWSCredentialsProvider;
+import com.amazonaws.auth.CognitoCachingCredentialsProvider;
+import com.amazonaws.auth.CognitoCredentialsProvider;
+import com.amazonaws.logging.LogFactory;
+import com.amazonaws.regions.Regions;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public class KinesisSharedCognito {
+    private AWSCredentialsProvider mCognitoCredentialsProvider;
+    private final YLogger mLog;
+    private Regions mRegion;
+
+    public AWSCredentialsProvider getAWSCredentialsProvider() {
+        return this.mCognitoCredentialsProvider;
+    }
+
+    public Regions getRegion() {
+        return this.mRegion;
+    }
+
+    public KinesisSharedCognito(Context context, AwsProperties awsProperties) {
+        Logger.getLogger("com.amazonaws").setLevel(Level.OFF);
+        LogFactory.setLevel(LogFactory.Level.OFF);
+        this.mLog = YLogger.create("SharedCognito");
+        this.mRegion = Regions.fromName(awsProperties.region);
+        try {
+            this.mCognitoCredentialsProvider = new CognitoCachingCredentialsProvider(context, awsProperties.accountId, awsProperties.identityPoolId, awsProperties.unauthenticatedRoleArn, awsProperties.authenticatedRoleArn, this.mRegion);
+        } catch (Exception e) {
+            this.mLog.e("INIT.ERROR", "e", e);
+            this.mCognitoCredentialsProvider = new CognitoCredentialsProvider(awsProperties.accountId, awsProperties.identityPoolId, awsProperties.unauthenticatedRoleArn, awsProperties.authenticatedRoleArn, this.mRegion);
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/PerfMeasure.java

@@ -0,0 +1,13 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public class PerfMeasure {
+    public double averageFPS;
+    public double currentMem;
+    public double lastFPS;
+    public double maxFPS;
+    public double maxMem;
+    public double minFPS;
+    public double startMem;
+    public double time;
+}

decompiled/sources/com/glu/plugins/gluanalytics/R.java

@@ -0,0 +1,7 @@
+package com.glu.plugins.gluanalytics;
+
+/* loaded from: classes2.dex */
+public final class R {
+    private R() {
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/SharedPreferencesAnalytics.java

@@ -0,0 +1,157 @@
+package com.glu.plugins.gluanalytics;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.Conversion;
+import com.glu.plugins.gluanalytics.util.YLogger;
+import csdk.gluads.Consts;
+import java.math.BigDecimal;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class SharedPreferencesAnalytics implements IAnalytics {
+    private static final String PROP_INSTALL_TIMESTAMP = "install-timestamp";
+    private static final String PROP_LIFETIME_VALUE_CENTS = "lifetime-value-cents";
+    private static final String PROP_RUN_COUNT = "run-count";
+    private static final String PROP_RUN_COUNT_VERSION_X = "run-count-";
+    private static final String PROP_TOTAL_SESSION_DURATION = "total-session-duration";
+    private final YLogger mLog = YLogger.create(getClass());
+    private final SharedPreferences mPreferences;
+    private long mStartTime;
+    private final long mVersionCode;
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void destroy() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics, com.glu.plugins.gluanalytics.IAnalyticsParametersGetter
+    public Map<String, Object> getCustomProperties() {
+        return null;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public GeoLocation getGeoLocation() {
+        return null;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logCpuEvent(Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_logEvent_adImpression(String str, String str2, String str3, String str4, BigDecimal bigDecimal, Long l, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_perfEvent(String str, String str2, String str3, String str4, String str5, Map<String, Object> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_pinpointAttribute(String str, String str2, String str3, Map<String, Object> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_setRevID(String str, String str2, boolean z) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_updatePSValue(String str, boolean z, String str2, String str3, String str4, String str5, String str6, String str7) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void logEvent(String str, String str2, String str3, String str4, Long l, Long l2, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public boolean perfSampleAction(String str, int i) {
+        return false;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void perfSampleEnd(String str, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void perfSampleStart(String str, int i, Map<String, ?> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setCustomProperties(Map<String, Object> map) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setEATargetedMarketing(boolean z) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void setUserIdentifier(String str) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void shortcircuitEATargetedMarketingOff() {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void userAgedUp() {
+    }
+
+    public SharedPreferencesAnalytics(Context context, SharedPreferences sharedPreferences) {
+        this.mPreferences = sharedPreferences;
+        this.mVersionCode = Common.packageVersionCode(context);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void init(IAnalyticsCallback iAnalyticsCallback) {
+        trackInstall();
+        incrementRunCounts(this.mVersionCode);
+        onResume();
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void onResume() {
+        this.mStartTime = timestamp();
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void onPause() {
+        incrementSessionDuration(Math.max(0L, timestamp() - this.mStartTime));
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public PerfMeasure perfGetValues() {
+        return new PerfMeasure();
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalytics
+    public void internal_trackRevenueInUsd(double d, String str, String str2, String str3, Map<String, ?> map) {
+        long usdToCents = Conversion.usdToCents(d);
+        this.mPreferences.edit().putLong(PROP_LIFETIME_VALUE_CENTS, this.mPreferences.getLong(PROP_LIFETIME_VALUE_CENTS, 0L) + usdToCents).apply();
+    }
+
+    private static long timestamp() {
+        return System.currentTimeMillis() / 1000;
+    }
+
+    private void trackInstall() {
+        if (this.mPreferences.getLong(PROP_INSTALL_TIMESTAMP, 0L) == 0) {
+            long timestamp = timestamp();
+            this.mLog.i("LIFECYCLE.INSTALL.TIMESTAMP", Consts.KEY_TAPJOY_USER_ID_VERSION, Long.valueOf(timestamp));
+            this.mPreferences.edit().putLong(PROP_INSTALL_TIMESTAMP, timestamp).apply();
+        }
+    }
+
+    private void incrementSessionDuration(long j) {
+        this.mPreferences.edit().putLong(PROP_TOTAL_SESSION_DURATION, this.mPreferences.getLong(PROP_TOTAL_SESSION_DURATION, 0L) + j).apply();
+    }
+
+    private void incrementRunCounts(long j) {
+        int i = this.mPreferences.getInt(PROP_RUN_COUNT, 0);
+        int i2 = this.mPreferences.getInt(PROP_RUN_COUNT_VERSION_X + j, 0);
+        this.mPreferences.edit().putInt(PROP_RUN_COUNT, i + 1).putInt(PROP_RUN_COUNT_VERSION_X + j, i2 + 1).apply();
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/eventbus/ConfigGetterEventHandler.java

@@ -0,0 +1,80 @@
+package com.glu.plugins.gluanalytics.eventbus;
+
+import android.text.TextUtils;
+import com.facebook.share.internal.ShareConstants;
+import com.glu.plugins.gluanalytics.eventbus.GluEventBus;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.glu.plugins.gluanalytics.util.ConfigUtil;
+import com.glu.plugins.gluanalytics.util.IAction2;
+import com.mbridge.msdk.MBridgeConstans;
+import java.util.Collections;
+
+/* loaded from: classes2.dex */
+public class ConfigGetterEventHandler implements GluEventBus.IEventHandler {
+    private static final String CHANNEL_SDK = "#csdk.gluAnalytics";
+    private static final String ID_HANDLER = "@csdk.gluAnalytics.configGetter";
+    private final String mDefaultConfig;
+    private final GluEventBus mEventBus;
+    private final IAction2<String, String> mInitFn;
+    private Object mToken;
+    private boolean mut_initialized;
+
+    private ConfigGetterEventHandler(GluEventBus gluEventBus, IAction2<String, String> iAction2, String str) {
+        this.mEventBus = gluEventBus;
+        this.mInitFn = iAction2;
+        this.mDefaultConfig = str;
+    }
+
+    public static ConfigGetterEventHandler subscribe(GluEventBus gluEventBus, Object obj, IAction2<String, String> iAction2, String str) {
+        ConfigGetterEventHandler configGetterEventHandler = new ConfigGetterEventHandler(gluEventBus, iAction2, str);
+        configGetterEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Collections.singletonList(CHANNEL_SDK), configGetterEventHandler);
+        return configGetterEventHandler;
+    }
+
+    public void requestConfig(long j) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#csdk.gluAnalytics.evt", "configRequested", null, Collections.singletonMap("jsonConfig", this.mDefaultConfig)));
+        if (j > 0) {
+            Common.runOnUIThreadDelayed(new Runnable() { // from class: com.glu.plugins.gluanalytics.eventbus.ConfigGetterEventHandler.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    ConfigGetterEventHandler configGetterEventHandler = ConfigGetterEventHandler.this;
+                    configGetterEventHandler.initOnce(configGetterEventHandler.mDefaultConfig, "app-timeout");
+                    ConfigGetterEventHandler.this.onDestroy();
+                }
+            }, j);
+        }
+    }
+
+    public void onDestroy() {
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus.IEventHandler
+    public void handleEvent(GluEventBus gluEventBus, Object obj, String str, GluEventBus.Event event) throws Exception {
+        String str2;
+        if (TextUtils.equals(event.channel, CHANNEL_SDK) && TextUtils.equals(event.action, "reconfigure")) {
+            String string = ConfigUtil.getString(event.data, "jsonConfig");
+            if (TextUtils.isEmpty(string)) {
+                string = this.mDefaultConfig;
+                str2 = MBridgeConstans.DYNAMIC_VIEW_WX_APP;
+            } else {
+                str2 = ConfigUtil.getString(event.data, ShareConstants.FEED_SOURCE_PARAM);
+            }
+            initOnce(string, str2);
+            gluEventBus.unsubscribe(obj);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void initOnce(String str, String str2) {
+        boolean z;
+        synchronized (this) {
+            z = this.mut_initialized;
+            this.mut_initialized = true;
+        }
+        if (z) {
+            return;
+        }
+        this.mInitFn.apply(str, str2);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/eventbus/GluAnalyticsEventHandler.java

@@ -0,0 +1,165 @@
+package com.glu.plugins.gluanalytics.eventbus;
+
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.facebook.share.internal.ShareConstants;
+import com.glu.plugins.gluanalytics.Analytics;
+import com.glu.plugins.gluanalytics.BuildConfig;
+import com.glu.plugins.gluanalytics.IAnalyticsCallback;
+import com.glu.plugins.gluanalytics.eventbus.GluEventBus;
+import com.glu.plugins.gluanalytics.kvstore.StringStore;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.ConfigUtil;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class GluAnalyticsEventHandler implements GluEventBus.IEventHandler, IAnalyticsCallback {
+    private static final String CHANNEL_GLOBAL_SDK = "#sdk";
+    private static final String CHANNEL_LIFECYCLE = "#eb.lifecycle";
+    private static final String CHANNEL_SDK = "#csdk.gluAnalytics";
+    private static final String CHANNEL_SDK_EVT = "#csdk.gluAnalytics.evt";
+    private static final String ID_HANDLER = "@csdk.gluAnalytics";
+    private final Analytics mAnalytics;
+    private final GluEventBus mEventBus;
+    private String mPreviousSessionID = "";
+    private String mRevSDKVersion;
+    private Object mToken;
+
+    public GluAnalyticsEventHandler(GluEventBus gluEventBus, Analytics analytics, String str) {
+        this.mEventBus = gluEventBus;
+        this.mAnalytics = analytics;
+        this.mRevSDKVersion = str;
+    }
+
+    public static GluAnalyticsEventHandler subscribe(GluEventBus gluEventBus, Object obj, Analytics analytics, String str) {
+        GluAnalyticsEventHandler gluAnalyticsEventHandler = new GluAnalyticsEventHandler(gluEventBus, analytics, str);
+        gluAnalyticsEventHandler.mToken = gluEventBus.subscribe(obj, ID_HANDLER, Arrays.asList(CHANNEL_SDK, CHANNEL_LIFECYCLE, CHANNEL_GLOBAL_SDK), gluAnalyticsEventHandler);
+        return gluAnalyticsEventHandler;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void onInit(String str, String str2, String str3, String str4, String str5, String str6) {
+        Map createMap = CollectionUtil.createMap();
+        createMap.put("name", "GluAnalytics");
+        createMap.put("version", BuildConfig.VERSION_NAME);
+        createMap.put("RevSDKVersion", this.mRevSDKVersion);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "initialized", null, createMap));
+        publishAnalyticsDeviceId(str, str2);
+        publishRevenueId(str3);
+        publishGAID(str4);
+        publishAndroidId(str5);
+        publishAppSetId(str6);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void onDestroy() {
+        Map createMap = CollectionUtil.createMap();
+        createMap.put("name", "GluAnalytics");
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event("#sdk.evt", "destroyed", null, createMap));
+        this.mEventBus.unsubscribe(this.mToken);
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void onUserIdChanged(String str, String str2) {
+        Map createMap = CollectionUtil.createMap();
+        createMap.put(SDKConstants.PARAM_USER_ID, str);
+        createMap.put("revID", str2);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "userIDChanged", null, createMap));
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void recordAnalyticsRequest(String str, String str2, String str3, String str4, String str5, String str6, String str7) {
+        Map createMap = CollectionUtil.createMap();
+        createMap.put("association", str);
+        createMap.put("fieldName", str2);
+        createMap.put("fieldType", str4);
+        createMap.put("fieldValue", str5);
+        createMap.put("mapKeyName", str3);
+        createMap.put("writeOperation", str6);
+        createMap.put("requestId", str7);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "recordAnalyticsRequest", null, createMap));
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Code restructure failed: missing block: B:172:0x01a8, code lost:
+    
+        if (r3.equals("setEATargetedMarketing") == false) goto L6;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:193:0x05b4, code lost:
+    
+        if (r1.equals("destroy") == false) goto L183;
+     */
+    @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus.IEventHandler
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void handleEvent(com.glu.plugins.gluanalytics.eventbus.GluEventBus r33, java.lang.Object r34, java.lang.String r35, com.glu.plugins.gluanalytics.eventbus.GluEventBus.Event r36) {
+        /*
+            Method dump skipped, instructions count: 1754
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.glu.plugins.gluanalytics.eventbus.GluAnalyticsEventHandler.handleEvent(com.glu.plugins.gluanalytics.eventbus.GluEventBus, java.lang.Object, java.lang.String, com.glu.plugins.gluanalytics.eventbus.GluEventBus$Event):void");
+    }
+
+    private void publishAnalyticsDeviceId(String str, String str2) {
+        Map createMap = CollectionUtil.createMap();
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, "id", str);
+        CollectionUtil.putIfNotEmpty((Map<String, ? super String>) createMap, ShareConstants.FEED_SOURCE_PARAM, str2);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "analyticsDeviceID", null, createMap));
+        StringStore.set(StringStore.Key.ANALYTICS_ID, str);
+    }
+
+    private void publishRevenueId(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "revenueID", null, Collections.singletonMap("id", str)));
+        StringStore.set(StringStore.Key.REV_ID, str);
+    }
+
+    private void publishGAID(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "advertisingID", null, Collections.singletonMap("id", str)));
+    }
+
+    private void publishAndroidId(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "androidID", null, Collections.singletonMap("id", str)));
+    }
+
+    private void publishAppSetId(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "appSetId", null, Collections.singletonMap("id", str)));
+    }
+
+    private void publishSessionId(String str) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, SDKConstants.PARAM_SESSION_ID, null, Collections.singletonMap("id", str)));
+        StringStore.set(StringStore.Key.SESSION_ID, str);
+        this.mPreviousSessionID = str;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void onUpdateSessionId() {
+        String sessionIdentifier = this.mAnalytics.getSessionIdentifier();
+        if (sessionIdentifier == null || sessionIdentifier.length() <= 0 || sessionIdentifier.equals(this.mPreviousSessionID)) {
+            return;
+        }
+        publishSessionId(this.mAnalytics.getSessionIdentifier());
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void internalTargetedAdsChanged(boolean z) {
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, z ? "internalTargetedAdsOn" : "internalTargetedAdsOff", null, CollectionUtil.createMap()));
+    }
+
+    @Override // com.glu.plugins.gluanalytics.IAnalyticsCallback
+    public void setPushToken(String str) {
+        publishPushToken(str);
+    }
+
+    private void setUserIdentifier(Map<String, Object> map) {
+        this.mAnalytics.setUserIdentifier(ConfigUtil.getString(map, "id"));
+    }
+
+    private void publishPushToken(String str) {
+        Map createMap = CollectionUtil.createMap();
+        createMap.put("pushToken", str);
+        this.mEventBus.publish(this.mToken, new GluEventBus.Event(CHANNEL_SDK_EVT, "publishPushToken", null, createMap));
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/eventbus/GluEventBus.java

@@ -0,0 +1,246 @@
+package com.glu.plugins.gluanalytics.eventbus;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import csdk.glucentralservices.eventbus.IServerEventBus;
+import csdk.glucentralservices.eventbus.IServerEventHandler;
+import csdk.glucentralservices.eventbus.ServerEventBus;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public abstract class GluEventBus {
+    public static final GluEventBus DISCONNECTED = new DisconnectedEventBus();
+    private static final String EVT_ACTION = "action";
+    private static final String EVT_CHANNEL = "channel";
+    private static final String EVT_DATA = "data";
+    private static final String EVT_SENDER = "sender";
+    public static final Object GLOBAL_TOKEN;
+    private static final Set<String> KEYS;
+    public static final GluEventBus SHARED;
+
+    public interface IEventHandler {
+        void handleEvent(GluEventBus gluEventBus, Object obj, String str, Event event) throws Exception;
+    }
+
+    public abstract Object globalToken();
+
+    public abstract boolean isConnected();
+
+    public abstract void publish(Object obj, Event event);
+
+    public abstract Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler);
+
+    public abstract void unsubscribe(Object obj);
+
+    static {
+        GluEventBus createEventBus = createEventBus();
+        SHARED = createEventBus;
+        GLOBAL_TOKEN = createEventBus.globalToken();
+        KEYS = createKeys();
+    }
+
+    private static GluEventBus createEventBus() {
+        try {
+            return new RealEventBus(ServerEventBus.getShared());
+        } catch (NoClassDefFoundError unused) {
+            return DISCONNECTED;
+        }
+    }
+
+    private static Set<String> createKeys() {
+        HashSet hashSet = new HashSet();
+        hashSet.add("channel");
+        hashSet.add("action");
+        hashSet.add(EVT_SENDER);
+        hashSet.add("data");
+        return hashSet;
+    }
+
+    public static class Event implements Map<String, Object> {
+        public String action;
+        public String channel;
+        public Map<String, Object> data;
+        public String sender;
+
+        public Event() {
+        }
+
+        public Event(String str, String str2, String str3, Map<String, Object> map) {
+            this.channel = str;
+            this.action = str2;
+            this.sender = str3;
+            this.data = map;
+        }
+
+        @Override // java.util.Map
+        public int size() {
+            return keySet().size();
+        }
+
+        @Override // java.util.Map
+        public boolean isEmpty() {
+            return size() == 0;
+        }
+
+        @Override // java.util.Map
+        public boolean containsKey(Object obj) {
+            return GluEventBus.KEYS.contains(obj);
+        }
+
+        @Override // java.util.Map
+        public boolean containsValue(Object obj) {
+            return values().contains(obj);
+        }
+
+        @Override // java.util.Map
+        public Object get(Object obj) {
+            if (obj == null) {
+                return null;
+            }
+            if (obj.equals("channel")) {
+                return this.channel;
+            }
+            if (obj.equals("action")) {
+                return this.action;
+            }
+            if (obj.equals(GluEventBus.EVT_SENDER)) {
+                return this.sender;
+            }
+            if (obj.equals("data")) {
+                return this.data;
+            }
+            return null;
+        }
+
+        @Override // java.util.Map
+        public Object put(String str, Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public Object remove(Object obj) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void putAll(@NonNull Map<? extends String, ? extends Object> map) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<String> keySet() {
+            return GluEventBus.KEYS;
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Collection<Object> values() {
+            return Arrays.asList(this.channel, this.action, this.sender, this.data);
+        }
+
+        @Override // java.util.Map
+        @NonNull
+        public Set<Map.Entry<String, Object>> entrySet() {
+            HashSet hashSet = new HashSet();
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("channel", this.channel));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("action", this.action));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry(GluEventBus.EVT_SENDER, this.sender));
+            hashSet.add(new AbstractMap.SimpleImmutableEntry("data", this.data));
+            return hashSet;
+        }
+    }
+
+    public static class DisconnectedEventBus extends GluEventBus {
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public Object globalToken() {
+            return this;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public boolean isConnected() {
+            return false;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+        }
+
+        private DisconnectedEventBus() {
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, IEventHandler iEventHandler) {
+            if (iEventHandler != null) {
+                try {
+                    iEventHandler.handleEvent(this, obj, str, new Event("#me", "unsubscribed", "@eb.disconnected", null));
+                } catch (Exception e) {
+                    Log.e("DisconnectedEventBus", "Failed to destroy handler", e);
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class RealEventBus extends GluEventBus {
+        private final IServerEventBus mEventBus;
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public boolean isConnected() {
+            return true;
+        }
+
+        public RealEventBus(IServerEventBus iServerEventBus) {
+            this.mEventBus = iServerEventBus;
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public Object subscribe(Object obj, String str, Collection<String> collection, final IEventHandler iEventHandler) {
+            return this.mEventBus.subscribe(obj, str, collection, iEventHandler != null ? new IServerEventHandler() { // from class: com.glu.plugins.gluanalytics.eventbus.GluEventBus.RealEventBus.1
+                @Override // csdk.glucentralservices.eventbus.IServerEventHandler
+                public void handleEvent(IServerEventBus iServerEventBus, Object obj2, String str2, Map<String, Object> map) throws Exception {
+                    Event event;
+                    if (map != null) {
+                        event = new Event();
+                        event.channel = (String) map.get("channel");
+                        event.action = (String) map.get("action");
+                        event.sender = (String) map.get(GluEventBus.EVT_SENDER);
+                        event.data = (Map) map.get("data");
+                    } else {
+                        event = null;
+                    }
+                    iEventHandler.handleEvent(RealEventBus.this, obj2, str2, event);
+                }
+            } : null);
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public void unsubscribe(Object obj) {
+            this.mEventBus.unsubscribe(obj);
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public void publish(Object obj, Event event) {
+            this.mEventBus.publish(obj, event);
+        }
+
+        @Override // com.glu.plugins.gluanalytics.eventbus.GluEventBus
+        public Object globalToken() {
+            return this.mEventBus.globalToken();
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/kvstore/StringStore.java

@@ -0,0 +1,88 @@
+package com.glu.plugins.gluanalytics.kvstore;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class StringStore {
+    private static final String gcsClassName = "csdk.glucentralservices.kvstore.StringStore";
+    private static final String getMethodName = "get";
+    private static final Map<Key, String> keys = new HashMap<Key, String>() { // from class: com.glu.plugins.gluanalytics.kvstore.StringStore.1
+        {
+            put(Key.ANALYTICS_ID, "AnalyticsID");
+            put(Key.ANALYTICS_APP_NAME, "AnalyticsAppName");
+            put(Key.ANALYTICS_ENV, "AnalyticsEnvironment");
+            put(Key.REV_ID, "RevID");
+            put(Key.SESSION_ID, "SessionID");
+            put(Key.LOCATION_IP_ADDRESS, "LocationIPAddress");
+            put(Key.LOCATION_ISO_CODE, "LocationISOCode");
+        }
+    };
+    private static final String setMethodName = "set";
+
+    public enum Key {
+        ANALYTICS_ID,
+        ANALYTICS_APP_NAME,
+        ANALYTICS_ENV,
+        REV_ID,
+        SESSION_ID,
+        LOCATION_IP_ADDRESS,
+        LOCATION_ISO_CODE
+    }
+
+    private static void log(String str) {
+    }
+
+    public static void init() {
+        set("*init", "gluanalytics");
+    }
+
+    public static void destroy() {
+        set("*destroy", "gluanalytics");
+    }
+
+    private static String get(String str) {
+        try {
+            return (String) csdk.glucentralservices.kvstore.StringStore.class.getMethod(getMethodName, String.class).invoke(null, str);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+            return null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private static void set(String str, String str2) {
+        try {
+            csdk.glucentralservices.kvstore.StringStore.class.getMethod(setMethodName, String.class, String.class).invoke(null, str, str2);
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            log("Can't find GCS");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static String get(Key key) {
+        Map<Key, String> map = keys;
+        if (!map.containsKey(key)) {
+            log("Invalid Key: " + key);
+            return null;
+        }
+        return get(map.get(key));
+    }
+
+    public static String getOrDefault(Key key, String str) {
+        String str2 = get(key);
+        return (str2 == null || str2.isEmpty()) ? str : str2;
+    }
+
+    public static void set(Key key, String str) {
+        Map<Key, String> map = keys;
+        if (!map.containsKey(key)) {
+            log("Invalid Key: " + key);
+            return;
+        }
+        set(map.get(key), str);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/network/GluTLS12SocketFactory.java

@@ -0,0 +1,108 @@
+package com.glu.plugins.gluanalytics.network;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+/* loaded from: classes2.dex */
+public class GluTLS12SocketFactory extends SSLSocketFactory {
+    private final SSLSocketFactory delegate;
+    private static final Object contextLock = new Object();
+    private static final String[] SUPPORTED_PROTOCOLS = {"TLSv1.2"};
+    private static SSLContext sslContext = null;
+
+    @Nullable
+    public static GluTLS12SocketFactory createGluTLS12SocketFactory(@Nullable SSLContext sSLContext) {
+        return null;
+    }
+
+    public static void fixTLSPre21(@NonNull HttpsURLConnection httpsURLConnection, @Nullable GluTLS12SocketFactory gluTLS12SocketFactory) {
+    }
+
+    @Nullable
+    public static GluTLS12SocketFactory createGluTLS12SocketFactory() {
+        return createGluTLS12SocketFactory(null);
+    }
+
+    public static void fixTLSPre21(@NonNull HttpsURLConnection httpsURLConnection) {
+        fixTLSPre21(httpsURLConnection, createGluTLS12SocketFactory());
+    }
+
+    private GluTLS12SocketFactory(@Nullable SSLContext sSLContext) throws KeyManagementException, NoSuchAlgorithmException {
+        if (sSLContext != null) {
+            this.delegate = sSLContext.getSocketFactory();
+            return;
+        }
+        synchronized (contextLock) {
+            try {
+                if (sslContext == null) {
+                    SSLContext sSLContext2 = SSLContext.getInstance("TLS");
+                    sslContext = sSLContext2;
+                    sSLContext2.init(null, null, null);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        this.delegate = sslContext.getSocketFactory();
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public String[] getDefaultCipherSuites() {
+        return this.delegate.getDefaultCipherSuites();
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public String[] getSupportedCipherSuites() {
+        return this.delegate.getSupportedCipherSuites();
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket() throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket());
+    }
+
+    @Override // javax.net.ssl.SSLSocketFactory
+    public Socket createSocket(Socket socket, String str, int i, boolean z) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(socket, str, i, z));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(String str, int i) throws IOException, UnknownHostException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(str, i));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(String str, int i, InetAddress inetAddress, int i2) throws IOException, UnknownHostException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(str, i, inetAddress, i2));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(InetAddress inetAddress, int i) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(inetAddress, i));
+    }
+
+    @Override // javax.net.SocketFactory
+    public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress2, int i2) throws IOException {
+        return updateTLSProtocols((SSLSocket) this.delegate.createSocket(inetAddress, i, inetAddress2, i2));
+    }
+
+    private Socket updateTLSProtocols(Socket socket) {
+        if (socket instanceof SSLSocket) {
+            try {
+                ((SSLSocket) socket).setEnabledProtocols(SUPPORTED_PROTOCOLS);
+            } catch (Exception unused) {
+            }
+        }
+        return socket;
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/network/NetworkReachability.java

@@ -0,0 +1,97 @@
+package com.glu.plugins.gluanalytics.network;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import androidx.annotation.RequiresApi;
+import androidx.core.content.ContextCompat;
+
+/* loaded from: classes2.dex */
+public class NetworkReachability {
+    private static final String NetworkType_2G = "2G";
+    private static final String NetworkType_3G = "3G";
+    private static final String NetworkType_4G = "4G";
+    private static final String NetworkType_Ethernet = "Ethernet";
+    private static final String NetworkType_Mobile = "Mobile";
+    private static final String NetworkType_Unknown = "Unknown";
+    private static final String NetworkType_Wifi = "Wifi";
+    private final ConnectivityManager mConnectivityManager;
+    private final Context mContext;
+
+    public NetworkReachability(Context context) {
+        this.mContext = context;
+        this.mConnectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
+    }
+
+    private static boolean isPermissionGranted(Context context, String str) {
+        try {
+            return ContextCompat.checkSelfPermission(context, str) == 0;
+        } catch (Exception unused) {
+            return false;
+        }
+    }
+
+    public String getNetworkType() {
+        if (!isPermissionGranted(this.mContext, "android.permission.ACCESS_NETWORK_STATE")) {
+            return "Unknown";
+        }
+        ConnectivityManager connectivityManager = this.mConnectivityManager;
+        NetworkInfo activeNetworkInfo = connectivityManager != null ? connectivityManager.getActiveNetworkInfo() : null;
+        return (activeNetworkInfo == null || !activeNetworkInfo.isConnected()) ? "Unknown" : getNetworkTypeApi21();
+    }
+
+    @RequiresApi(api = 21)
+    private String getNetworkTypeApi21() {
+        for (Network network : this.mConnectivityManager.getAllNetworks()) {
+            NetworkCapabilities networkCapabilities = this.mConnectivityManager.getNetworkCapabilities(network);
+            if (networkCapabilities != null) {
+                if (networkCapabilities.hasTransport(3)) {
+                    return NetworkType_Ethernet;
+                }
+                if (networkCapabilities.hasTransport(1)) {
+                    return NetworkType_Wifi;
+                }
+                if (networkCapabilities.hasTransport(0)) {
+                    return NetworkType_Mobile;
+                }
+            }
+        }
+        return "Unknown";
+    }
+
+    private String getNetworkType(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == 9) {
+            return NetworkType_Ethernet;
+        }
+        if (networkInfo.getType() == 1) {
+            return NetworkType_Wifi;
+        }
+        if (networkInfo.getType() != 0) {
+            return "Unknown";
+        }
+        switch (networkInfo.getSubtype()) {
+            case 1:
+            case 2:
+            case 4:
+            case 7:
+            case 11:
+                return NetworkType_2G;
+            case 3:
+            case 5:
+            case 6:
+            case 8:
+            case 9:
+            case 10:
+            case 12:
+            case 14:
+                return NetworkType_3G;
+            case 13:
+            case 15:
+                return NetworkType_4G;
+            default:
+                return NetworkType_Mobile;
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/network/NetworkResponse.java

@@ -0,0 +1,16 @@
+package com.glu.plugins.gluanalytics.network;
+
+/* loaded from: classes2.dex */
+public class NetworkResponse {
+    public final byte[] body;
+    public final int code;
+    public final String nonce;
+    public final Throwable throwable;
+
+    public NetworkResponse(int i, byte[] bArr, String str, Exception exc) {
+        this.code = i;
+        this.body = bArr;
+        this.nonce = str;
+        this.throwable = exc;
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/network/NetworkUtils.java

@@ -0,0 +1,192 @@
+package com.glu.plugins.gluanalytics.network;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+
+/* loaded from: classes2.dex */
+public class NetworkUtils {
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:62:0x00c9  */
+    /* JADX WARN: Type inference failed for: r3v0 */
+    /* JADX WARN: Type inference failed for: r3v1, types: [java.net.HttpURLConnection] */
+    /* JADX WARN: Type inference failed for: r3v2 */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static com.glu.plugins.gluanalytics.network.NetworkResponse sendRequest(java.lang.String r5, java.net.URL r6, java.util.Map<java.lang.String, java.lang.String> r7, java.lang.String r8, int r9) {
+        /*
+            java.lang.String r0 = "POST"
+            boolean r0 = android.text.TextUtils.equals(r5, r0)
+            r1 = 1
+            r2 = 0
+            if (r0 != 0) goto L15
+            java.lang.String r0 = "PUT"
+            boolean r0 = android.text.TextUtils.equals(r5, r0)
+            if (r0 == 0) goto L13
+            goto L15
+        L13:
+            r0 = r2
+            goto L16
+        L15:
+            r0 = r1
+        L16:
+            r3 = 0
+            java.net.URLConnection r6 = r6.openConnection()     // Catch: java.lang.Throwable -> Lb7 java.io.IOException -> Lb9
+            java.lang.Object r6 = com.google.firebase.perf.network.FirebasePerfUrlConnection.instrument(r6)     // Catch: java.lang.Throwable -> Lb7 java.io.IOException -> Lb9
+            java.net.URLConnection r6 = (java.net.URLConnection) r6     // Catch: java.lang.Throwable -> Lb7 java.io.IOException -> Lb9
+            javax.net.ssl.HttpsURLConnection r6 = (javax.net.ssl.HttpsURLConnection) r6     // Catch: java.lang.Throwable -> Lb7 java.io.IOException -> Lb9
+            com.glu.plugins.gluanalytics.network.GluTLS12SocketFactory.fixTLSPre21(r6)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r6.setRequestMethod(r5)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            if (r7 == 0) goto L55
+            java.util.Set r5 = r7.entrySet()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.util.Iterator r5 = r5.iterator()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        L33:
+            boolean r7 = r5.hasNext()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            if (r7 == 0) goto L55
+            java.lang.Object r7 = r5.next()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.util.Map$Entry r7 = (java.util.Map.Entry) r7     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.Object r4 = r7.getKey()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.String r4 = (java.lang.String) r4     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.Object r7 = r7.getValue()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.String r7 = (java.lang.String) r7     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r6.setRequestProperty(r4, r7)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            goto L33
+        L4f:
+            r5 = move-exception
+            r3 = r6
+            goto Lc7
+        L53:
+            r5 = move-exception
+            goto Lbb
+        L55:
+            r6.setAllowUserInteraction(r2)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            if (r9 <= 0) goto L60
+            r6.setConnectTimeout(r9)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r6.setReadTimeout(r9)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        L60:
+            r6.setUseCaches(r2)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            if (r0 == 0) goto L81
+            r6.setDoOutput(r1)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r6.connect()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.io.OutputStream r5 = r6.getOutputStream()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.String r7 = "UTF-8"
+            byte[] r7 = r8.getBytes(r7)     // Catch: java.lang.Throwable -> L7c
+            r5.write(r7)     // Catch: java.lang.Throwable -> L7c
+            r5.close()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            goto L84
+        L7c:
+            r7 = move-exception
+            r5.close()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            throw r7     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        L81:
+            r6.connect()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        L84:
+            int r5 = r6.getResponseCode()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r7 = 400(0x190, float:5.6E-43)
+            if (r5 < r7) goto L94
+            java.io.InputStream r7 = r6.getErrorStream()     // Catch: java.lang.Throwable -> L91
+            goto L98
+        L91:
+            r5 = move-exception
+            r7 = r3
+            goto Lb1
+        L94:
+            java.io.InputStream r7 = r6.getInputStream()     // Catch: java.lang.Throwable -> L91
+        L98:
+            byte[] r8 = readAsByteArrayAndClose(r7)     // Catch: java.lang.Throwable -> Lb0
+            if (r7 == 0) goto La1
+            r7.close()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        La1:
+            com.glu.plugins.gluanalytics.network.NetworkResponse r7 = new com.glu.plugins.gluanalytics.network.NetworkResponse     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            java.lang.String r9 = "nonce"
+            java.lang.String r9 = r6.getHeaderField(r9)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r7.<init>(r5, r8, r9, r3)     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+            r6.disconnect()
+            return r7
+        Lb0:
+            r5 = move-exception
+        Lb1:
+            if (r7 == 0) goto Lb6
+            r7.close()     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        Lb6:
+            throw r5     // Catch: java.lang.Throwable -> L4f java.io.IOException -> L53
+        Lb7:
+            r5 = move-exception
+            goto Lc7
+        Lb9:
+            r5 = move-exception
+            r6 = r3
+        Lbb:
+            com.glu.plugins.gluanalytics.network.NetworkResponse r7 = new com.glu.plugins.gluanalytics.network.NetworkResponse     // Catch: java.lang.Throwable -> L4f
+            r8 = -1
+            r7.<init>(r8, r3, r3, r5)     // Catch: java.lang.Throwable -> L4f
+            if (r6 == 0) goto Lc6
+            r6.disconnect()
+        Lc6:
+            return r7
+        Lc7:
+            if (r3 == 0) goto Lcc
+            r3.disconnect()
+        Lcc:
+            throw r5
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.glu.plugins.gluanalytics.network.NetworkUtils.sendRequest(java.lang.String, java.net.URL, java.util.Map, java.lang.String, int):com.glu.plugins.gluanalytics.network.NetworkResponse");
+    }
+
+    private static String readAsStringAndClose(InputStream inputStream) throws IOException {
+        BufferedReader bufferedReader;
+        Throwable th;
+        try {
+            StringBuilder sb = new StringBuilder();
+            char[] cArr = new char[1024];
+            bufferedReader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
+            while (true) {
+                try {
+                    int read = bufferedReader.read(cArr);
+                    if (read >= 0) {
+                        sb.append(cArr, 0, read);
+                    } else {
+                        String sb2 = sb.toString();
+                        bufferedReader.close();
+                        inputStream.close();
+                        return sb2;
+                    }
+                } catch (Throwable th2) {
+                    th = th2;
+                    if (bufferedReader != null) {
+                        bufferedReader.close();
+                    }
+                    inputStream.close();
+                    throw th;
+                }
+            }
+        } catch (Throwable th3) {
+            bufferedReader = null;
+            th = th3;
+        }
+    }
+
+    private static byte[] readAsByteArrayAndClose(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        try {
+            byte[] bArr = new byte[1024];
+            while (true) {
+                int read = inputStream.read(bArr);
+                if (read >= 0) {
+                    byteArrayOutputStream.write(bArr, 0, read);
+                } else {
+                    return byteArrayOutputStream.toByteArray();
+                }
+            }
+        } finally {
+            byteArrayOutputStream.toByteArray();
+            byteArrayOutputStream.close();
+            inputStream.close();
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/unity/UnityAnalyticsFactory.java

@@ -0,0 +1,29 @@
+package com.glu.plugins.gluanalytics.unity;
+
+import android.text.TextUtils;
+import com.glu.plugins.gluanalytics.Analytics;
+import com.glu.plugins.gluanalytics.AnalyticsFactory;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.Common;
+import com.unity3d.player.UnityPlayer;
+import java.util.Map;
+import org.json.JSONException;
+
+/* loaded from: classes2.dex */
+public class UnityAnalyticsFactory {
+    private final AnalyticsFactory factory = new AnalyticsFactory(UnityPlayer.currentActivity.getApplicationContext());
+
+    public Analytics createAnalytics(String str, String str2) {
+        Map<String, Object> parseJsonObject;
+        if (TextUtils.isEmpty(str2)) {
+            parseJsonObject = null;
+        } else {
+            try {
+                parseJsonObject = CollectionUtil.parseJsonObject(str2);
+            } catch (JSONException e) {
+                throw Common.propagate(e);
+            }
+        }
+        return this.factory.createAnalytics(str, parseJsonObject);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/unity/UnityAnalyticsUtil.java

@@ -0,0 +1,89 @@
+package com.glu.plugins.gluanalytics.unity;
+
+import android.text.TextUtils;
+import com.glu.plugins.gluanalytics.Analytics;
+import com.glu.plugins.gluanalytics.CustomProperties;
+import com.glu.plugins.gluanalytics.GluAnalytics;
+import com.glu.plugins.gluanalytics.PerfMeasure;
+import com.glu.plugins.gluanalytics.util.CollectionUtil;
+import com.glu.plugins.gluanalytics.util.Common;
+import java.util.Map;
+import org.json.JSONException;
+
+/* loaded from: classes2.dex */
+public class UnityAnalyticsUtil {
+    public static void logEvent(Analytics analytics, String str, String str2, String str3, String str4, String str5, String str6, String str7) {
+        analytics.logEvent(str, str2, str3, str4, !TextUtils.isEmpty(str5) ? Long.valueOf(Long.parseLong(str5)) : null, TextUtils.isEmpty(str6) ? null : Long.valueOf(Long.parseLong(str6)), toMap(str7));
+    }
+
+    public static void logInAppPurchaseInUsd(Analytics analytics, double d, String str, String str2, String str3, String str4, long j, long j2, long j3, String str5) {
+        analytics.logInAppPurchaseInUsd(d, str, str2, str3, str4, j, j2, j3, toMap(str5));
+    }
+
+    public static void logTutorialStepCompleted(Analytics analytics, String str, long j, String str2, long j2, String str3) {
+        analytics.logTutorialStepCompleted(str, j, str2, j2, toMap(str3));
+    }
+
+    public static void logMissionStarted(Analytics analytics, String str, String str2, String str3, long j, long j2, long j3, String str4) {
+        analytics.logMissionStarted(str, str2, str3, j, j2, j3, toMap(str4));
+    }
+
+    public static void logMissionFailed(Analytics analytics, String str, String str2, String str3, String str4, long j, long j2, long j3, String str5) {
+        analytics.logMissionFailed(str, str2, str3, str4, j, j2, j3, toMap(str5));
+    }
+
+    public static void logMissionCompleted(Analytics analytics, String str, String str2, String str3, long j, long j2, long j3, String str4) {
+        analytics.logMissionCompleted(str, str2, str3, j, j2, j3, toMap(str4));
+    }
+
+    public static void logCurrencySink(Analytics analytics, long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, String str7) {
+        analytics.logCurrencySink(j, str, str2, str3, str4, str5, str6, j2, j3, j4, toMap(str7));
+    }
+
+    public static void logCurrencySource(Analytics analytics, long j, String str, String str2, String str3, String str4, String str5, String str6, long j2, long j3, long j4, String str7) {
+        analytics.logCurrencySource(j, str, str2, str3, str4, str5, str6, j2, j3, j4, toMap(str7));
+    }
+
+    public static void logAdvertisementOpportunity(Analytics analytics, String str, String str2, long j, boolean z, String str3) {
+        analytics.logAdvertisementOpportunity(str, str2, j, z, toMap(str3));
+    }
+
+    public static void perfSampleStart(Analytics analytics, String str, int i, String str2) {
+        analytics.perfSampleStart(str, i, toMap(str2));
+    }
+
+    public static void perfSampleEnd(Analytics analytics, String str, String str2) {
+        analytics.perfSampleEnd(str, toMap(str2));
+    }
+
+    public static PerfMeasure perfGetValues(Analytics analytics) {
+        return analytics.perfGetValues();
+    }
+
+    public static boolean perfSampleAction(Analytics analytics, String str, int i) {
+        return analytics.perfSampleAction(str, i);
+    }
+
+    public static void setCustomProperties(Analytics analytics, String str) {
+        analytics.setCustomProperties(toMap(str));
+    }
+
+    public static CustomProperties getCustomProperties(Analytics analytics) {
+        Map<String, Object> customProperties = analytics.getCustomProperties();
+        CustomProperties customProperties2 = new CustomProperties();
+        customProperties2.usageSharing = ((Boolean) customProperties.get(GluAnalytics.KEY_USAGE_SHARING)).booleanValue();
+        customProperties2.internalTargetedAds = ((Boolean) customProperties.get(GluAnalytics.KEY_INTERNAL_TARGETED_ADS)).booleanValue();
+        return customProperties2;
+    }
+
+    private static Map<String, Object> toMap(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return CollectionUtil.parseJsonObject(str);
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/CollectionUtil.java

@@ -0,0 +1,339 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import com.applovin.impl.f;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class CollectionUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static void putIfNotEmpty(JSONStringer jSONStringer, String str, String str2) throws JSONException {
+        if (TextUtils.isEmpty(str2)) {
+            return;
+        }
+        jSONStringer.key(str).value(str2);
+    }
+
+    public static void putIfNotNull(JSONStringer jSONStringer, String str, Object obj) throws JSONException {
+        if (obj != null) {
+            jSONStringer.key(str);
+            addValue(jSONStringer, obj);
+        }
+    }
+
+    public static void putIf(Map<String, Object> map, boolean z, String str, Object obj) {
+        if (z) {
+            map.put(str, obj);
+        }
+    }
+
+    public static void putIfNotEmpty(Map<String, ? super String> map, String str, String str2) {
+        if (TextUtils.isEmpty(str2)) {
+            return;
+        }
+        map.put(str, str2);
+    }
+
+    public static void putIfNotNull(Map<String, Object> map, String str, Object obj) {
+        if (obj != null) {
+            map.put(str, obj);
+        }
+    }
+
+    public static void putAll(Map<String, Object> map, Map<String, ?> map2) {
+        if (map2 != null) {
+            map.putAll(map2);
+        }
+    }
+
+    public static void putAll(JSONStringer jSONStringer, Map<String, ?> map) throws JSONException {
+        for (Map.Entry<String, ?> entry : map.entrySet()) {
+            jSONStringer.key(entry.getKey());
+            addValue(jSONStringer, entry.getValue());
+        }
+    }
+
+    public static void addAll(JSONStringer jSONStringer, Collection<?> collection) throws JSONException {
+        Iterator<?> it = collection.iterator();
+        while (it.hasNext()) {
+            addValue(jSONStringer, it.next());
+        }
+    }
+
+    public static void addValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj instanceof Map) {
+            jSONStringer.object();
+            putAll(jSONStringer, (Map<String, ?>) obj);
+            jSONStringer.endObject();
+        } else {
+            if (obj instanceof List) {
+                jSONStringer.array();
+                addAll(jSONStringer, (Collection) obj);
+                jSONStringer.endArray();
+                return;
+            }
+            jSONStringer.value(obj);
+        }
+    }
+
+    public static void writeSanitizedList(JSONStringer jSONStringer, List<?> list) throws JSONException {
+        jSONStringer.array();
+        for (Object obj : list) {
+            if (obj instanceof Map) {
+                writeSanitizedMap(jSONStringer, (Map) obj);
+            } else if (obj instanceof List) {
+                writeSanitizedList(jSONStringer, (List) obj);
+            } else {
+                writeSanitizedValue(jSONStringer, obj);
+            }
+        }
+        jSONStringer.endArray();
+    }
+
+    public static void writeSanitizedMap(JSONStringer jSONStringer, Map<String, ?> map) throws JSONException {
+        jSONStringer.object();
+        for (Map.Entry<String, ?> entry : map.entrySet()) {
+            Object value = entry.getValue();
+            if (value != null) {
+                if (value instanceof String) {
+                    String str = (String) value;
+                    if (str.length() > 0) {
+                        jSONStringer.key(entry.getKey()).value(str);
+                    }
+                } else if (value instanceof Map) {
+                    Map map2 = (Map) value;
+                    if (!isEmpty((Map<?, ?>) map2)) {
+                        jSONStringer.key(entry.getKey());
+                        writeSanitizedMap(jSONStringer, map2);
+                    }
+                } else if (value instanceof List) {
+                    List list = (List) value;
+                    if (!isEmpty((List<?>) list)) {
+                        jSONStringer.key(entry.getKey());
+                        writeSanitizedList(jSONStringer, list);
+                    }
+                } else {
+                    jSONStringer.key(entry.getKey());
+                    writeSanitizedValue(jSONStringer, value);
+                }
+            }
+        }
+        jSONStringer.endObject();
+    }
+
+    public static boolean isEmpty(List<?> list) {
+        return list.isEmpty();
+    }
+
+    public static boolean isEmpty(Map<?, ?> map) {
+        if (map.isEmpty()) {
+            return true;
+        }
+        for (Object obj : map.values()) {
+            if (obj != null) {
+                if (obj instanceof Map) {
+                    if (!isEmpty((Map<?, ?>) obj)) {
+                        return false;
+                    }
+                } else if (obj instanceof List) {
+                    if (!isEmpty((List<?>) obj)) {
+                        return false;
+                    }
+                } else if (!(obj instanceof String) || ((String) obj).length() > 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static Map<String, Object> toMap(Bundle bundle) {
+        return (Map) toSimpleJavaTypes(bundle);
+    }
+
+    public static Map<String, Object> toMap(JSONObject jSONObject) {
+        return (Map) toSimpleJavaTypes(jSONObject);
+    }
+
+    public static <K, V> Map<K, V> createMap() {
+        return new HashMap();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public static <K, V> Map<K, V> createMap(Object... objArr) {
+        f.b bVar = (Map<K, V>) createMap();
+        int length = objArr.length;
+        for (int i = 0; i < length; i += 2) {
+            bVar.put(objArr[i], objArr[i + 1]);
+        }
+        return bVar;
+    }
+
+    public static <K, V> Map<K, V> shallowClone(Map<K, V> map) {
+        Map<K, V> createMap = createMap();
+        if (map != null) {
+            createMap.putAll(map);
+        }
+        return createMap;
+    }
+
+    private static Object toSimpleJavaTypes(Object obj) {
+        if (obj == null || (obj instanceof String) || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return obj;
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return obj.toString();
+        }
+        if (obj instanceof Iterable) {
+            ArrayList arrayList = new ArrayList();
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                arrayList.add(toSimpleJavaTypes(it.next()));
+            }
+            return arrayList;
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            ArrayList arrayList2 = new ArrayList();
+            int length = Array.getLength(obj);
+            while (i < length) {
+                arrayList2.add(toSimpleJavaTypes(Array.get(obj, i)));
+                i++;
+            }
+            return arrayList2;
+        }
+        if (obj instanceof Bundle) {
+            Map createMap = createMap();
+            Bundle bundle = (Bundle) obj;
+            for (String str : bundle.keySet()) {
+                createMap.put(str, toSimpleJavaTypes(bundle.get(str)));
+            }
+            return createMap;
+        }
+        if (obj instanceof JSONArray) {
+            ArrayList arrayList3 = new ArrayList();
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                arrayList3.add(toSimpleJavaTypes(jSONArray.opt(i)));
+                i++;
+            }
+            return arrayList3;
+        }
+        if (obj instanceof JSONObject) {
+            Map createMap2 = createMap();
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                createMap2.put(next, toSimpleJavaTypes(jSONObject.opt(next)));
+            }
+            return createMap2;
+        }
+        if (obj == JSONObject.NULL) {
+            return null;
+        }
+        throw new IllegalArgumentException(String.format("Unsupported type %s", obj.getClass()));
+    }
+
+    private static void writeSanitizedValue(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj instanceof Boolean) {
+            jSONStringer.value(((Boolean) obj).booleanValue() ? 1L : 0L);
+        } else {
+            jSONStringer.value(obj);
+        }
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            try {
+                JsonReader jsonReader = new JsonReader(new StringReader(str));
+                jsonReader.setLenient(true);
+                return parseJsonObject(jsonReader);
+            } catch (IOException e) {
+                throw Common.propagate(e);
+            }
+        }
+
+        public static Object parseJsonValue(JsonReader jsonReader) throws JSONException, IOException {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return Boolean.valueOf(jsonReader.nextBoolean());
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return Double.valueOf(Double.parseDouble(nextString));
+                }
+                return Long.valueOf(Long.parseLong(nextString));
+            }
+            if (peek == JsonToken.STRING) {
+                return jsonReader.nextString();
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static Map<String, Object> parseJsonObject(JsonReader jsonReader) throws JSONException, IOException {
+            Map<String, Object> createMap = CollectionUtil.createMap();
+            jsonReader.beginObject();
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return createMap;
+                }
+                if (peek == JsonToken.NAME) {
+                    createMap.put(jsonReader.nextName(), parseJsonValue(jsonReader));
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static List<Object> parseJsonArray(JsonReader jsonReader) throws JSONException, IOException {
+            ArrayList arrayList = new ArrayList();
+            jsonReader.beginArray();
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                arrayList.add(parseJsonValue(jsonReader));
+            }
+            jsonReader.endArray();
+            return arrayList;
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return CollectionUtil.toMap(new JSONObject(str));
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/Common.java

@@ -0,0 +1,119 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import java.net.UnknownHostException;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public class Common {
+    private static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public static <T> T or(T t, T t2) {
+        return t != null ? t : t2;
+    }
+
+    public static void require(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void require(boolean z, String str) {
+        if (z) {
+            return;
+        }
+        if (str != null) {
+            throw new IllegalArgumentException(str);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static RuntimeException propagate(Throwable th) {
+        if (th instanceof Error) {
+            throw ((Error) th);
+        }
+        if (th instanceof RuntimeException) {
+            throw ((RuntimeException) th);
+        }
+        throw new RuntimeException(th);
+    }
+
+    public static UnknownHostException unknownHostCause(Throwable th) {
+        while (th != null) {
+            if (!(th instanceof UnknownHostException)) {
+                th = th.getCause();
+            } else {
+                return (UnknownHostException) th;
+            }
+        }
+        return null;
+    }
+
+    public static String emptyToNull(String str) {
+        if (str == null || str.length() > 0) {
+            return str;
+        }
+        return null;
+    }
+
+    public static String printBytes(byte[] bArr, int i, int i2) {
+        StringBuilder sb = new StringBuilder();
+        while (i < i2) {
+            sb.append(String.format("%02x", Byte.valueOf(bArr[i])));
+            i++;
+        }
+        return sb.toString();
+    }
+
+    public static Looper createLooper() {
+        return createLooper("looper");
+    }
+
+    public static Looper createLooper(String str) {
+        HandlerThread handlerThread = new HandlerThread(str);
+        handlerThread.start();
+        return handlerThread.getLooper();
+    }
+
+    public static <T> T call(Callable<T> callable) {
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw propagate(e);
+        }
+    }
+
+    public static long packageVersionCode(Context context) {
+        long longVersionCode;
+        try {
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            if (Build.VERSION.SDK_INT >= 28) {
+                longVersionCode = packageInfo.getLongVersionCode();
+                return longVersionCode;
+            }
+            return packageInfo.versionCode;
+        } catch (PackageManager.NameNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void runOnUIThread(Runnable runnable) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.post(runnable)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+
+    public static void runOnUIThreadDelayed(Runnable runnable, long j) {
+        require(runnable != null, "runnable == null");
+        if (!mainHandler.postDelayed(runnable, j)) {
+            throw new IllegalStateException("Failed to post runnable");
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/ConfigUtil.java

@@ -0,0 +1,183 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import csdk.gluads.Consts;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public class ConfigUtil {
+    public static Boolean getNullableBoolean(@Nullable Object obj, @NonNull String str, Boolean bool) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return bool;
+        }
+        if (object instanceof Boolean) {
+            return Boolean.valueOf(((Boolean) object).booleanValue());
+        }
+        if (object instanceof String) {
+            String str2 = (String) object;
+            if (TextUtils.equals(str2, "true")) {
+                return Boolean.TRUE;
+            }
+            if (TextUtils.equals(str2, "false")) {
+                return Boolean.FALSE;
+            }
+            throw new IllegalArgumentException("Can't convert string to boolean value: " + str2 + Consts.STRING_PERIOD);
+        }
+        throw new IllegalArgumentException("Unsupported type for boolean value: " + object.getClass());
+    }
+
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str) {
+        return getBoolean(obj, str, false);
+    }
+
+    public static boolean getBoolean(@Nullable Object obj, @NonNull String str, boolean z) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return z;
+        }
+        if (object instanceof Boolean) {
+            return ((Boolean) object).booleanValue();
+        }
+        if (object instanceof String) {
+            String str2 = (String) object;
+            if (TextUtils.equals(str2, "true")) {
+                return true;
+            }
+            if (TextUtils.equals(str2, "false")) {
+                return false;
+            }
+            throw new IllegalArgumentException("Can't convert string to boolean value: " + str2 + Consts.STRING_PERIOD);
+        }
+        throw new IllegalArgumentException("Unsupported type for boolean value: " + object.getClass());
+    }
+
+    public static Long getNullableLong(@Nullable Object obj, @NonNull String str, Long l) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return l;
+        }
+        if (object instanceof Number) {
+            return Long.valueOf(((Number) object).longValue());
+        }
+        if (object instanceof String) {
+            return Long.valueOf(Long.parseLong((String) object));
+        }
+        throw new IllegalArgumentException("Unsupported type for long value: " + object.getClass());
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str) {
+        return getLong(obj, str, 0L);
+    }
+
+    public static long getLong(@Nullable Object obj, @NonNull String str, long j) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return j;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).longValue();
+        }
+        if (object instanceof String) {
+            return Long.parseLong((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for long value: " + object.getClass());
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str) {
+        return getDouble(obj, str, 0.0d);
+    }
+
+    public static double getDouble(@Nullable Object obj, @NonNull String str, double d) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return d;
+        }
+        if (object instanceof Number) {
+            return ((Number) object).doubleValue();
+        }
+        if (object instanceof String) {
+            return Double.parseDouble((String) object);
+        }
+        throw new IllegalArgumentException("Unsupported type for double value: " + object.getClass());
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str) {
+        return getString(obj, str, null);
+    }
+
+    @Nullable
+    public static String getString(@Nullable Object obj, @NonNull String str, @Nullable String str2) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return str2;
+        }
+        if (object instanceof String) {
+            return (String) object;
+        }
+        if ((object instanceof Number) || (object instanceof Boolean)) {
+            return object.toString();
+        }
+        throw new IllegalArgumentException("Unsupported type for string value: " + object.getClass());
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str) {
+        return getMap(obj, str, null);
+    }
+
+    @Nullable
+    public static Map<String, Object> getMap(@Nullable Object obj, @NonNull String str, @Nullable Map<String, Object> map) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return map;
+        }
+        if (object instanceof Map) {
+            return (Map) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for map value: " + object.getClass());
+    }
+
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str) {
+        return getList(obj, str, null);
+    }
+
+    @Nullable
+    public static List<Object> getList(@Nullable Object obj, @NonNull String str, @Nullable List<Object> list) {
+        Object object = getObject(obj, str, null);
+        if (object == null) {
+            return list;
+        }
+        if (object instanceof List) {
+            return (List) object;
+        }
+        throw new IllegalArgumentException("Unsupported type for list value: " + object.getClass());
+    }
+
+    public static Object getObject(@Nullable Object obj, @NonNull String str) {
+        return getObject(obj, str, null);
+    }
+
+    @Nullable
+    public static Object getObject(@Nullable Object obj, @NonNull String str, @Nullable Object obj2) {
+        if (obj == null) {
+            return obj2;
+        }
+        for (String str2 : splitPath(str)) {
+            if (obj == null) {
+                return obj2;
+            }
+            obj = ((Map) obj).get(str2);
+        }
+        return obj;
+    }
+
+    @NonNull
+    private static String[] splitPath(@NonNull String str) {
+        return str.split("\\.");
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/Conversion.java

@@ -0,0 +1,20 @@
+package com.glu.plugins.gluanalytics.util;
+
+import java.math.BigDecimal;
+
+/* loaded from: classes2.dex */
+public class Conversion {
+    private static final BigDecimal HUNDRED_AS_DECIMAL = new BigDecimal(100);
+
+    public static double centsToUsd(long j) {
+        return j * 0.01d;
+    }
+
+    public static long usdToCents(double d) {
+        return (long) ((d * 100.0d) + 0.5d);
+    }
+
+    public static BigDecimal usdToCentsInDecimal(double d) {
+        return BigDecimal.valueOf(d).multiply(HUNDRED_AS_DECIMAL);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/Crypto.java

@@ -0,0 +1,18 @@
+package com.glu.plugins.gluanalytics.util;
+
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import javax.crypto.Mac;
+import javax.crypto.ShortBufferException;
+import javax.crypto.spec.SecretKeySpec;
+
+/* loaded from: classes2.dex */
+public class Crypto {
+    public static void hmacSHA256(byte[] bArr, int i, int i2, byte[] bArr2, byte[] bArr3, int i3) throws InvalidKeyException, NoSuchAlgorithmException, ShortBufferException {
+        SecretKeySpec secretKeySpec = new SecretKeySpec(bArr2, "HmacSHA256");
+        Mac mac = Mac.getInstance("HmacSHA256");
+        mac.init(secretKeySpec);
+        mac.update(bArr, i, i2);
+        mac.doFinal(bArr3, i3);
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/DummyEventBus.java

@@ -0,0 +1,22 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class DummyEventBus implements EventBus {
+    public static final EventBus INSTANCE = new DummyEventBus();
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void publish(Intent intent) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable) {
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void unsubscribe(UUID uuid) {
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/EventBus.java

@@ -0,0 +1,14 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+import android.content.IntentFilter;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public interface EventBus {
+    void publish(Intent intent);
+
+    void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable);
+
+    void unsubscribe(UUID uuid);
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/GluActivityLifecycleCallbacks.java

@@ -0,0 +1,89 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.os.Bundle;
+import java.util.HashSet;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public class GluActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    public static final String APPLICATION_PAUSE = "onApplicationPaused";
+    public static final String APPLICATION_RESUME = "onApplicationResumed";
+    private Set<Activity> mActivities;
+    private Application mApplication;
+    private IAction2<String, Activity> mOnActivityCallback;
+
+    public boolean isRunning() {
+        return this.mApplication != null;
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityDestroyed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityResumed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+    }
+
+    public GluActivityLifecycleCallbacks(Context context, IAction2<String, Activity> iAction2) {
+        Context applicationContext = context.getApplicationContext();
+        if (applicationContext instanceof Application) {
+            this.mOnActivityCallback = iAction2;
+            this.mActivities = new HashSet();
+            Application application = (Application) applicationContext;
+            this.mApplication = application;
+            application.registerActivityLifecycleCallbacks(this);
+        }
+    }
+
+    public void destroy() {
+        Common.runOnUIThread(new Runnable() { // from class: com.glu.plugins.gluanalytics.util.GluActivityLifecycleCallbacks.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (GluActivityLifecycleCallbacks.this.mApplication != null) {
+                    GluActivityLifecycleCallbacks.this.mApplication.unregisterActivityLifecycleCallbacks(this);
+                }
+                GluActivityLifecycleCallbacks.this.mApplication = null;
+                GluActivityLifecycleCallbacks.this.mOnActivityCallback = null;
+                GluActivityLifecycleCallbacks.this.mActivities = null;
+            }
+        });
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+        if (this.mOnActivityCallback != null && addActivity(activity) && this.mActivities.size() == 1) {
+            this.mOnActivityCallback.apply("onApplicationResumed", activity);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        addActivity(activity);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+        if (this.mOnActivityCallback != null && this.mActivities.remove(activity) && this.mActivities.size() == 0) {
+            this.mOnActivityCallback.apply("onApplicationPaused", activity);
+        }
+    }
+
+    private boolean addActivity(Activity activity) {
+        Set<Activity> set = this.mActivities;
+        if (set != null) {
+            return set.add(activity);
+        }
+        return false;
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/GoogleAdvertisingIDUtil.java

@@ -0,0 +1,175 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/* loaded from: classes2.dex */
+public class GoogleAdvertisingIDUtil {
+    private static final String ADVERTISING_ID_SERVICE_NAME = "com.google.android.gms.ads.identifier.internal.IAdvertisingIdService";
+
+    public static AnalyticsData.AdvertisingIdInfo getAdvertisingIdInfo(Context context) {
+        AnalyticsData.AdvertisingIdInfo advertisingIdInfo = AnalyticsData.getAdvertisingIdInfo(context);
+        return (advertisingIdInfo == null || isAdvertisingIDEmpty(advertisingIdInfo)) ? getAdvertisingIDByBackupMethod(context) : advertisingIdInfo;
+    }
+
+    private static boolean isAdvertisingIDEmpty(AnalyticsData.AdvertisingIdInfo advertisingIdInfo) {
+        return advertisingIdInfo != null && TextUtils.isEmpty(advertisingIdInfo.advertisingId);
+    }
+
+    private static AnalyticsData.AdvertisingIdInfo getAdvertisingIDByBackupMethod(Context context) {
+        try {
+            return queryAdvertisingIDFromService(context);
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static AnalyticsData.AdvertisingIdInfo queryAdvertisingIDFromService(Context context) {
+        boolean z;
+        GoogleAdvertisingServiceConnection googleAdvertisingServiceConnection = new GoogleAdvertisingServiceConnection();
+        Intent intent = new Intent("com.google.android.gms.ads.identifier.service.START");
+        intent.setPackage("com.google.android.gms");
+        try {
+            z = context.bindService(intent, googleAdvertisingServiceConnection, 1);
+        } catch (Throwable unused) {
+            z = false;
+        }
+        if (z) {
+            try {
+                GoogleAdvertisingInfo create = GoogleAdvertisingInfo.GoogleAdvertisingInfoBinder.create(googleAdvertisingServiceConnection.getBinder());
+                AnalyticsData.AdvertisingIdInfo advertisingIdInfo = new AnalyticsData.AdvertisingIdInfo(create.getId(), create.getEnabled(true));
+                if (z) {
+                    context.unbindService(googleAdvertisingServiceConnection);
+                }
+                return advertisingIdInfo;
+            } catch (Throwable unused2) {
+                if (!z) {
+                    return null;
+                }
+            }
+        } else if (!z) {
+            return null;
+        }
+        context.unbindService(googleAdvertisingServiceConnection);
+        return null;
+    }
+
+    public interface GoogleAdvertisingInfo extends IInterface {
+        boolean getEnabled(boolean z) throws RemoteException;
+
+        String getId() throws RemoteException;
+
+        public static abstract class GoogleAdvertisingInfoBinder extends Binder implements GoogleAdvertisingInfo {
+            public static GoogleAdvertisingInfo create(IBinder iBinder) {
+                if (iBinder == null) {
+                    return null;
+                }
+                IInterface queryLocalInterface = iBinder.queryLocalInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                if (queryLocalInterface instanceof GoogleAdvertisingInfo) {
+                    return (GoogleAdvertisingInfo) queryLocalInterface;
+                }
+                return new GoogleAdvertisingInfoImplementation(iBinder);
+            }
+
+            @Override // android.os.Binder
+            public boolean onTransact(int i, @NonNull Parcel parcel, Parcel parcel2, int i2) throws RemoteException {
+                if (i == 1) {
+                    parcel.enforceInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                    String id = getId();
+                    parcel2.writeNoException();
+                    parcel2.writeString(id);
+                    return true;
+                }
+                if (i == 2) {
+                    parcel.enforceInterface(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                    boolean enabled = getEnabled(parcel.readInt() != 0);
+                    parcel2.writeNoException();
+                    parcel2.writeInt(enabled ? 1 : 0);
+                    return true;
+                }
+                return super.onTransact(i, parcel, parcel2, i2);
+            }
+
+            public static class GoogleAdvertisingInfoImplementation implements GoogleAdvertisingInfo {
+                private final IBinder mBinder;
+
+                @Override // android.os.IInterface
+                public IBinder asBinder() {
+                    return this.mBinder;
+                }
+
+                public GoogleAdvertisingInfoImplementation(IBinder iBinder) {
+                    this.mBinder = iBinder;
+                }
+
+                @Override // com.glu.plugins.gluanalytics.util.GoogleAdvertisingIDUtil.GoogleAdvertisingInfo
+                public String getId() throws RemoteException {
+                    Parcel obtain = Parcel.obtain();
+                    Parcel obtain2 = Parcel.obtain();
+                    try {
+                        obtain.writeInterfaceToken(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                        this.mBinder.transact(1, obtain, obtain2, 0);
+                        obtain2.readException();
+                        return obtain2.readString();
+                    } finally {
+                        obtain2.recycle();
+                        obtain.recycle();
+                    }
+                }
+
+                @Override // com.glu.plugins.gluanalytics.util.GoogleAdvertisingIDUtil.GoogleAdvertisingInfo
+                public boolean getEnabled(boolean z) throws RemoteException {
+                    Parcel obtain = Parcel.obtain();
+                    Parcel obtain2 = Parcel.obtain();
+                    try {
+                        obtain.writeInterfaceToken(GoogleAdvertisingIDUtil.ADVERTISING_ID_SERVICE_NAME);
+                        obtain.writeInt(z ? 1 : 0);
+                        this.mBinder.transact(2, obtain, obtain2, 0);
+                        obtain2.readException();
+                        return obtain2.readInt() != 0;
+                    } finally {
+                        obtain2.recycle();
+                        obtain.recycle();
+                    }
+                }
+            }
+        }
+    }
+
+    public static class GoogleAdvertisingServiceConnection implements ServiceConnection {
+        private final BlockingQueue<IBinder> mBinderQueue = new LinkedBlockingQueue();
+        boolean mConsumed = false;
+
+        @Override // android.content.ServiceConnection
+        public void onServiceDisconnected(ComponentName componentName) {
+        }
+
+        @Override // android.content.ServiceConnection
+        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+            try {
+                this.mBinderQueue.put(iBinder);
+            } catch (Throwable unused) {
+            }
+        }
+
+        public IBinder getBinder() throws InterruptedException {
+            if (this.mConsumed) {
+                throw new IllegalStateException();
+            }
+            this.mConsumed = true;
+            return this.mBinderQueue.take();
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/IAction.java

@@ -0,0 +1,6 @@
+package com.glu.plugins.gluanalytics.util;
+
+/* loaded from: classes2.dex */
+public interface IAction {
+    void apply();
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/IAction2.java

@@ -0,0 +1,6 @@
+package com.glu.plugins.gluanalytics.util;
+
+/* loaded from: classes2.dex */
+public interface IAction2<T1, T2> {
+    void apply(T1 t1, T2 t2);
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/ISerializableJsonObject.java

@@ -0,0 +1,9 @@
+package com.glu.plugins.gluanalytics.util;
+
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public interface ISerializableJsonObject {
+    void write(JSONStringer jSONStringer) throws JSONException;
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/JsonUtil.java

@@ -0,0 +1,304 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.annotation.TargetApi;
+import android.os.Bundle;
+import android.util.JsonReader;
+import android.util.JsonToken;
+import com.fyber.inneractive.sdk.external.InneractiveMediationDefs;
+import csdk.gluads.Consts;
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class JsonUtil {
+    public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+        return Api11.parseJsonObject(str);
+    }
+
+    public static Map<String, Object> toMap(Bundle bundle) {
+        return (Map) toSimpleJavaTypes(bundle);
+    }
+
+    public static Map<String, Object> toMap(JSONObject jSONObject) {
+        return (Map) toSimpleJavaTypes(jSONObject);
+    }
+
+    public static String toJson(Object obj) {
+        JSONStringer jSONStringer = new JSONStringer();
+        try {
+            value(jSONStringer, obj);
+            return jSONStringer.toString();
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    public static void optKeyValue(JSONStringer jSONStringer, String str, Object obj) throws JSONException {
+        if (obj != null) {
+            jSONStringer.key(str);
+            value(jSONStringer, obj);
+        }
+    }
+
+    public static void value(JSONStringer jSONStringer, Object obj) throws JSONException {
+        if (obj == null) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof ISerializableJsonObject) {
+            jSONStringer.object();
+            ((ISerializableJsonObject) obj).write(jSONStringer);
+            jSONStringer.endObject();
+            return;
+        }
+        if ((obj instanceof Number) || (obj instanceof Boolean) || (obj instanceof CharSequence) || (obj instanceof Character)) {
+            jSONStringer.value(obj);
+            return;
+        }
+        if (obj instanceof Map) {
+            serializeMap(jSONStringer, (Map) obj);
+            return;
+        }
+        if (obj instanceof Iterable) {
+            serializeIterable(jSONStringer, (Iterable) obj);
+            return;
+        }
+        if (obj.getClass().isArray()) {
+            serializeArray(jSONStringer, obj);
+        } else if (obj instanceof Throwable) {
+            serializeThrowable(jSONStringer, (Throwable) obj);
+        } else {
+            serializeDefaultObject(jSONStringer, obj);
+        }
+    }
+
+    private static void serializeMap(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        Iterator<?> it = map.keySet().iterator();
+        while (it.hasNext()) {
+            if (!(it.next() instanceof CharSequence)) {
+                serializeMapWithNonStringKeys(jSONStringer, map);
+                return;
+            }
+        }
+        jSONStringer.object();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.key(entry.getKey().toString());
+            value(jSONStringer, entry.getValue());
+        }
+        jSONStringer.endObject();
+    }
+
+    private static void serializeMapWithNonStringKeys(JSONStringer jSONStringer, Map<?, ?> map) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", "flatmap");
+        jSONStringer.key(Consts.KEY_TAPJOY_USER_ID_VERSION).array();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            jSONStringer.array();
+            value(jSONStringer, entry.getKey());
+            value(jSONStringer, entry.getValue());
+            jSONStringer.endArray();
+        }
+        jSONStringer.endArray();
+        jSONStringer.endObject();
+    }
+
+    private static void serializeIterable(JSONStringer jSONStringer, Iterable<?> iterable) throws JSONException {
+        jSONStringer.array();
+        Iterator<?> it = iterable.iterator();
+        while (it.hasNext()) {
+            value(jSONStringer, it.next());
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeArray(JSONStringer jSONStringer, Object obj) throws JSONException {
+        int length = Array.getLength(obj);
+        jSONStringer.array();
+        for (int i = 0; i < length; i++) {
+            value(jSONStringer, Array.get(obj, i));
+        }
+        jSONStringer.endArray();
+    }
+
+    private static void serializeThrowable(JSONStringer jSONStringer, Throwable th) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "cls", th.getClass().getSimpleName());
+        optKeyValue(jSONStringer, InneractiveMediationDefs.GENDER_MALE, th.getMessage());
+        jSONStringer.endObject();
+    }
+
+    private static void serializeDefaultObject(JSONStringer jSONStringer, Object obj) throws JSONException {
+        jSONStringer.object();
+        optKeyValue(jSONStringer, "str", obj.toString());
+        jSONStringer.endObject();
+    }
+
+    private static Object toSimpleJavaTypes(Object obj) {
+        if (obj == null || (obj instanceof String) || (obj instanceof Number) || (obj instanceof Boolean)) {
+            return obj;
+        }
+        if ((obj instanceof CharSequence) || (obj instanceof Character)) {
+            return obj.toString();
+        }
+        if (obj instanceof Iterable) {
+            ArrayList arrayList = new ArrayList();
+            Iterator it = ((Iterable) obj).iterator();
+            while (it.hasNext()) {
+                arrayList.add(toSimpleJavaTypes(it.next()));
+            }
+            return arrayList;
+        }
+        int i = 0;
+        if (obj.getClass().isArray()) {
+            ArrayList arrayList2 = new ArrayList();
+            int length = Array.getLength(obj);
+            while (i < length) {
+                arrayList2.add(toSimpleJavaTypes(Array.get(obj, i)));
+                i++;
+            }
+            return arrayList2;
+        }
+        if (obj instanceof Bundle) {
+            Map createMap = CollectionUtil.createMap();
+            Bundle bundle = (Bundle) obj;
+            for (String str : bundle.keySet()) {
+                createMap.put(str, toSimpleJavaTypes(bundle.get(str)));
+            }
+            return createMap;
+        }
+        if (obj instanceof JSONArray) {
+            ArrayList arrayList3 = new ArrayList();
+            JSONArray jSONArray = (JSONArray) obj;
+            while (i < jSONArray.length()) {
+                arrayList3.add(toSimpleJavaTypes(jSONArray.opt(i)));
+                i++;
+            }
+            return arrayList3;
+        }
+        if (obj instanceof JSONObject) {
+            Map createMap2 = CollectionUtil.createMap();
+            JSONObject jSONObject = (JSONObject) obj;
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                createMap2.put(next, toSimpleJavaTypes(jSONObject.opt(next)));
+            }
+            return createMap2;
+        }
+        if (obj == JSONObject.NULL) {
+            return null;
+        }
+        throw new IllegalArgumentException(String.format("Unsupported type %s", obj.getClass()));
+    }
+
+    @TargetApi(11)
+    public static class Api11 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            JsonReader jsonReader;
+            JsonReader jsonReader2 = null;
+            try {
+                try {
+                    jsonReader = new JsonReader(new StringReader(str));
+                } catch (Throwable th) {
+                    th = th;
+                }
+            } catch (IOException e) {
+                e = e;
+            }
+            try {
+                jsonReader.setLenient(true);
+                Map<String, Object> parseJsonObject = parseJsonObject(jsonReader);
+                try {
+                    jsonReader.close();
+                    return parseJsonObject;
+                } catch (IOException e2) {
+                    throw Common.propagate(e2);
+                }
+            } catch (IOException e3) {
+                e = e3;
+                throw Common.propagate(e);
+            } catch (Throwable th2) {
+                th = th2;
+                jsonReader2 = jsonReader;
+                if (jsonReader2 != null) {
+                    try {
+                        jsonReader2.close();
+                    } catch (IOException e4) {
+                        throw Common.propagate(e4);
+                    }
+                }
+                throw th;
+            }
+        }
+
+        public static Object parseJsonValue(JsonReader jsonReader) throws JSONException, IOException {
+            JsonToken peek = jsonReader.peek();
+            if (peek == JsonToken.BEGIN_OBJECT) {
+                return parseJsonObject(jsonReader);
+            }
+            if (peek == JsonToken.BEGIN_ARRAY) {
+                return parseJsonArray(jsonReader);
+            }
+            if (peek == JsonToken.BOOLEAN) {
+                return Boolean.valueOf(jsonReader.nextBoolean());
+            }
+            if (peek == JsonToken.NULL) {
+                jsonReader.nextNull();
+                return null;
+            }
+            if (peek == JsonToken.NUMBER) {
+                String nextString = jsonReader.nextString();
+                if (nextString.contains(Consts.STRING_PERIOD) || nextString.contains("e") || nextString.contains("E")) {
+                    return Double.valueOf(Double.parseDouble(nextString));
+                }
+                return Long.valueOf(Long.parseLong(nextString));
+            }
+            if (peek == JsonToken.STRING) {
+                return jsonReader.nextString();
+            }
+            throw new JSONException("Unexpected token " + peek);
+        }
+
+        public static Map<String, Object> parseJsonObject(JsonReader jsonReader) throws JSONException, IOException {
+            Map<String, Object> createMap = CollectionUtil.createMap();
+            jsonReader.beginObject();
+            while (true) {
+                JsonToken peek = jsonReader.peek();
+                if (peek == JsonToken.END_OBJECT) {
+                    jsonReader.endObject();
+                    return createMap;
+                }
+                if (peek == JsonToken.NAME) {
+                    createMap.put(jsonReader.nextName(), parseJsonValue(jsonReader));
+                } else {
+                    throw new JSONException("Expected } or name but found " + peek);
+                }
+            }
+        }
+
+        public static List<Object> parseJsonArray(JsonReader jsonReader) throws JSONException, IOException {
+            ArrayList arrayList = new ArrayList();
+            jsonReader.beginArray();
+            while (jsonReader.peek() != JsonToken.END_ARRAY) {
+                arrayList.add(parseJsonValue(jsonReader));
+            }
+            jsonReader.endArray();
+            return arrayList;
+        }
+    }
+
+    public static class Api1 {
+        public static Map<String, Object> parseJsonObject(String str) throws JSONException {
+            return JsonUtil.toMap(new JSONObject(str));
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/LocalBroadcastManagerEventBus.java

@@ -0,0 +1,97 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.UUID;
+
+/* loaded from: classes2.dex */
+public class LocalBroadcastManagerEventBus implements EventBus {
+    private static volatile EventBus sInstance;
+    private final LocalBroadcastManager mLbm;
+    private final Map<UUID, BroadcastReceiver> mReceivers = new HashMap();
+
+    public static boolean isSupported() {
+        return true;
+    }
+
+    private LocalBroadcastManagerEventBus(Context context) {
+        this.mLbm = LocalBroadcastManager.getInstance(context);
+    }
+
+    public static EventBus getInstance(Context context) {
+        Common.require(context != null, "context can't be null.");
+        if (sInstance == null) {
+            synchronized (LocalBroadcastManagerEventBus.class) {
+                try {
+                    if (sInstance == null) {
+                        sInstance = new LocalBroadcastManagerEventBus(context);
+                    }
+                } finally {
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void subscribe(UUID uuid, Subscriber subscriber, Iterable<IntentFilter> iterable) {
+        Common.require(uuid != null, "key can't be null.");
+        Common.require(subscriber != null, "weakSubscriber can't be null.");
+        Common.require(iterable != null, "filters can't be null.");
+        unsubscribe(uuid);
+        SubscriberAdapter subscriberAdapter = new SubscriberAdapter(uuid, subscriber);
+        synchronized (this) {
+            this.mReceivers.put(uuid, subscriberAdapter);
+        }
+        Iterator<IntentFilter> it = iterable.iterator();
+        while (it.hasNext()) {
+            this.mLbm.registerReceiver(subscriberAdapter, it.next());
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void unsubscribe(UUID uuid) {
+        BroadcastReceiver remove;
+        Common.require(uuid != null, "key can't be null.");
+        synchronized (this) {
+            remove = this.mReceivers.remove(uuid);
+        }
+        if (remove != null) {
+            this.mLbm.unregisterReceiver(remove);
+        }
+    }
+
+    @Override // com.glu.plugins.gluanalytics.util.EventBus
+    public void publish(Intent intent) {
+        Common.require(intent != null, "intent can't be null.");
+        this.mLbm.sendBroadcast(intent);
+    }
+
+    public class SubscriberAdapter extends BroadcastReceiver {
+        private final UUID mKey;
+        private final Reference<Subscriber> mSubscriber;
+
+        public SubscriberAdapter(UUID uuid, Subscriber subscriber) {
+            this.mKey = uuid;
+            this.mSubscriber = new WeakReference(subscriber);
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            Subscriber subscriber = this.mSubscriber.get();
+            if (subscriber != null) {
+                subscriber.onReceive(LocalBroadcastManagerEventBus.this, intent);
+            } else {
+                LocalBroadcastManagerEventBus.this.unsubscribe(this.mKey);
+            }
+        }
+    }
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/Subscriber.java

@@ -0,0 +1,8 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.content.Intent;
+
+/* loaded from: classes2.dex */
+public interface Subscriber {
+    void onReceive(EventBus eventBus, Intent intent);
+}

decompiled/sources/com/glu/plugins/gluanalytics/util/YLogger.java

@@ -0,0 +1,110 @@
+package com.glu.plugins.gluanalytics.util;
+
+import android.text.TextUtils;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.json.JSONException;
+import org.json.JSONStringer;
+
+/* loaded from: classes2.dex */
+public class YLogger {
+    private final Logger mLog;
+
+    private YLogger(Logger logger) {
+        this.mLog = logger;
+    }
+
+    public static YLogger create(String str) {
+        return new YLogger(Logger.getLogger(str));
+    }
+
+    public static YLogger create(Class<?> cls) {
+        return create(cls.getName());
+    }
+
+    public void v(String str, Object... objArr) {
+        doLog(Level.FINEST, str, objArr);
+    }
+
+    public void i(String str, Object... objArr) {
+        doLog(Level.INFO, str, objArr);
+    }
+
+    public void e(String str, Object... objArr) {
+        doLog(Level.SEVERE, str, objArr);
+    }
+
+    public boolean canV() {
+        return this.mLog.isLoggable(Level.FINEST);
+    }
+
+    private static String format(String str, Object... objArr) {
+        try {
+            JSONStringer object = new JSONStringer().array().value(str).object();
+            appendPlistToJson(object, objArr);
+            Object[] plistTail = plistTail(objArr);
+            if (plistTail != null) {
+                appendPlistToJson(object, plistTail);
+            }
+            object.endObject().endArray();
+            return "#evu" + object.toString();
+        } catch (JSONException e) {
+            throw Common.propagate(e);
+        }
+    }
+
+    private static Throwable findThrowable(Object... objArr) {
+        Throwable findThrowableNoTail = findThrowableNoTail(objArr);
+        if (findThrowableNoTail != null) {
+            return findThrowableNoTail;
+        }
+        Object[] plistTail = plistTail(objArr);
+        if (plistTail != null) {
+            return findThrowableNoTail(plistTail);
+        }
+        return null;
+    }
+
+    private static Throwable findThrowableNoTail(Object... objArr) {
+        int length = objArr.length - (objArr.length % 2);
+        for (int i = 0; i < length; i += 2) {
+            if (TextUtils.equals((String) objArr[i], "e")) {
+                Object obj = objArr[i + 1];
+                if (obj instanceof Throwable) {
+                    return (Throwable) obj;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Object[] plistTail(Object[] objArr) {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        if (i < length) {
+            Object obj = objArr[i];
+            if (obj instanceof Object[]) {
+                return (Object[]) obj;
+            }
+        }
+        return null;
+    }
+
+    private static void appendPlistToJson(JSONStringer jSONStringer, Object[] objArr) throws JSONException {
+        int length = objArr.length;
+        int i = length - (length % 2);
+        for (int i2 = 0; i2 < i; i2 += 2) {
+            Object obj = objArr[i2];
+            Object obj2 = objArr[i2 + 1];
+            if ((obj instanceof String) && obj2 != null) {
+                jSONStringer.key((String) obj).value(obj2);
+            }
+        }
+    }
+
+    private void doLog(Level level, String str, Object[] objArr) {
+        if (this.mLog.isLoggable(level)) {
+            this.mLog.log(level, format(str, objArr), findThrowable(objArr));
+        }
+    }
+}