Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
566 lines
24 KiB
Java
566 lines
24 KiB
Java
package com.vungle.ads;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.os.Build;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import androidx.annotation.WorkerThread;
|
|
import com.ironsource.v8;
|
|
import com.vungle.ads.internal.executor.VungleThreadPoolExecutor;
|
|
import com.vungle.ads.internal.network.VungleApiClient;
|
|
import com.vungle.ads.internal.protos.Sdk;
|
|
import com.vungle.ads.internal.signals.SignalManager;
|
|
import com.vungle.ads.internal.util.ActivityManager;
|
|
import com.vungle.ads.internal.util.Logger;
|
|
import java.util.concurrent.BlockingQueue;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.TimeUnit;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
import kotlin.jvm.internal.Intrinsics;
|
|
|
|
/* loaded from: classes4.dex */
|
|
public final class AnalyticsClient {
|
|
public static final AnalyticsClient INSTANCE = new AnalyticsClient();
|
|
private static final String TAG;
|
|
private static final BlockingQueue<Sdk.SDKError.Builder> errors;
|
|
private static VungleThreadPoolExecutor executor = null;
|
|
private static LogLevel logLevel = null;
|
|
private static final int maxBatchSize = 20;
|
|
private static final BlockingQueue<Sdk.SDKMetric.Builder> metrics;
|
|
private static boolean metricsEnabled = false;
|
|
private static boolean paused = false;
|
|
private static final BlockingQueue<Sdk.SDKError.Builder> pendingErrors;
|
|
private static final BlockingQueue<Sdk.SDKMetric.Builder> pendingMetrics;
|
|
private static boolean refreshEnabled = false;
|
|
private static final long refreshTimeMillis = 5000;
|
|
|
|
@SuppressLint({"StaticFieldLeak"})
|
|
private static SignalManager signalManager;
|
|
private static VungleApiClient vungleApiClient;
|
|
|
|
public interface RequestListener {
|
|
void onFailure();
|
|
|
|
void onSuccess();
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getErrors$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getExecutor$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getMetrics$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getMetricsEnabled$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getPendingErrors$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getPendingMetrics$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getRefreshEnabled$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getSignalManager$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getVungleApiClient$vungle_ads_release$annotations() {
|
|
}
|
|
|
|
public final BlockingQueue<Sdk.SDKError.Builder> getErrors$vungle_ads_release() {
|
|
return errors;
|
|
}
|
|
|
|
public final VungleThreadPoolExecutor getExecutor$vungle_ads_release() {
|
|
return executor;
|
|
}
|
|
|
|
public final BlockingQueue<Sdk.SDKMetric.Builder> getMetrics$vungle_ads_release() {
|
|
return metrics;
|
|
}
|
|
|
|
public final boolean getMetricsEnabled$vungle_ads_release() {
|
|
return metricsEnabled;
|
|
}
|
|
|
|
public final BlockingQueue<Sdk.SDKError.Builder> getPendingErrors$vungle_ads_release() {
|
|
return pendingErrors;
|
|
}
|
|
|
|
public final BlockingQueue<Sdk.SDKMetric.Builder> getPendingMetrics$vungle_ads_release() {
|
|
return pendingMetrics;
|
|
}
|
|
|
|
public final boolean getRefreshEnabled$vungle_ads_release() {
|
|
return refreshEnabled;
|
|
}
|
|
|
|
public final SignalManager getSignalManager$vungle_ads_release() {
|
|
return signalManager;
|
|
}
|
|
|
|
public final VungleApiClient getVungleApiClient$vungle_ads_release() {
|
|
return vungleApiClient;
|
|
}
|
|
|
|
public final void pause() {
|
|
paused = true;
|
|
}
|
|
|
|
public final void resume() {
|
|
paused = false;
|
|
}
|
|
|
|
public final void setExecutor$vungle_ads_release(VungleThreadPoolExecutor vungleThreadPoolExecutor) {
|
|
executor = vungleThreadPoolExecutor;
|
|
}
|
|
|
|
public final void setMetricsEnabled$vungle_ads_release(boolean z) {
|
|
metricsEnabled = z;
|
|
}
|
|
|
|
public final void setRefreshEnabled$vungle_ads_release(boolean z) {
|
|
refreshEnabled = z;
|
|
}
|
|
|
|
public final void setSignalManager$vungle_ads_release(SignalManager signalManager2) {
|
|
signalManager = signalManager2;
|
|
}
|
|
|
|
public final void setVungleApiClient$vungle_ads_release(VungleApiClient vungleApiClient2) {
|
|
vungleApiClient = vungleApiClient2;
|
|
}
|
|
|
|
private AnalyticsClient() {
|
|
}
|
|
|
|
public enum LogLevel {
|
|
ERROR_LOG_LEVEL_OFF(0),
|
|
ERROR_LOG_LEVEL_ERROR(1),
|
|
ERROR_LOG_LEVEL_DEBUG(2);
|
|
|
|
public static final Companion Companion = new Companion(null);
|
|
private final int level;
|
|
|
|
public final int getLevel() {
|
|
return this.level;
|
|
}
|
|
|
|
LogLevel(int i) {
|
|
this.level = i;
|
|
}
|
|
|
|
public static final class Companion {
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
|
|
private Companion() {
|
|
}
|
|
|
|
public final LogLevel fromValue(int i) {
|
|
LogLevel logLevel = LogLevel.ERROR_LOG_LEVEL_DEBUG;
|
|
if (i == logLevel.getLevel()) {
|
|
return logLevel;
|
|
}
|
|
LogLevel logLevel2 = LogLevel.ERROR_LOG_LEVEL_ERROR;
|
|
if (i == logLevel2.getLevel()) {
|
|
return logLevel2;
|
|
}
|
|
LogLevel logLevel3 = LogLevel.ERROR_LOG_LEVEL_OFF;
|
|
return i == logLevel3.getLevel() ? logLevel3 : logLevel2;
|
|
}
|
|
}
|
|
}
|
|
|
|
static {
|
|
String simpleName = AnalyticsClient.class.getSimpleName();
|
|
Intrinsics.checkNotNullExpressionValue(simpleName, "AnalyticsClient::class.java.simpleName");
|
|
TAG = simpleName;
|
|
errors = new LinkedBlockingQueue();
|
|
metrics = new LinkedBlockingQueue();
|
|
pendingErrors = new LinkedBlockingQueue();
|
|
pendingMetrics = new LinkedBlockingQueue();
|
|
logLevel = LogLevel.ERROR_LOG_LEVEL_ERROR;
|
|
refreshEnabled = true;
|
|
}
|
|
|
|
public final void init$vungle_ads_release(VungleApiClient vungleApiClient2, final VungleThreadPoolExecutor executor2, int i, boolean z, SignalManager signalManager2) {
|
|
Intrinsics.checkNotNullParameter(vungleApiClient2, "vungleApiClient");
|
|
Intrinsics.checkNotNullParameter(executor2, "executor");
|
|
Intrinsics.checkNotNullParameter(signalManager2, "signalManager");
|
|
signalManager = signalManager2;
|
|
executor = executor2;
|
|
vungleApiClient = vungleApiClient2;
|
|
try {
|
|
BlockingQueue<Sdk.SDKError.Builder> blockingQueue = pendingErrors;
|
|
if (!blockingQueue.isEmpty()) {
|
|
blockingQueue.drainTo(errors);
|
|
}
|
|
} catch (Exception e) {
|
|
Logger.Companion.e(TAG, "Failed to add pendingErrors to errors queue.", e);
|
|
}
|
|
try {
|
|
BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue2 = pendingMetrics;
|
|
if (!blockingQueue2.isEmpty()) {
|
|
blockingQueue2.drainTo(metrics);
|
|
}
|
|
} catch (Exception e2) {
|
|
Logger.Companion.e(TAG, "Failed to add pendingMetrics to metrics queue.", e2);
|
|
}
|
|
if (refreshEnabled) {
|
|
Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda1
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
AnalyticsClient.m3780init$lambda1(VungleThreadPoolExecutor.this);
|
|
}
|
|
}, 0L, 5000L, TimeUnit.MILLISECONDS);
|
|
}
|
|
updateErrorLevelAndMetricEnabled$vungle_ads_release(i, z);
|
|
if (i == LogLevel.ERROR_LOG_LEVEL_DEBUG.getLevel()) {
|
|
Logger.Companion.enable(true);
|
|
} else if (i == LogLevel.ERROR_LOG_LEVEL_ERROR.getLevel()) {
|
|
Logger.Companion.enable(false);
|
|
} else if (i == LogLevel.ERROR_LOG_LEVEL_OFF.getLevel()) {
|
|
Logger.Companion.enable(false);
|
|
}
|
|
ActivityManager.Companion.addLifecycleListener(new ActivityManager.LifeCycleCallback() { // from class: com.vungle.ads.AnalyticsClient$init$2
|
|
@Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
|
|
public void onResume() {
|
|
super.onResume();
|
|
AnalyticsClient.INSTANCE.resume();
|
|
}
|
|
|
|
@Override // com.vungle.ads.internal.util.ActivityManager.LifeCycleCallback
|
|
public void onPause() {
|
|
super.onPause();
|
|
AnalyticsClient.INSTANCE.pause();
|
|
}
|
|
});
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: init$lambda-1, reason: not valid java name */
|
|
public static final void m3780init$lambda1(VungleThreadPoolExecutor executor2) {
|
|
Intrinsics.checkNotNullParameter(executor2, "$executor");
|
|
executor2.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda0
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
AnalyticsClient.m3781init$lambda1$lambda0();
|
|
}
|
|
});
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: init$lambda-1$lambda-0, reason: not valid java name */
|
|
public static final void m3781init$lambda1$lambda0() {
|
|
INSTANCE.report();
|
|
}
|
|
|
|
public final synchronized void updateErrorLevelAndMetricEnabled$vungle_ads_release(int i, boolean z) {
|
|
logLevel = LogLevel.Companion.fromValue(i);
|
|
metricsEnabled = z;
|
|
}
|
|
|
|
public final synchronized void logError$vungle_ads_release(final Sdk.SDKError.Reason reason, final String message, final String str, final String str2, final String str3) {
|
|
VungleThreadPoolExecutor vungleThreadPoolExecutor;
|
|
Intrinsics.checkNotNullParameter(reason, "reason");
|
|
Intrinsics.checkNotNullParameter(message, "message");
|
|
try {
|
|
vungleThreadPoolExecutor = executor;
|
|
} catch (Exception e) {
|
|
Logger.Companion.e(TAG, "Cannot logError " + reason + ", " + message + ", " + str + ", " + str2 + ',' + str3, e);
|
|
}
|
|
if (vungleThreadPoolExecutor == null) {
|
|
pendingErrors.put(genSDKError(reason, message, str, str2, str3));
|
|
} else {
|
|
if (vungleThreadPoolExecutor != null) {
|
|
vungleThreadPoolExecutor.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda2
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
AnalyticsClient.m3782logError$lambda2(Sdk.SDKError.Reason.this, message, str, str2, str3);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: logError$lambda-2, reason: not valid java name */
|
|
public static final void m3782logError$lambda2(Sdk.SDKError.Reason reason, String message, String str, String str2, String str3) {
|
|
Intrinsics.checkNotNullParameter(reason, "$reason");
|
|
Intrinsics.checkNotNullParameter(message, "$message");
|
|
INSTANCE.logErrorInSameThread(reason, message, str, str2, str3);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public final Sdk.SDKError.Builder genSDKError(Sdk.SDKError.Reason reason, String str, String str2, String str3, String str4) {
|
|
String uuid;
|
|
Sdk.SDKError.Builder at = Sdk.SDKError.newBuilder().setOs(v8.d).setOsVersion(String.valueOf(Build.VERSION.SDK_INT)).setMake(Build.MANUFACTURER).setModel(Build.MODEL).setReason(reason).setMessage(str).setAt(System.currentTimeMillis());
|
|
String str5 = "";
|
|
if (str2 == null) {
|
|
str2 = "";
|
|
}
|
|
Sdk.SDKError.Builder placementReferenceId = at.setPlacementReferenceId(str2);
|
|
if (str3 == null) {
|
|
str3 = "";
|
|
}
|
|
Sdk.SDKError.Builder creativeId = placementReferenceId.setCreativeId(str3);
|
|
if (str4 == null) {
|
|
str4 = "";
|
|
}
|
|
Sdk.SDKError.Builder eventId = creativeId.setEventId(str4);
|
|
SignalManager signalManager2 = signalManager;
|
|
if (signalManager2 != null && (uuid = signalManager2.getUuid()) != null) {
|
|
str5 = uuid;
|
|
}
|
|
Sdk.SDKError.Builder sessionId = eventId.setSessionId(str5);
|
|
Intrinsics.checkNotNullExpressionValue(sessionId, "newBuilder()\n …ignalManager?.uuid ?: \"\")");
|
|
return sessionId;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public final synchronized void logErrorInSameThread(Sdk.SDKError.Reason reason, String str, String str2, String str3, String str4) {
|
|
if (logLevel == LogLevel.ERROR_LOG_LEVEL_OFF) {
|
|
return;
|
|
}
|
|
try {
|
|
Sdk.SDKError.Builder genSDKError = genSDKError(reason, str, str2, str3, str4);
|
|
BlockingQueue<Sdk.SDKError.Builder> blockingQueue = errors;
|
|
blockingQueue.put(genSDKError);
|
|
Logger.Companion.w(TAG, "Logging error: " + reason + " with message: " + str);
|
|
if (blockingQueue.size() >= 20) {
|
|
report();
|
|
}
|
|
} catch (Exception e) {
|
|
Logger.Companion.e(TAG, "Cannot logError", e);
|
|
}
|
|
}
|
|
|
|
public final synchronized void logError$vungle_ads_release(int i, String message, String str, String str2, String str3) {
|
|
Intrinsics.checkNotNullParameter(message, "message");
|
|
Sdk.SDKError.Reason forNumber = Sdk.SDKError.Reason.forNumber(i);
|
|
Intrinsics.checkNotNullExpressionValue(forNumber, "forNumber(reasonCode)");
|
|
logError$vungle_ads_release(forNumber, message, str, str2, str3);
|
|
}
|
|
|
|
public final synchronized void logMetric$vungle_ads_release(final Sdk.SDKMetric.SDKMetricType metricType, final long j, final String str, final String str2, final String str3, final String str4) {
|
|
VungleThreadPoolExecutor vungleThreadPoolExecutor;
|
|
Intrinsics.checkNotNullParameter(metricType, "metricType");
|
|
try {
|
|
vungleThreadPoolExecutor = executor;
|
|
} catch (Exception e) {
|
|
Logger.Companion.e(TAG, "Cannot logMetric " + metricType + ", " + j + ", " + str + ", " + str2 + ',' + str3 + ", " + str4, e);
|
|
}
|
|
if (vungleThreadPoolExecutor == null) {
|
|
pendingMetrics.put(genMetric(metricType, j, str, str2, str3, str4));
|
|
} else {
|
|
if (vungleThreadPoolExecutor != null) {
|
|
vungleThreadPoolExecutor.execute(new Runnable() { // from class: com.vungle.ads.AnalyticsClient$$ExternalSyntheticLambda3
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
AnalyticsClient.m3783logMetric$lambda3(Sdk.SDKMetric.SDKMetricType.this, j, str, str2, str3, str4);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: logMetric$lambda-3, reason: not valid java name */
|
|
public static final void m3783logMetric$lambda3(Sdk.SDKMetric.SDKMetricType metricType, long j, String str, String str2, String str3, String str4) {
|
|
Intrinsics.checkNotNullParameter(metricType, "$metricType");
|
|
INSTANCE.logMetricInSameThread(metricType, j, str, str2, str3, str4);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public final Sdk.SDKMetric.Builder genMetric(Sdk.SDKMetric.SDKMetricType sDKMetricType, long j, String str, String str2, String str3, String str4) {
|
|
String uuid;
|
|
Sdk.SDKMetric.Builder osVersion = Sdk.SDKMetric.newBuilder().setType(sDKMetricType).setValue(j).setMake(Build.MANUFACTURER).setModel(Build.MODEL).setOs(v8.d).setOsVersion(String.valueOf(Build.VERSION.SDK_INT));
|
|
String str5 = "";
|
|
if (str == null) {
|
|
str = "";
|
|
}
|
|
Sdk.SDKMetric.Builder placementReferenceId = osVersion.setPlacementReferenceId(str);
|
|
if (str2 == null) {
|
|
str2 = "";
|
|
}
|
|
Sdk.SDKMetric.Builder creativeId = placementReferenceId.setCreativeId(str2);
|
|
if (str3 == null) {
|
|
str3 = "";
|
|
}
|
|
Sdk.SDKMetric.Builder eventId = creativeId.setEventId(str3);
|
|
if (str4 == null) {
|
|
str4 = "";
|
|
}
|
|
Sdk.SDKMetric.Builder meta = eventId.setMeta(str4);
|
|
SignalManager signalManager2 = signalManager;
|
|
if (signalManager2 != null && (uuid = signalManager2.getUuid()) != null) {
|
|
str5 = uuid;
|
|
}
|
|
Sdk.SDKMetric.Builder sessionId = meta.setSessionId(str5);
|
|
Intrinsics.checkNotNullExpressionValue(sessionId, "newBuilder()\n …ignalManager?.uuid ?: \"\")");
|
|
return sessionId;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public final synchronized void logMetricInSameThread(Sdk.SDKMetric.SDKMetricType sDKMetricType, long j, String str, String str2, String str3, String str4) {
|
|
if (metricsEnabled) {
|
|
try {
|
|
Sdk.SDKMetric.Builder genMetric = genMetric(sDKMetricType, j, str, str2, str3, str4);
|
|
BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue = metrics;
|
|
blockingQueue.put(genMetric);
|
|
Logger.Companion.d(TAG, "Logging Metric " + sDKMetricType + " with value " + j + " for placement " + str);
|
|
if (blockingQueue.size() >= 20) {
|
|
report();
|
|
}
|
|
} catch (Exception e) {
|
|
Logger.Companion.e(TAG, "Cannot logMetrics", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final synchronized void logMetric$vungle_ads_release(Metric metric, String str, String str2, String str3, String str4) {
|
|
try {
|
|
Intrinsics.checkNotNullParameter(metric, "metric");
|
|
Sdk.SDKMetric.SDKMetricType metricType = metric.getMetricType();
|
|
long value = metric.getValue();
|
|
if (str4 == null) {
|
|
str4 = metric.getMeta();
|
|
}
|
|
logMetric$vungle_ads_release(metricType, value, str, str2, str3, str4);
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public final synchronized void logMetric$vungle_ads_release(SingleValueMetric singleValueMetric, String str, String str2, String str3, String str4) {
|
|
Intrinsics.checkNotNullParameter(singleValueMetric, "singleValueMetric");
|
|
logMetric$vungle_ads_release((Metric) singleValueMetric, str, str2, str3, str4);
|
|
}
|
|
|
|
public static /* synthetic */ void logMetric$vungle_ads_release$default(AnalyticsClient analyticsClient, TimeIntervalMetric timeIntervalMetric, String str, String str2, String str3, String str4, int i, Object obj) {
|
|
String str5 = (i & 2) != 0 ? null : str;
|
|
String str6 = (i & 4) != 0 ? null : str2;
|
|
String str7 = (i & 8) != 0 ? null : str3;
|
|
if ((i & 16) != 0) {
|
|
str4 = timeIntervalMetric.getMeta();
|
|
}
|
|
analyticsClient.logMetric$vungle_ads_release(timeIntervalMetric, str5, str6, str7, str4);
|
|
}
|
|
|
|
public final synchronized void logMetric$vungle_ads_release(TimeIntervalMetric timeIntervalMetric, String str, String str2, String str3, String str4) {
|
|
Intrinsics.checkNotNullParameter(timeIntervalMetric, "timeIntervalMetric");
|
|
logMetric$vungle_ads_release((Metric) timeIntervalMetric, str, str2, str3, str4);
|
|
}
|
|
|
|
public final synchronized void logMetric$vungle_ads_release(OneShotTimeIntervalMetric oneShotTimeIntervalMetric, String str, String str2, String str3, String str4) {
|
|
Intrinsics.checkNotNullParameter(oneShotTimeIntervalMetric, "oneShotTimeIntervalMetric");
|
|
if (!oneShotTimeIntervalMetric.isLogged()) {
|
|
logMetric$vungle_ads_release((TimeIntervalMetric) oneShotTimeIntervalMetric, str, str2, str3, str4);
|
|
oneShotTimeIntervalMetric.markLogged();
|
|
}
|
|
}
|
|
|
|
private final synchronized void report() {
|
|
try {
|
|
if (paused) {
|
|
return;
|
|
}
|
|
if (logLevel != LogLevel.ERROR_LOG_LEVEL_OFF && errors.size() > 0) {
|
|
flushErrors();
|
|
}
|
|
if (metricsEnabled && metrics.size() > 0) {
|
|
flushMetrics();
|
|
}
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
@WorkerThread
|
|
private final void flushMetrics() {
|
|
VungleApiClient vungleApiClient2;
|
|
Logger.Companion companion = Logger.Companion;
|
|
String str = TAG;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("Sending ");
|
|
BlockingQueue<Sdk.SDKMetric.Builder> blockingQueue = metrics;
|
|
sb.append(blockingQueue.size());
|
|
sb.append(" metrics");
|
|
companion.d(str, sb.toString());
|
|
final LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
|
|
blockingQueue.drainTo(linkedBlockingQueue);
|
|
if (linkedBlockingQueue.isEmpty() || (vungleApiClient2 = vungleApiClient) == null) {
|
|
return;
|
|
}
|
|
vungleApiClient2.reportMetrics(linkedBlockingQueue, new RequestListener() { // from class: com.vungle.ads.AnalyticsClient$flushMetrics$1
|
|
@Override // com.vungle.ads.AnalyticsClient.RequestListener
|
|
public void onSuccess() {
|
|
String str2;
|
|
Logger.Companion companion2 = Logger.Companion;
|
|
str2 = AnalyticsClient.TAG;
|
|
companion2.d(str2, "Sent " + linkedBlockingQueue.size() + " metrics");
|
|
}
|
|
|
|
@Override // com.vungle.ads.AnalyticsClient.RequestListener
|
|
public void onFailure() {
|
|
String str2;
|
|
Logger.Companion companion2 = Logger.Companion;
|
|
str2 = AnalyticsClient.TAG;
|
|
companion2.d(str2, "Failed to send " + linkedBlockingQueue.size() + " metrics");
|
|
AnalyticsClient.INSTANCE.getMetrics$vungle_ads_release().addAll(linkedBlockingQueue);
|
|
}
|
|
});
|
|
}
|
|
|
|
@WorkerThread
|
|
private final void flushErrors() {
|
|
VungleApiClient vungleApiClient2;
|
|
Logger.Companion companion = Logger.Companion;
|
|
String str = TAG;
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("Sending ");
|
|
BlockingQueue<Sdk.SDKError.Builder> blockingQueue = errors;
|
|
sb.append(blockingQueue.size());
|
|
sb.append(" errors");
|
|
companion.d(str, sb.toString());
|
|
final LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
|
|
blockingQueue.drainTo(linkedBlockingQueue);
|
|
if (linkedBlockingQueue.isEmpty() || (vungleApiClient2 = vungleApiClient) == null) {
|
|
return;
|
|
}
|
|
vungleApiClient2.reportErrors(linkedBlockingQueue, new RequestListener() { // from class: com.vungle.ads.AnalyticsClient$flushErrors$1
|
|
@Override // com.vungle.ads.AnalyticsClient.RequestListener
|
|
public void onSuccess() {
|
|
String str2;
|
|
Logger.Companion companion2 = Logger.Companion;
|
|
str2 = AnalyticsClient.TAG;
|
|
companion2.d(str2, "Sent " + linkedBlockingQueue.size() + " errors");
|
|
}
|
|
|
|
@Override // com.vungle.ads.AnalyticsClient.RequestListener
|
|
public void onFailure() {
|
|
String str2;
|
|
Logger.Companion companion2 = Logger.Companion;
|
|
str2 = AnalyticsClient.TAG;
|
|
companion2.d(str2, "Failed to send " + linkedBlockingQueue.size() + " errors");
|
|
AnalyticsClient.INSTANCE.getErrors$vungle_ads_release().addAll(linkedBlockingQueue);
|
|
}
|
|
});
|
|
}
|
|
}
|