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/google/firebase/perf/transport/FlgTransport.java

@@ -0,0 +1,48 @@
+package com.google.firebase.perf.transport;
+
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Event;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.Transport;
+import com.google.android.datatransport.TransportFactory;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.perf.logging.AndroidLogger;
+import com.google.firebase.perf.v1.PerfMetric;
+
+/* loaded from: classes3.dex */
+public final class FlgTransport {
+    public static final AndroidLogger logger = AndroidLogger.getInstance();
+    public Transport flgTransport;
+    public final Provider flgTransportFactoryProvider;
+    public final String logSourceName;
+
+    public FlgTransport(Provider provider, String str) {
+        this.logSourceName = str;
+        this.flgTransportFactoryProvider = provider;
+    }
+
+    public void log(PerfMetric perfMetric) {
+        if (!initializeFlgTransportClient()) {
+            logger.warn("Unable to dispatch event because Flg Transport is not available");
+        } else {
+            this.flgTransport.send(Event.ofData(perfMetric));
+        }
+    }
+
+    public final boolean initializeFlgTransportClient() {
+        if (this.flgTransport == null) {
+            TransportFactory transportFactory = (TransportFactory) this.flgTransportFactoryProvider.get();
+            if (transportFactory != null) {
+                this.flgTransport = transportFactory.getTransport(this.logSourceName, PerfMetric.class, Encoding.of("proto"), new Transformer() { // from class: com.google.firebase.perf.transport.FlgTransport$$ExternalSyntheticLambda0
+                    @Override // com.google.android.datatransport.Transformer
+                    public final Object apply(Object obj) {
+                        return ((PerfMetric) obj).toByteArray();
+                    }
+                });
+            } else {
+                logger.warn("Flg TransportFactory is not available at the moment");
+            }
+        }
+        return this.flgTransport != null;
+    }
+}

decompiled/sources/com/google/firebase/perf/transport/PendingPerfEvent.java

@@ -0,0 +1,15 @@
+package com.google.firebase.perf.transport;
+
+import com.google.firebase.perf.v1.ApplicationProcessState;
+import com.google.firebase.perf.v1.PerfMetric;
+
+/* loaded from: classes3.dex */
+public final class PendingPerfEvent {
+    public final ApplicationProcessState appState;
+    public final PerfMetric.Builder perfMetricBuilder;
+
+    public PendingPerfEvent(PerfMetric.Builder builder, ApplicationProcessState applicationProcessState) {
+        this.perfMetricBuilder = builder;
+        this.appState = applicationProcessState;
+    }
+}

decompiled/sources/com/google/firebase/perf/transport/RateLimiter.java

@@ -0,0 +1,209 @@
+package com.google.firebase.perf.transport;
+
+import android.content.Context;
+import com.google.firebase.perf.config.ConfigResolver;
+import com.google.firebase.perf.logging.AndroidLogger;
+import com.google.firebase.perf.util.Clock;
+import com.google.firebase.perf.util.Constants$TraceNames;
+import com.google.firebase.perf.util.Rate;
+import com.google.firebase.perf.util.Timer;
+import com.google.firebase.perf.util.Utils;
+import com.google.firebase.perf.v1.PerfMetric;
+import com.google.firebase.perf.v1.PerfSession;
+import com.google.firebase.perf.v1.SessionVerbosity;
+import com.unity3d.ads.core.domain.InitializeAndroidBoldSDK;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public final class RateLimiter {
+    public final ConfigResolver configResolver;
+    public final double fragmentBucketId;
+    public boolean isLogcatEnabled;
+    public RateLimiterImpl networkLimiter;
+    public final double samplingBucketId;
+    public RateLimiterImpl traceLimiter;
+
+    public RateLimiter(Context context, Rate rate, long j) {
+        this(rate, j, new Clock(), getSamplingBucketId(), getSamplingBucketId(), ConfigResolver.getInstance());
+        this.isLogcatEnabled = Utils.isDebugLoggingEnabled(context);
+    }
+
+    public static double getSamplingBucketId() {
+        return new Random().nextDouble();
+    }
+
+    public RateLimiter(Rate rate, long j, Clock clock, double d, double d2, ConfigResolver configResolver) {
+        this.traceLimiter = null;
+        this.networkLimiter = null;
+        boolean z = false;
+        this.isLogcatEnabled = false;
+        Utils.checkArgument(0.0d <= d && d < 1.0d, "Sampling bucket ID should be in range [0.0, 1.0).");
+        if (0.0d <= d2 && d2 < 1.0d) {
+            z = true;
+        }
+        Utils.checkArgument(z, "Fragment sampling bucket ID should be in range [0.0, 1.0).");
+        this.samplingBucketId = d;
+        this.fragmentBucketId = d2;
+        this.configResolver = configResolver;
+        this.traceLimiter = new RateLimiterImpl(rate, j, clock, configResolver, "Trace", this.isLogcatEnabled);
+        this.networkLimiter = new RateLimiterImpl(rate, j, clock, configResolver, InitializeAndroidBoldSDK.MSG_NETWORK, this.isLogcatEnabled);
+    }
+
+    public final boolean isDeviceAllowedToSendTraces() {
+        return this.samplingBucketId < this.configResolver.getTraceSamplingRate();
+    }
+
+    public final boolean isDeviceAllowedToSendNetworkEvents() {
+        return this.samplingBucketId < this.configResolver.getNetworkRequestSamplingRate();
+    }
+
+    public final boolean isDeviceAllowedToSendFragmentScreenTraces() {
+        return this.fragmentBucketId < this.configResolver.getFragmentSamplingRate();
+    }
+
+    public boolean isFragmentScreenTrace(PerfMetric perfMetric) {
+        return perfMetric.hasTraceMetric() && perfMetric.getTraceMetric().getName().startsWith("_st_") && perfMetric.getTraceMetric().containsCustomAttributes("Hosting_activity");
+    }
+
+    public boolean isEventRateLimited(PerfMetric perfMetric) {
+        if (!isRateLimitApplicable(perfMetric)) {
+            return false;
+        }
+        if (perfMetric.hasNetworkRequestMetric()) {
+            return !this.networkLimiter.check(perfMetric);
+        }
+        if (perfMetric.hasTraceMetric()) {
+            return !this.traceLimiter.check(perfMetric);
+        }
+        return true;
+    }
+
+    public boolean isEventSampled(PerfMetric perfMetric) {
+        if (perfMetric.hasTraceMetric() && !isDeviceAllowedToSendTraces() && !hasVerboseSessions(perfMetric.getTraceMetric().getPerfSessionsList())) {
+            return false;
+        }
+        if (!isFragmentScreenTrace(perfMetric) || isDeviceAllowedToSendFragmentScreenTraces() || hasVerboseSessions(perfMetric.getTraceMetric().getPerfSessionsList())) {
+            return !perfMetric.hasNetworkRequestMetric() || isDeviceAllowedToSendNetworkEvents() || hasVerboseSessions(perfMetric.getNetworkRequestMetric().getPerfSessionsList());
+        }
+        return false;
+    }
+
+    public final boolean hasVerboseSessions(List list) {
+        return list.size() > 0 && ((PerfSession) list.get(0)).getSessionVerbosityCount() > 0 && ((PerfSession) list.get(0)).getSessionVerbosity(0) == SessionVerbosity.GAUGES_AND_SYSTEM_EVENTS;
+    }
+
+    public boolean isRateLimitApplicable(PerfMetric perfMetric) {
+        return (!perfMetric.hasTraceMetric() || (!(perfMetric.getTraceMetric().getName().equals(Constants$TraceNames.FOREGROUND_TRACE_NAME.toString()) || perfMetric.getTraceMetric().getName().equals(Constants$TraceNames.BACKGROUND_TRACE_NAME.toString())) || perfMetric.getTraceMetric().getCountersCount() <= 0)) && !perfMetric.hasGaugeMetric();
+    }
+
+    public void changeRate(boolean z) {
+        this.traceLimiter.changeRate(z);
+        this.networkLimiter.changeRate(z);
+    }
+
+    public static class RateLimiterImpl {
+        public long backgroundCapacity;
+        public Rate backgroundRate;
+        public long capacity;
+        public final Clock clock;
+        public long foregroundCapacity;
+        public Rate foregroundRate;
+        public final boolean isLogcatEnabled;
+        public Timer lastTimeTokenReplenished;
+        public Rate rate;
+        public double tokenCount;
+        public static final AndroidLogger logger = AndroidLogger.getInstance();
+        public static final long MICROS_IN_A_SECOND = TimeUnit.SECONDS.toMicros(1);
+
+        public RateLimiterImpl(Rate rate, long j, Clock clock, ConfigResolver configResolver, String str, boolean z) {
+            this.clock = clock;
+            this.capacity = j;
+            this.rate = rate;
+            this.tokenCount = j;
+            this.lastTimeTokenReplenished = clock.getTime();
+            setRateByReadingRemoteConfigValues(configResolver, str, z);
+            this.isLogcatEnabled = z;
+        }
+
+        public synchronized boolean check(PerfMetric perfMetric) {
+            try {
+                Timer time = this.clock.getTime();
+                double durationMicros = (this.lastTimeTokenReplenished.getDurationMicros(time) * this.rate.getTokensPerSeconds()) / MICROS_IN_A_SECOND;
+                if (durationMicros > 0.0d) {
+                    this.tokenCount = Math.min(this.tokenCount + durationMicros, this.capacity);
+                    this.lastTimeTokenReplenished = time;
+                }
+                double d = this.tokenCount;
+                if (d >= 1.0d) {
+                    this.tokenCount = d - 1.0d;
+                    return true;
+                }
+                if (this.isLogcatEnabled) {
+                    logger.warn("Exceeded log rate limit, dropping the log.");
+                }
+                return false;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+
+        public synchronized void changeRate(boolean z) {
+            try {
+                this.rate = z ? this.foregroundRate : this.backgroundRate;
+                this.capacity = z ? this.foregroundCapacity : this.backgroundCapacity;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+
+        public final void setRateByReadingRemoteConfigValues(ConfigResolver configResolver, String str, boolean z) {
+            long flimitSec = getFlimitSec(configResolver, str);
+            long flimitEvents = getFlimitEvents(configResolver, str);
+            TimeUnit timeUnit = TimeUnit.SECONDS;
+            Rate rate = new Rate(flimitEvents, flimitSec, timeUnit);
+            this.foregroundRate = rate;
+            this.foregroundCapacity = flimitEvents;
+            if (z) {
+                logger.debug("Foreground %s logging rate:%f, burst capacity:%d", str, rate, Long.valueOf(flimitEvents));
+            }
+            long blimitSec = getBlimitSec(configResolver, str);
+            long blimitEvents = getBlimitEvents(configResolver, str);
+            Rate rate2 = new Rate(blimitEvents, blimitSec, timeUnit);
+            this.backgroundRate = rate2;
+            this.backgroundCapacity = blimitEvents;
+            if (z) {
+                logger.debug("Background %s logging rate:%f, capacity:%d", str, rate2, Long.valueOf(blimitEvents));
+            }
+        }
+
+        public static long getFlimitSec(ConfigResolver configResolver, String str) {
+            if (str == "Trace") {
+                return configResolver.getRateLimitSec();
+            }
+            return configResolver.getRateLimitSec();
+        }
+
+        public static long getFlimitEvents(ConfigResolver configResolver, String str) {
+            if (str == "Trace") {
+                return configResolver.getTraceEventCountForeground();
+            }
+            return configResolver.getNetworkEventCountForeground();
+        }
+
+        public static long getBlimitSec(ConfigResolver configResolver, String str) {
+            if (str == "Trace") {
+                return configResolver.getRateLimitSec();
+            }
+            return configResolver.getRateLimitSec();
+        }
+
+        public static long getBlimitEvents(ConfigResolver configResolver, String str) {
+            if (str == "Trace") {
+                return configResolver.getTraceEventCountBackground();
+            }
+            return configResolver.getNetworkEventCountBackground();
+        }
+    }
+}

decompiled/sources/com/google/firebase/perf/transport/TransportManager.java

@@ -0,0 +1,394 @@
+package com.google.firebase.perf.transport;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.perf.BuildConfig;
+import com.google.firebase.perf.FirebasePerformance;
+import com.google.firebase.perf.application.AppStateMonitor;
+import com.google.firebase.perf.config.ConfigResolver;
+import com.google.firebase.perf.logging.AndroidLogger;
+import com.google.firebase.perf.logging.ConsoleUrlGenerator;
+import com.google.firebase.perf.metrics.validator.PerfMetricValidator;
+import com.google.firebase.perf.session.SessionManager;
+import com.google.firebase.perf.util.Constants$CounterNames;
+import com.google.firebase.perf.util.Rate;
+import com.google.firebase.perf.v1.AndroidApplicationInfo;
+import com.google.firebase.perf.v1.ApplicationInfo;
+import com.google.firebase.perf.v1.ApplicationProcessState;
+import com.google.firebase.perf.v1.GaugeMetric;
+import com.google.firebase.perf.v1.NetworkRequestMetric;
+import com.google.firebase.perf.v1.PerfMetric;
+import com.google.firebase.perf.v1.PerfMetricOrBuilder;
+import com.google.firebase.perf.v1.TraceMetric;
+import java.lang.ref.WeakReference;
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes3.dex */
+public class TransportManager implements AppStateMonitor.AppStateCallback {
+    public Context appContext;
+    public AppStateMonitor appStateMonitor;
+    public ApplicationInfo.Builder applicationInfoBuilder;
+    public final Map cacheMap;
+    public ConfigResolver configResolver;
+    public FirebaseApp firebaseApp;
+    public FirebaseInstallationsApi firebaseInstallationsApi;
+    public FirebasePerformance firebasePerformance;
+    public FlgTransport flgTransport;
+    public Provider flgTransportFactoryProvider;
+    public String packageName;
+    public String projectId;
+    public RateLimiter rateLimiter;
+    public static final AndroidLogger logger = AndroidLogger.getInstance();
+    public static final TransportManager instance = new TransportManager();
+    public final ConcurrentLinkedQueue pendingEventsQueue = new ConcurrentLinkedQueue();
+    public final AtomicBoolean isTransportInitialized = new AtomicBoolean(false);
+    public boolean isForegroundState = false;
+    public ExecutorService executorService = new ThreadPoolExecutor(0, 1, 10, TimeUnit.SECONDS, new LinkedBlockingQueue());
+
+    public static TransportManager getInstance() {
+        return instance;
+    }
+
+    public TransportManager() {
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        this.cacheMap = concurrentHashMap;
+        concurrentHashMap.put("KEY_AVAILABLE_TRACES_FOR_CACHING", 50);
+        concurrentHashMap.put("KEY_AVAILABLE_NETWORK_REQUESTS_FOR_CACHING", 50);
+        concurrentHashMap.put("KEY_AVAILABLE_GAUGES_FOR_CACHING", 50);
+    }
+
+    public void initialize(FirebaseApp firebaseApp, FirebaseInstallationsApi firebaseInstallationsApi, Provider provider) {
+        this.firebaseApp = firebaseApp;
+        this.projectId = firebaseApp.getOptions().getProjectId();
+        this.firebaseInstallationsApi = firebaseInstallationsApi;
+        this.flgTransportFactoryProvider = provider;
+        this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda1
+            @Override // java.lang.Runnable
+            public final void run() {
+                TransportManager.this.syncInit();
+            }
+        });
+    }
+
+    public final void syncInit() {
+        Context applicationContext = this.firebaseApp.getApplicationContext();
+        this.appContext = applicationContext;
+        this.packageName = applicationContext.getPackageName();
+        this.configResolver = ConfigResolver.getInstance();
+        this.rateLimiter = new RateLimiter(this.appContext, new Rate(100L, 1L, TimeUnit.MINUTES), 500L);
+        this.appStateMonitor = AppStateMonitor.getInstance();
+        this.flgTransport = new FlgTransport(this.flgTransportFactoryProvider, this.configResolver.getAndCacheLogSourceName());
+        finishInitialization();
+    }
+
+    public final void finishInitialization() {
+        this.appStateMonitor.registerForAppState(new WeakReference(instance));
+        ApplicationInfo.Builder newBuilder = ApplicationInfo.newBuilder();
+        this.applicationInfoBuilder = newBuilder;
+        newBuilder.setGoogleAppId(this.firebaseApp.getOptions().getApplicationId()).setAndroidAppInfo(AndroidApplicationInfo.newBuilder().setPackageName(this.packageName).setSdkVersion(BuildConfig.FIREPERF_VERSION_NAME).setVersionName(getVersionName(this.appContext)));
+        this.isTransportInitialized.set(true);
+        while (!this.pendingEventsQueue.isEmpty()) {
+            final PendingPerfEvent pendingPerfEvent = (PendingPerfEvent) this.pendingEventsQueue.poll();
+            if (pendingPerfEvent != null) {
+                this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda5
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        TransportManager.this.lambda$finishInitialization$0(pendingPerfEvent);
+                    }
+                });
+            }
+        }
+    }
+
+    public final /* synthetic */ void lambda$finishInitialization$0(PendingPerfEvent pendingPerfEvent) {
+        syncLog(pendingPerfEvent.perfMetricBuilder, pendingPerfEvent.appState);
+    }
+
+    @Override // com.google.firebase.perf.application.AppStateMonitor.AppStateCallback
+    public void onUpdateAppState(ApplicationProcessState applicationProcessState) {
+        this.isForegroundState = applicationProcessState == ApplicationProcessState.FOREGROUND;
+        if (isInitialized()) {
+            this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda3
+                @Override // java.lang.Runnable
+                public final void run() {
+                    TransportManager.this.lambda$onUpdateAppState$1();
+                }
+            });
+        }
+    }
+
+    public final /* synthetic */ void lambda$onUpdateAppState$1() {
+        this.rateLimiter.changeRate(this.isForegroundState);
+    }
+
+    public boolean isInitialized() {
+        return this.isTransportInitialized.get();
+    }
+
+    public void log(final TraceMetric traceMetric, final ApplicationProcessState applicationProcessState) {
+        this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                TransportManager.this.lambda$log$2(traceMetric, applicationProcessState);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$log$2(TraceMetric traceMetric, ApplicationProcessState applicationProcessState) {
+        syncLog(PerfMetric.newBuilder().setTraceMetric(traceMetric), applicationProcessState);
+    }
+
+    public void log(final NetworkRequestMetric networkRequestMetric, final ApplicationProcessState applicationProcessState) {
+        this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda2
+            @Override // java.lang.Runnable
+            public final void run() {
+                TransportManager.this.lambda$log$3(networkRequestMetric, applicationProcessState);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$log$3(NetworkRequestMetric networkRequestMetric, ApplicationProcessState applicationProcessState) {
+        syncLog(PerfMetric.newBuilder().setNetworkRequestMetric(networkRequestMetric), applicationProcessState);
+    }
+
+    public void log(final GaugeMetric gaugeMetric, final ApplicationProcessState applicationProcessState) {
+        this.executorService.execute(new Runnable() { // from class: com.google.firebase.perf.transport.TransportManager$$ExternalSyntheticLambda4
+            @Override // java.lang.Runnable
+            public final void run() {
+                TransportManager.this.lambda$log$4(gaugeMetric, applicationProcessState);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$log$4(GaugeMetric gaugeMetric, ApplicationProcessState applicationProcessState) {
+        syncLog(PerfMetric.newBuilder().setGaugeMetric(gaugeMetric), applicationProcessState);
+    }
+
+    public final void syncLog(PerfMetric.Builder builder, ApplicationProcessState applicationProcessState) {
+        if (!isInitialized()) {
+            if (isAllowedToCache(builder)) {
+                logger.debug("Transport is not initialized yet, %s will be queued for to be dispatched later", getLogcatMsg(builder));
+                this.pendingEventsQueue.add(new PendingPerfEvent(builder, applicationProcessState));
+                return;
+            }
+            return;
+        }
+        PerfMetric applicationInfoAndBuild = setApplicationInfoAndBuild(builder, applicationProcessState);
+        if (isAllowedToDispatch(applicationInfoAndBuild)) {
+            dispatchLog(applicationInfoAndBuild);
+            SessionManager.getInstance().stopGaugeCollectionIfSessionRunningTooLong();
+        }
+    }
+
+    public final boolean isAllowedToCache(PerfMetricOrBuilder perfMetricOrBuilder) {
+        int intValue = ((Integer) this.cacheMap.get("KEY_AVAILABLE_TRACES_FOR_CACHING")).intValue();
+        int intValue2 = ((Integer) this.cacheMap.get("KEY_AVAILABLE_NETWORK_REQUESTS_FOR_CACHING")).intValue();
+        int intValue3 = ((Integer) this.cacheMap.get("KEY_AVAILABLE_GAUGES_FOR_CACHING")).intValue();
+        if (perfMetricOrBuilder.hasTraceMetric() && intValue > 0) {
+            this.cacheMap.put("KEY_AVAILABLE_TRACES_FOR_CACHING", Integer.valueOf(intValue - 1));
+            return true;
+        }
+        if (perfMetricOrBuilder.hasNetworkRequestMetric() && intValue2 > 0) {
+            this.cacheMap.put("KEY_AVAILABLE_NETWORK_REQUESTS_FOR_CACHING", Integer.valueOf(intValue2 - 1));
+            return true;
+        }
+        if (perfMetricOrBuilder.hasGaugeMetric() && intValue3 > 0) {
+            this.cacheMap.put("KEY_AVAILABLE_GAUGES_FOR_CACHING", Integer.valueOf(intValue3 - 1));
+            return true;
+        }
+        logger.debug("%s is not allowed to cache. Cache exhausted the limit (availableTracesForCaching: %d, availableNetworkRequestsForCaching: %d, availableGaugesForCaching: %d).", getLogcatMsg(perfMetricOrBuilder), Integer.valueOf(intValue), Integer.valueOf(intValue2), Integer.valueOf(intValue3));
+        return false;
+    }
+
+    public final boolean isAllowedToDispatch(PerfMetric perfMetric) {
+        if (!this.configResolver.isPerformanceMonitoringEnabled()) {
+            logger.info("Performance collection is not enabled, dropping %s", getLogcatMsg(perfMetric));
+            return false;
+        }
+        if (!perfMetric.getApplicationInfo().hasAppInstanceId()) {
+            logger.warn("App Instance ID is null or empty, dropping %s", getLogcatMsg(perfMetric));
+            return false;
+        }
+        if (!PerfMetricValidator.isValid(perfMetric, this.appContext)) {
+            logger.warn("Unable to process the PerfMetric (%s) due to missing or invalid values. See earlier log statements for additional information on the specific missing/invalid values.", getLogcatMsg(perfMetric));
+            return false;
+        }
+        if (!this.rateLimiter.isEventSampled(perfMetric)) {
+            incrementDropCount(perfMetric);
+            logger.info("Event dropped due to device sampling - %s", getLogcatMsg(perfMetric));
+            return false;
+        }
+        if (!this.rateLimiter.isEventRateLimited(perfMetric)) {
+            return true;
+        }
+        incrementDropCount(perfMetric);
+        logger.info("Rate limited (per device) - %s", getLogcatMsg(perfMetric));
+        return false;
+    }
+
+    public final void dispatchLog(PerfMetric perfMetric) {
+        if (perfMetric.hasTraceMetric()) {
+            logger.info("Logging %s. In a minute, visit the Firebase console to view your data: %s", getLogcatMsg(perfMetric), getConsoleUrl(perfMetric.getTraceMetric()));
+        } else {
+            logger.info("Logging %s", getLogcatMsg(perfMetric));
+        }
+        this.flgTransport.log(perfMetric);
+    }
+
+    public static String getVersionName(Context context) {
+        try {
+            String str = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
+            return str == null ? "" : str;
+        } catch (PackageManager.NameNotFoundException unused) {
+            return "";
+        }
+    }
+
+    public final PerfMetric setApplicationInfoAndBuild(PerfMetric.Builder builder, ApplicationProcessState applicationProcessState) {
+        updateFirebaseInstallationIdIfPossibleAndNeeded();
+        ApplicationInfo.Builder applicationProcessState2 = this.applicationInfoBuilder.setApplicationProcessState(applicationProcessState);
+        if (builder.hasTraceMetric() || builder.hasNetworkRequestMetric()) {
+            applicationProcessState2 = ((ApplicationInfo.Builder) applicationProcessState2.mo856clone()).putAllCustomAttributes(getGlobalCustomAttributes());
+        }
+        return (PerfMetric) builder.setApplicationInfo(applicationProcessState2).build();
+    }
+
+    public final Map getGlobalCustomAttributes() {
+        updateFirebasePerformanceIfPossibleAndNeeded();
+        FirebasePerformance firebasePerformance = this.firebasePerformance;
+        if (firebasePerformance != null) {
+            return firebasePerformance.getAttributes();
+        }
+        return Collections.emptyMap();
+    }
+
+    public final void updateFirebasePerformanceIfPossibleAndNeeded() {
+        if (this.firebasePerformance == null && isInitialized()) {
+            this.firebasePerformance = FirebasePerformance.getInstance();
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:13:0x0063  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0069  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void updateFirebaseInstallationIdIfPossibleAndNeeded() {
+        /*
+            r4 = this;
+            com.google.firebase.perf.config.ConfigResolver r0 = r4.configResolver
+            boolean r0 = r0.isPerformanceMonitoringEnabled()
+            if (r0 == 0) goto L70
+            com.google.firebase.perf.v1.ApplicationInfo$Builder r0 = r4.applicationInfoBuilder
+            boolean r0 = r0.hasAppInstanceId()
+            if (r0 == 0) goto L15
+            boolean r0 = r4.isForegroundState
+            if (r0 != 0) goto L15
+            return
+        L15:
+            com.google.firebase.installations.FirebaseInstallationsApi r0 = r4.firebaseInstallationsApi     // Catch: java.util.concurrent.TimeoutException -> L27 java.lang.InterruptedException -> L29 java.util.concurrent.ExecutionException -> L2b
+            com.google.android.gms.tasks.Task r0 = r0.getId()     // Catch: java.util.concurrent.TimeoutException -> L27 java.lang.InterruptedException -> L29 java.util.concurrent.ExecutionException -> L2b
+            java.util.concurrent.TimeUnit r1 = java.util.concurrent.TimeUnit.MILLISECONDS     // Catch: java.util.concurrent.TimeoutException -> L27 java.lang.InterruptedException -> L29 java.util.concurrent.ExecutionException -> L2b
+            r2 = 60000(0xea60, double:2.9644E-319)
+            java.lang.Object r0 = com.google.android.gms.tasks.Tasks.await(r0, r2, r1)     // Catch: java.util.concurrent.TimeoutException -> L27 java.lang.InterruptedException -> L29 java.util.concurrent.ExecutionException -> L2b
+            java.lang.String r0 = (java.lang.String) r0     // Catch: java.util.concurrent.TimeoutException -> L27 java.lang.InterruptedException -> L29 java.util.concurrent.ExecutionException -> L2b
+            goto L5d
+        L27:
+            r0 = move-exception
+            goto L2d
+        L29:
+            r0 = move-exception
+            goto L3d
+        L2b:
+            r0 = move-exception
+            goto L4d
+        L2d:
+            com.google.firebase.perf.logging.AndroidLogger r1 = com.google.firebase.perf.transport.TransportManager.logger
+            java.lang.String r0 = r0.getMessage()
+            java.lang.Object[] r0 = new java.lang.Object[]{r0}
+            java.lang.String r2 = "Task to retrieve Installation Id is timed out: %s"
+            r1.error(r2, r0)
+            goto L5c
+        L3d:
+            com.google.firebase.perf.logging.AndroidLogger r1 = com.google.firebase.perf.transport.TransportManager.logger
+            java.lang.String r0 = r0.getMessage()
+            java.lang.Object[] r0 = new java.lang.Object[]{r0}
+            java.lang.String r2 = "Task to retrieve Installation Id is interrupted: %s"
+            r1.error(r2, r0)
+            goto L5c
+        L4d:
+            com.google.firebase.perf.logging.AndroidLogger r1 = com.google.firebase.perf.transport.TransportManager.logger
+            java.lang.String r0 = r0.getMessage()
+            java.lang.Object[] r0 = new java.lang.Object[]{r0}
+            java.lang.String r2 = "Unable to retrieve Installation Id: %s"
+            r1.error(r2, r0)
+        L5c:
+            r0 = 0
+        L5d:
+            boolean r1 = android.text.TextUtils.isEmpty(r0)
+            if (r1 != 0) goto L69
+            com.google.firebase.perf.v1.ApplicationInfo$Builder r1 = r4.applicationInfoBuilder
+            r1.setAppInstanceId(r0)
+            goto L70
+        L69:
+            com.google.firebase.perf.logging.AndroidLogger r0 = com.google.firebase.perf.transport.TransportManager.logger
+            java.lang.String r1 = "Firebase Installation Id is empty, contact Firebase Support for debugging."
+            r0.warn(r1)
+        L70:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.perf.transport.TransportManager.updateFirebaseInstallationIdIfPossibleAndNeeded():void");
+    }
+
+    public final void incrementDropCount(PerfMetric perfMetric) {
+        if (perfMetric.hasTraceMetric()) {
+            this.appStateMonitor.incrementCount(Constants$CounterNames.TRACE_EVENT_RATE_LIMITED.toString(), 1L);
+        } else if (perfMetric.hasNetworkRequestMetric()) {
+            this.appStateMonitor.incrementCount(Constants$CounterNames.NETWORK_TRACE_EVENT_RATE_LIMITED.toString(), 1L);
+        }
+    }
+
+    public static String getLogcatMsg(PerfMetricOrBuilder perfMetricOrBuilder) {
+        if (perfMetricOrBuilder.hasTraceMetric()) {
+            return getLogcatMsg(perfMetricOrBuilder.getTraceMetric());
+        }
+        if (perfMetricOrBuilder.hasNetworkRequestMetric()) {
+            return getLogcatMsg(perfMetricOrBuilder.getNetworkRequestMetric());
+        }
+        return perfMetricOrBuilder.hasGaugeMetric() ? getLogcatMsg(perfMetricOrBuilder.getGaugeMetric()) : "log";
+    }
+
+    public static String getLogcatMsg(TraceMetric traceMetric) {
+        return String.format(Locale.ENGLISH, "trace metric: %s (duration: %sms)", traceMetric.getName(), new DecimalFormat("#.####").format(traceMetric.getDurationUs() / 1000.0d));
+    }
+
+    public static String getLogcatMsg(NetworkRequestMetric networkRequestMetric) {
+        return String.format(Locale.ENGLISH, "network request trace: %s (responseCode: %s, responseTime: %sms)", networkRequestMetric.getUrl(), networkRequestMetric.hasHttpResponseCode() ? String.valueOf(networkRequestMetric.getHttpResponseCode()) : "UNKNOWN", new DecimalFormat("#.####").format((networkRequestMetric.hasTimeToResponseCompletedUs() ? networkRequestMetric.getTimeToResponseCompletedUs() : 0L) / 1000.0d));
+    }
+
+    public static String getLogcatMsg(GaugeMetric gaugeMetric) {
+        return String.format(Locale.ENGLISH, "gauges (hasMetadata: %b, cpuGaugeCount: %d, memoryGaugeCount: %d)", Boolean.valueOf(gaugeMetric.hasGaugeMetadata()), Integer.valueOf(gaugeMetric.getCpuMetricReadingsCount()), Integer.valueOf(gaugeMetric.getAndroidMemoryReadingsCount()));
+    }
+
+    public final String getConsoleUrl(TraceMetric traceMetric) {
+        String name = traceMetric.getName();
+        if (name.startsWith("_st_")) {
+            return ConsoleUrlGenerator.generateScreenTraceUrl(this.projectId, this.packageName, name);
+        }
+        return ConsoleUrlGenerator.generateCustomTraceUrl(this.projectId, this.packageName, name);
+    }
+}