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/messaging/AutoProtoEncoderDoNotUseEncoder.java

@@ -0,0 +1,88 @@
+package com.google.firebase.messaging;
+
+import androidx.core.app.NotificationCompat;
+import com.amazonaws.handlers.HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0;
+import com.google.firebase.encoders.FieldDescriptor;
+import com.google.firebase.encoders.ObjectEncoder;
+import com.google.firebase.encoders.ObjectEncoderContext;
+import com.google.firebase.encoders.config.Configurator;
+import com.google.firebase.encoders.config.EncoderConfig;
+import com.google.firebase.encoders.proto.AtProtobuf;
+import com.google.firebase.messaging.reporting.MessagingClientEvent;
+import com.google.firebase.messaging.reporting.MessagingClientEventExtension;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+
+/* loaded from: classes3.dex */
+public final class AutoProtoEncoderDoNotUseEncoder implements Configurator {
+    public static final Configurator CONFIG = new AutoProtoEncoderDoNotUseEncoder();
+
+    @Override // com.google.firebase.encoders.config.Configurator
+    public void configure(EncoderConfig encoderConfig) {
+        encoderConfig.registerEncoder(ProtoEncoderDoNotUse.class, ProtoEncoderDoNotUseEncoder.INSTANCE);
+        encoderConfig.registerEncoder(MessagingClientEventExtension.class, MessagingClientEventExtensionEncoder.INSTANCE);
+        encoderConfig.registerEncoder(MessagingClientEvent.class, MessagingClientEventEncoder.INSTANCE);
+    }
+
+    public static final class ProtoEncoderDoNotUseEncoder implements ObjectEncoder {
+        public static final ProtoEncoderDoNotUseEncoder INSTANCE = new ProtoEncoderDoNotUseEncoder();
+        public static final FieldDescriptor MESSAGINGCLIENTEVENTEXTENSION_DESCRIPTOR = FieldDescriptor.of("messagingClientEventExtension");
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public /* bridge */ /* synthetic */ void encode(Object obj, Object obj2) {
+            HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0.m(obj);
+            encode((ProtoEncoderDoNotUse) null, (ObjectEncoderContext) obj2);
+        }
+
+        public void encode(ProtoEncoderDoNotUse protoEncoderDoNotUse, ObjectEncoderContext objectEncoderContext) {
+            throw null;
+        }
+    }
+
+    public static final class MessagingClientEventExtensionEncoder implements ObjectEncoder {
+        public static final MessagingClientEventExtensionEncoder INSTANCE = new MessagingClientEventExtensionEncoder();
+        public static final FieldDescriptor MESSAGINGCLIENTEVENT_DESCRIPTOR = FieldDescriptor.builder("messagingClientEvent").withProperty(AtProtobuf.builder().tag(1).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(MessagingClientEventExtension messagingClientEventExtension, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(MESSAGINGCLIENTEVENT_DESCRIPTOR, messagingClientEventExtension.getMessagingClientEventInternal());
+        }
+    }
+
+    public static final class MessagingClientEventEncoder implements ObjectEncoder {
+        public static final MessagingClientEventEncoder INSTANCE = new MessagingClientEventEncoder();
+        public static final FieldDescriptor PROJECTNUMBER_DESCRIPTOR = FieldDescriptor.builder("projectNumber").withProperty(AtProtobuf.builder().tag(1).build()).build();
+        public static final FieldDescriptor MESSAGEID_DESCRIPTOR = FieldDescriptor.builder("messageId").withProperty(AtProtobuf.builder().tag(2).build()).build();
+        public static final FieldDescriptor INSTANCEID_DESCRIPTOR = FieldDescriptor.builder("instanceId").withProperty(AtProtobuf.builder().tag(3).build()).build();
+        public static final FieldDescriptor MESSAGETYPE_DESCRIPTOR = FieldDescriptor.builder("messageType").withProperty(AtProtobuf.builder().tag(4).build()).build();
+        public static final FieldDescriptor SDKPLATFORM_DESCRIPTOR = FieldDescriptor.builder("sdkPlatform").withProperty(AtProtobuf.builder().tag(5).build()).build();
+        public static final FieldDescriptor PACKAGENAME_DESCRIPTOR = FieldDescriptor.builder(HandleInvocationsFromAdViewer.KEY_PACKAGE_NAME).withProperty(AtProtobuf.builder().tag(6).build()).build();
+        public static final FieldDescriptor COLLAPSEKEY_DESCRIPTOR = FieldDescriptor.builder("collapseKey").withProperty(AtProtobuf.builder().tag(7).build()).build();
+        public static final FieldDescriptor PRIORITY_DESCRIPTOR = FieldDescriptor.builder(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY).withProperty(AtProtobuf.builder().tag(8).build()).build();
+        public static final FieldDescriptor TTL_DESCRIPTOR = FieldDescriptor.builder("ttl").withProperty(AtProtobuf.builder().tag(9).build()).build();
+        public static final FieldDescriptor TOPIC_DESCRIPTOR = FieldDescriptor.builder("topic").withProperty(AtProtobuf.builder().tag(10).build()).build();
+        public static final FieldDescriptor BULKID_DESCRIPTOR = FieldDescriptor.builder("bulkId").withProperty(AtProtobuf.builder().tag(11).build()).build();
+        public static final FieldDescriptor EVENT_DESCRIPTOR = FieldDescriptor.builder(NotificationCompat.CATEGORY_EVENT).withProperty(AtProtobuf.builder().tag(12).build()).build();
+        public static final FieldDescriptor ANALYTICSLABEL_DESCRIPTOR = FieldDescriptor.builder("analyticsLabel").withProperty(AtProtobuf.builder().tag(13).build()).build();
+        public static final FieldDescriptor CAMPAIGNID_DESCRIPTOR = FieldDescriptor.builder("campaignId").withProperty(AtProtobuf.builder().tag(14).build()).build();
+        public static final FieldDescriptor COMPOSERLABEL_DESCRIPTOR = FieldDescriptor.builder("composerLabel").withProperty(AtProtobuf.builder().tag(15).build()).build();
+
+        @Override // com.google.firebase.encoders.ObjectEncoder
+        public void encode(MessagingClientEvent messagingClientEvent, ObjectEncoderContext objectEncoderContext) {
+            objectEncoderContext.add(PROJECTNUMBER_DESCRIPTOR, messagingClientEvent.getProjectNumber());
+            objectEncoderContext.add(MESSAGEID_DESCRIPTOR, messagingClientEvent.getMessageId());
+            objectEncoderContext.add(INSTANCEID_DESCRIPTOR, messagingClientEvent.getInstanceId());
+            objectEncoderContext.add(MESSAGETYPE_DESCRIPTOR, messagingClientEvent.getMessageType());
+            objectEncoderContext.add(SDKPLATFORM_DESCRIPTOR, messagingClientEvent.getSdkPlatform());
+            objectEncoderContext.add(PACKAGENAME_DESCRIPTOR, messagingClientEvent.getPackageName());
+            objectEncoderContext.add(COLLAPSEKEY_DESCRIPTOR, messagingClientEvent.getCollapseKey());
+            objectEncoderContext.add(PRIORITY_DESCRIPTOR, messagingClientEvent.getPriority());
+            objectEncoderContext.add(TTL_DESCRIPTOR, messagingClientEvent.getTtl());
+            objectEncoderContext.add(TOPIC_DESCRIPTOR, messagingClientEvent.getTopic());
+            objectEncoderContext.add(BULKID_DESCRIPTOR, messagingClientEvent.getBulkId());
+            objectEncoderContext.add(EVENT_DESCRIPTOR, messagingClientEvent.getEvent());
+            objectEncoderContext.add(ANALYTICSLABEL_DESCRIPTOR, messagingClientEvent.getAnalyticsLabel());
+            objectEncoderContext.add(CAMPAIGNID_DESCRIPTOR, messagingClientEvent.getCampaignId());
+            objectEncoderContext.add(COMPOSERLABEL_DESCRIPTOR, messagingClientEvent.getComposerLabel());
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/ByteStreams.java

@@ -0,0 +1,137 @@
+package com.google.firebase.messaging;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/* loaded from: classes3.dex */
+public abstract class ByteStreams {
+    public static int saturatedCast(long j) {
+        if (j > 2147483647L) {
+            return Integer.MAX_VALUE;
+        }
+        if (j < -2147483648L) {
+            return Integer.MIN_VALUE;
+        }
+        return (int) j;
+    }
+
+    public static byte[] toByteArrayInternal(InputStream inputStream, Queue queue, int i) {
+        int min = Math.min(8192, Math.max(128, Integer.highestOneBit(i) * 2));
+        while (i < 2147483639) {
+            int min2 = Math.min(min, 2147483639 - i);
+            byte[] bArr = new byte[min2];
+            queue.add(bArr);
+            int i2 = 0;
+            while (i2 < min2) {
+                int read = inputStream.read(bArr, i2, min2 - i2);
+                if (read == -1) {
+                    return combineBuffers(queue, i);
+                }
+                i2 += read;
+                i += read;
+            }
+            min = saturatedCast(min * (min < 4096 ? 4 : 2));
+        }
+        if (inputStream.read() == -1) {
+            return combineBuffers(queue, 2147483639);
+        }
+        throw new OutOfMemoryError("input is too large to fit in a byte array");
+    }
+
+    public static byte[] combineBuffers(Queue queue, int i) {
+        if (queue.isEmpty()) {
+            return new byte[0];
+        }
+        byte[] bArr = (byte[]) queue.remove();
+        if (bArr.length == i) {
+            return bArr;
+        }
+        int length = i - bArr.length;
+        byte[] copyOf = Arrays.copyOf(bArr, i);
+        while (length > 0) {
+            byte[] bArr2 = (byte[]) queue.remove();
+            int min = Math.min(length, bArr2.length);
+            System.arraycopy(bArr2, 0, copyOf, i - length, min);
+            length -= min;
+        }
+        return copyOf;
+    }
+
+    public static byte[] toByteArray(InputStream inputStream) {
+        return toByteArrayInternal(inputStream, new ArrayDeque(20), 0);
+    }
+
+    public static InputStream limit(InputStream inputStream, long j) {
+        return new LimitedInputStream(inputStream, j);
+    }
+
+    public static final class LimitedInputStream extends FilterInputStream {
+        public long left;
+        public long mark;
+
+        public LimitedInputStream(InputStream inputStream, long j) {
+            super(inputStream);
+            this.mark = -1L;
+            this.left = j;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int available() {
+            return (int) Math.min(((FilterInputStream) this).in.available(), this.left);
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public synchronized void mark(int i) {
+            ((FilterInputStream) this).in.mark(i);
+            this.mark = this.left;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int read() {
+            if (this.left == 0) {
+                return -1;
+            }
+            int read = ((FilterInputStream) this).in.read();
+            if (read != -1) {
+                this.left--;
+            }
+            return read;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int read(byte[] bArr, int i, int i2) {
+            long j = this.left;
+            if (j == 0) {
+                return -1;
+            }
+            int read = ((FilterInputStream) this).in.read(bArr, i, (int) Math.min(i2, j));
+            if (read != -1) {
+                this.left -= read;
+            }
+            return read;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public synchronized void reset() {
+            if (!((FilterInputStream) this).in.markSupported()) {
+                throw new IOException("Mark not supported");
+            }
+            if (this.mark == -1) {
+                throw new IOException("Mark not set");
+            }
+            ((FilterInputStream) this).in.reset();
+            this.left = this.mark;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public long skip(long j) {
+            long skip = ((FilterInputStream) this).in.skip(Math.min(j, this.left));
+            this.left -= skip;
+            return skip;
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/CommonNotificationBuilder.java

@@ -0,0 +1,314 @@
+package com.google.firebase.messaging;
+
+import android.R;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.Color;
+import android.graphics.drawable.AdaptiveIconDrawable;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.core.app.NotificationCompat;
+import androidx.core.content.ContextCompat;
+import androidx.core.view.accessibility.AccessibilityEventCompat;
+import com.google.android.gms.cloudmessaging.CloudMessagingReceiver;
+import com.google.android.gms.drive.DriveFile;
+import com.mbridge.msdk.newreward.player.view.hybrid.util.MRAIDCommunicatorUtil;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes3.dex */
+public abstract class CommonNotificationBuilder {
+    public static final AtomicInteger requestCodeProvider = new AtomicInteger((int) SystemClock.elapsedRealtime());
+
+    public static int getPendingIntentFlags(int i) {
+        return i | AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL;
+    }
+
+    public static DisplayNotificationInfo createNotificationInfo(Context context, NotificationParams notificationParams) {
+        Bundle manifestMetadata = getManifestMetadata(context.getPackageManager(), context.getPackageName());
+        return createNotificationInfo(context, context, notificationParams, getOrCreateChannel(context, notificationParams.getNotificationChannelId(), manifestMetadata), manifestMetadata);
+    }
+
+    public static DisplayNotificationInfo createNotificationInfo(Context context, Context context2, NotificationParams notificationParams, String str, Bundle bundle) {
+        String packageName = context2.getPackageName();
+        Resources resources = context2.getResources();
+        PackageManager packageManager = context2.getPackageManager();
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context2, str);
+        String possiblyLocalizedString = notificationParams.getPossiblyLocalizedString(resources, packageName, "gcm.n.title");
+        if (!TextUtils.isEmpty(possiblyLocalizedString)) {
+            builder.setContentTitle(possiblyLocalizedString);
+        }
+        String possiblyLocalizedString2 = notificationParams.getPossiblyLocalizedString(resources, packageName, "gcm.n.body");
+        if (!TextUtils.isEmpty(possiblyLocalizedString2)) {
+            builder.setContentText(possiblyLocalizedString2);
+            builder.setStyle(new NotificationCompat.BigTextStyle().bigText(possiblyLocalizedString2));
+        }
+        builder.setSmallIcon(getSmallIcon(packageManager, resources, packageName, notificationParams.getString("gcm.n.icon"), bundle));
+        Uri sound = getSound(packageName, notificationParams, resources);
+        if (sound != null) {
+            builder.setSound(sound);
+        }
+        builder.setContentIntent(createContentIntent(context, notificationParams, packageName, packageManager));
+        PendingIntent createDeleteIntent = createDeleteIntent(context, context2, notificationParams);
+        if (createDeleteIntent != null) {
+            builder.setDeleteIntent(createDeleteIntent);
+        }
+        Integer color = getColor(context2, notificationParams.getString("gcm.n.color"), bundle);
+        if (color != null) {
+            builder.setColor(color.intValue());
+        }
+        builder.setAutoCancel(!notificationParams.getBoolean("gcm.n.sticky"));
+        builder.setLocalOnly(notificationParams.getBoolean("gcm.n.local_only"));
+        String string = notificationParams.getString("gcm.n.ticker");
+        if (string != null) {
+            builder.setTicker(string);
+        }
+        Integer notificationPriority = notificationParams.getNotificationPriority();
+        if (notificationPriority != null) {
+            builder.setPriority(notificationPriority.intValue());
+        }
+        Integer visibility = notificationParams.getVisibility();
+        if (visibility != null) {
+            builder.setVisibility(visibility.intValue());
+        }
+        Integer notificationCount = notificationParams.getNotificationCount();
+        if (notificationCount != null) {
+            builder.setNumber(notificationCount.intValue());
+        }
+        Long l = notificationParams.getLong("gcm.n.event_time");
+        if (l != null) {
+            builder.setShowWhen(true);
+            builder.setWhen(l.longValue());
+        }
+        long[] vibrateTimings = notificationParams.getVibrateTimings();
+        if (vibrateTimings != null) {
+            builder.setVibrate(vibrateTimings);
+        }
+        int[] lightSettings = notificationParams.getLightSettings();
+        if (lightSettings != null) {
+            builder.setLights(lightSettings[0], lightSettings[1], lightSettings[2]);
+        }
+        builder.setDefaults(getConsolidatedDefaults(notificationParams));
+        return new DisplayNotificationInfo(builder, getTag(notificationParams), 0);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v2, types: [int] */
+    /* JADX WARN: Type inference failed for: r0v6 */
+    /* JADX WARN: Type inference failed for: r0v7 */
+    public static int getConsolidatedDefaults(NotificationParams notificationParams) {
+        boolean z = notificationParams.getBoolean("gcm.n.default_sound");
+        ?? r0 = z;
+        if (notificationParams.getBoolean("gcm.n.default_vibrate_timings")) {
+            r0 = (z ? 1 : 0) | 2;
+        }
+        return notificationParams.getBoolean("gcm.n.default_light_settings") ? r0 | 4 : r0;
+    }
+
+    public static boolean isValidIcon(Resources resources, int i) {
+        if (Build.VERSION.SDK_INT != 26) {
+            return true;
+        }
+        try {
+            if (!(resources.getDrawable(i, null) instanceof AdaptiveIconDrawable)) {
+                return true;
+            }
+            Log.e("FirebaseMessaging", "Adaptive icons cannot be used in notifications. Ignoring icon id: " + i);
+            return false;
+        } catch (Resources.NotFoundException unused) {
+            Log.e("FirebaseMessaging", "Couldn't find resource " + i + ", treating it as an invalid icon");
+            return false;
+        }
+    }
+
+    public static int getSmallIcon(PackageManager packageManager, Resources resources, String str, String str2, Bundle bundle) {
+        if (!TextUtils.isEmpty(str2)) {
+            int identifier = resources.getIdentifier(str2, "drawable", str);
+            if (identifier != 0 && isValidIcon(resources, identifier)) {
+                return identifier;
+            }
+            int identifier2 = resources.getIdentifier(str2, "mipmap", str);
+            if (identifier2 != 0 && isValidIcon(resources, identifier2)) {
+                return identifier2;
+            }
+            Log.w("FirebaseMessaging", "Icon resource " + str2 + " not found. Notification will use default icon.");
+        }
+        int i = bundle.getInt("com.google.firebase.messaging.default_notification_icon", 0);
+        if (i == 0 || !isValidIcon(resources, i)) {
+            try {
+                i = packageManager.getApplicationInfo(str, 0).icon;
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.w("FirebaseMessaging", "Couldn't get own application info: " + e);
+            }
+        }
+        return (i == 0 || !isValidIcon(resources, i)) ? R.drawable.sym_def_app_icon : i;
+    }
+
+    public static Integer getColor(Context context, String str, Bundle bundle) {
+        if (!TextUtils.isEmpty(str)) {
+            try {
+                return Integer.valueOf(Color.parseColor(str));
+            } catch (IllegalArgumentException unused) {
+                Log.w("FirebaseMessaging", "Color is invalid: " + str + ". Notification will use default color.");
+            }
+        }
+        int i = bundle.getInt("com.google.firebase.messaging.default_notification_color", 0);
+        if (i == 0) {
+            return null;
+        }
+        try {
+            return Integer.valueOf(ContextCompat.getColor(context, i));
+        } catch (Resources.NotFoundException unused2) {
+            Log.w("FirebaseMessaging", "Cannot find the color resource referenced in AndroidManifest.");
+            return null;
+        }
+    }
+
+    public static Uri getSound(String str, NotificationParams notificationParams, Resources resources) {
+        String soundResourceName = notificationParams.getSoundResourceName();
+        if (TextUtils.isEmpty(soundResourceName)) {
+            return null;
+        }
+        if (!MRAIDCommunicatorUtil.STATES_DEFAULT.equals(soundResourceName) && resources.getIdentifier(soundResourceName, "raw", str) != 0) {
+            return Uri.parse("android.resource://" + str + "/raw/" + soundResourceName);
+        }
+        return RingtoneManager.getDefaultUri(2);
+    }
+
+    public static PendingIntent createContentIntent(Context context, NotificationParams notificationParams, String str, PackageManager packageManager) {
+        Intent createTargetIntent = createTargetIntent(str, notificationParams, packageManager);
+        if (createTargetIntent == null) {
+            return null;
+        }
+        createTargetIntent.addFlags(AccessibilityEventCompat.TYPE_VIEW_TARGETED_BY_SCROLL);
+        createTargetIntent.putExtras(notificationParams.paramsWithReservedKeysRemoved());
+        if (shouldUploadMetrics(notificationParams)) {
+            createTargetIntent.putExtra("gcm.n.analytics_data", notificationParams.paramsForAnalyticsIntent());
+        }
+        return PendingIntent.getActivity(context, generatePendingIntentRequestCode(), createTargetIntent, getPendingIntentFlags(1073741824));
+    }
+
+    public static Intent createTargetIntent(String str, NotificationParams notificationParams, PackageManager packageManager) {
+        String string = notificationParams.getString("gcm.n.click_action");
+        if (!TextUtils.isEmpty(string)) {
+            Intent intent = new Intent(string);
+            intent.setPackage(str);
+            intent.setFlags(DriveFile.MODE_READ_ONLY);
+            return intent;
+        }
+        Uri link = notificationParams.getLink();
+        if (link != null) {
+            Intent intent2 = new Intent("android.intent.action.VIEW");
+            intent2.setPackage(str);
+            intent2.setData(link);
+            return intent2;
+        }
+        Intent launchIntentForPackage = packageManager.getLaunchIntentForPackage(str);
+        if (launchIntentForPackage == null) {
+            Log.w("FirebaseMessaging", "No activity found to launch app");
+        }
+        return launchIntentForPackage;
+    }
+
+    public static Bundle getManifestMetadata(PackageManager packageManager, String str) {
+        try {
+            ApplicationInfo applicationInfo = packageManager.getApplicationInfo(str, 128);
+            if (applicationInfo != null) {
+                Bundle bundle = applicationInfo.metaData;
+                if (bundle != null) {
+                    return bundle;
+                }
+            }
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.w("FirebaseMessaging", "Couldn't get own application info: " + e);
+        }
+        return Bundle.EMPTY;
+    }
+
+    public static String getOrCreateChannel(Context context, String str, Bundle bundle) {
+        String string;
+        try {
+            if (context.getPackageManager().getApplicationInfo(context.getPackageName(), 0).targetSdkVersion < 26) {
+                return null;
+            }
+            NotificationManager notificationManager = (NotificationManager) context.getSystemService(NotificationManager.class);
+            if (!TextUtils.isEmpty(str)) {
+                if (notificationManager.getNotificationChannel(str) != null) {
+                    return str;
+                }
+                Log.w("FirebaseMessaging", "Notification Channel requested (" + str + ") has not been created by the app. Manifest configuration, or default, value will be used.");
+            }
+            String string2 = bundle.getString("com.google.firebase.messaging.default_notification_channel_id");
+            if (!TextUtils.isEmpty(string2)) {
+                if (notificationManager.getNotificationChannel(string2) != null) {
+                    return string2;
+                }
+                Log.w("FirebaseMessaging", "Notification Channel set in AndroidManifest.xml has not been created by the app. Default value will be used.");
+            } else {
+                Log.w("FirebaseMessaging", "Missing Default Notification Channel metadata in AndroidManifest. Default value will be used.");
+            }
+            if (notificationManager.getNotificationChannel("fcm_fallback_notification_channel") == null) {
+                int identifier = context.getResources().getIdentifier("fcm_fallback_notification_channel_label", "string", context.getPackageName());
+                if (identifier == 0) {
+                    Log.e("FirebaseMessaging", "String resource \"fcm_fallback_notification_channel_label\" is not found. Using default string channel name.");
+                    string = "Misc";
+                } else {
+                    string = context.getString(identifier);
+                }
+                notificationManager.createNotificationChannel(new NotificationChannel("fcm_fallback_notification_channel", string, 3));
+            }
+            return "fcm_fallback_notification_channel";
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    public static int generatePendingIntentRequestCode() {
+        return requestCodeProvider.incrementAndGet();
+    }
+
+    public static PendingIntent createDeleteIntent(Context context, Context context2, NotificationParams notificationParams) {
+        if (shouldUploadMetrics(notificationParams)) {
+            return createMessagingPendingIntent(context, context2, new Intent(CloudMessagingReceiver.IntentActionKeys.NOTIFICATION_DISMISS).putExtras(notificationParams.paramsForAnalyticsIntent()));
+        }
+        return null;
+    }
+
+    public static PendingIntent createMessagingPendingIntent(Context context, Context context2, Intent intent) {
+        return PendingIntent.getBroadcast(context, generatePendingIntentRequestCode(), new Intent("com.google.android.c2dm.intent.RECEIVE").setPackage(context2.getPackageName()).putExtra(CloudMessagingReceiver.IntentKeys.WRAPPED_INTENT, intent), getPendingIntentFlags(1073741824));
+    }
+
+    public static boolean shouldUploadMetrics(NotificationParams notificationParams) {
+        return notificationParams.getBoolean("google.c.a.e");
+    }
+
+    public static String getTag(NotificationParams notificationParams) {
+        String string = notificationParams.getString("gcm.n.tag");
+        if (!TextUtils.isEmpty(string)) {
+            return string;
+        }
+        return "FCM-Notification:" + SystemClock.uptimeMillis();
+    }
+
+    public static class DisplayNotificationInfo {
+        public final int id;
+        public final NotificationCompat.Builder notificationBuilder;
+        public final String tag;
+
+        public DisplayNotificationInfo(NotificationCompat.Builder builder, String str, int i) {
+            this.notificationBuilder = builder;
+            this.tag = str;
+            this.id = i;
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/Constants.java

@@ -0,0 +1,27 @@
+package com.google.firebase.messaging;
+
+import android.os.Bundle;
+import androidx.collection.ArrayMap;
+import com.ea.eadp.pushnotification.forwarding.FCMMessageService;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public abstract class Constants {
+    public static final long WAKE_LOCK_ACQUIRE_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(3);
+
+    public static final class MessagePayloadKeys {
+        public static ArrayMap extractDeveloperDefinedPayload(Bundle bundle) {
+            ArrayMap arrayMap = new ArrayMap();
+            for (String str : bundle.keySet()) {
+                Object obj = bundle.get(str);
+                if (obj instanceof String) {
+                    String str2 = (String) obj;
+                    if (!str.startsWith("google.") && !str.startsWith("gcm.") && !str.equals("from") && !str.equals("message_type") && !str.equals(FCMMessageService.PushIntentExtraKeys.COLLAPSE_KEY)) {
+                        arrayMap.put(str, str2);
+                    }
+                }
+            }
+            return arrayMap;
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/DisplayNotification.java

@@ -0,0 +1,99 @@
+package com.google.firebase.messaging;
+
+import android.app.ActivityManager;
+import android.app.KeyguardManager;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.os.Process;
+import android.os.SystemClock;
+import android.util.Log;
+import androidx.core.app.NotificationCompat;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.messaging.CommonNotificationBuilder;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public class DisplayNotification {
+    public final Context context;
+    public final ExecutorService networkIoExecutor;
+    public final NotificationParams params;
+
+    public DisplayNotification(Context context, NotificationParams notificationParams, ExecutorService executorService) {
+        this.networkIoExecutor = executorService;
+        this.context = context;
+        this.params = notificationParams;
+    }
+
+    public final boolean isAppForeground() {
+        if (((KeyguardManager) this.context.getSystemService("keyguard")).inKeyguardRestrictedInputMode()) {
+            return false;
+        }
+        if (!PlatformVersion.isAtLeastLollipop()) {
+            SystemClock.sleep(10L);
+        }
+        int myPid = Process.myPid();
+        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = ((ActivityManager) this.context.getSystemService("activity")).getRunningAppProcesses();
+        if (runningAppProcesses == null) {
+            return false;
+        }
+        for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
+            if (runningAppProcessInfo.pid == myPid) {
+                return runningAppProcessInfo.importance == 100;
+            }
+        }
+        return false;
+    }
+
+    public boolean handleNotification() {
+        if (this.params.getBoolean("gcm.n.noui")) {
+            return true;
+        }
+        if (isAppForeground()) {
+            return false;
+        }
+        ImageDownload startImageDownloadInBackground = startImageDownloadInBackground();
+        CommonNotificationBuilder.DisplayNotificationInfo createNotificationInfo = CommonNotificationBuilder.createNotificationInfo(this.context, this.params);
+        waitForAndApplyImageDownload(createNotificationInfo.notificationBuilder, startImageDownloadInBackground);
+        showNotification(createNotificationInfo);
+        return true;
+    }
+
+    public final ImageDownload startImageDownloadInBackground() {
+        ImageDownload create = ImageDownload.create(this.params.getString("gcm.n.image"));
+        if (create != null) {
+            create.start(this.networkIoExecutor);
+        }
+        return create;
+    }
+
+    public final void waitForAndApplyImageDownload(NotificationCompat.Builder builder, ImageDownload imageDownload) {
+        if (imageDownload == null) {
+            return;
+        }
+        try {
+            Bitmap bitmap = (Bitmap) Tasks.await(imageDownload.getTask(), 5L, TimeUnit.SECONDS);
+            builder.setLargeIcon(bitmap);
+            builder.setStyle(new NotificationCompat.BigPictureStyle().bigPicture(bitmap).bigLargeIcon((Bitmap) null));
+        } catch (InterruptedException unused) {
+            Log.w("FirebaseMessaging", "Interrupted while downloading image, showing notification without it");
+            imageDownload.close();
+            Thread.currentThread().interrupt();
+        } catch (ExecutionException e) {
+            Log.w("FirebaseMessaging", "Failed to download image: " + e.getCause());
+        } catch (TimeoutException unused2) {
+            Log.w("FirebaseMessaging", "Failed to download image in time, showing notification without it");
+            imageDownload.close();
+        }
+    }
+
+    public final void showNotification(CommonNotificationBuilder.DisplayNotificationInfo displayNotificationInfo) {
+        Log.isLoggable("FirebaseMessaging", 3);
+        ((NotificationManager) this.context.getSystemService("notification")).notify(displayNotificationInfo.tag, displayNotificationInfo.id, displayNotificationInfo.notificationBuilder.build());
+    }
+}

decompiled/sources/com/google/firebase/messaging/EnhancedIntentService.java

@@ -0,0 +1,138 @@
+package com.google.firebase.messaging;
+
+import android.annotation.SuppressLint;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.IBinder;
+import android.util.Log;
+import androidx.annotation.CallSuper;
+import androidx.annotation.VisibleForTesting;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.messaging.WithinAppServiceBinder;
+import java.util.concurrent.ExecutorService;
+
+@SuppressLint({"UnwrappedWakefulBroadcastReceiver"})
+/* loaded from: classes3.dex */
+public abstract class EnhancedIntentService extends Service {
+    static final long MESSAGE_TIMEOUT_S = 20;
+    private static final String TAG = "EnhancedIntentService";
+    private Binder binder;
+    private int lastStartId;
+
+    @VisibleForTesting
+    final ExecutorService executor = FcmExecutors.newIntentHandleExecutor();
+    private final Object lock = new Object();
+    private int runningTasks = 0;
+
+    public Intent getStartCommandIntent(Intent intent) {
+        return intent;
+    }
+
+    public abstract void handleIntent(Intent intent);
+
+    public boolean handleIntentOnMainThread(Intent intent) {
+        return false;
+    }
+
+    @Override // android.app.Service
+    public final synchronized IBinder onBind(Intent intent) {
+        try {
+            Log.isLoggable(TAG, 3);
+            if (this.binder == null) {
+                this.binder = new WithinAppServiceBinder(new WithinAppServiceBinder.IntentHandler() { // from class: com.google.firebase.messaging.EnhancedIntentService.1
+                    @Override // com.google.firebase.messaging.WithinAppServiceBinder.IntentHandler
+                    public Task handle(Intent intent2) {
+                        return EnhancedIntentService.this.processIntent(intent2);
+                    }
+                });
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.binder;
+    }
+
+    public final Task processIntent(final Intent intent) {
+        if (handleIntentOnMainThread(intent)) {
+            return Tasks.forResult(null);
+        }
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.executor.execute(new Runnable() { // from class: com.google.firebase.messaging.EnhancedIntentService$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                EnhancedIntentService.this.lambda$processIntent$0(intent, taskCompletionSource);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    public final /* synthetic */ void lambda$processIntent$0(Intent intent, TaskCompletionSource taskCompletionSource) {
+        try {
+            handleIntent(intent);
+        } finally {
+            taskCompletionSource.setResult(null);
+        }
+    }
+
+    @Override // android.app.Service
+    public final int onStartCommand(final Intent intent, int i, int i2) {
+        synchronized (this.lock) {
+            this.lastStartId = i2;
+            this.runningTasks++;
+        }
+        Intent startCommandIntent = getStartCommandIntent(intent);
+        if (startCommandIntent == null) {
+            finishTask(intent);
+            return 2;
+        }
+        Task processIntent = processIntent(startCommandIntent);
+        if (processIntent.isComplete()) {
+            finishTask(intent);
+            return 2;
+        }
+        processIntent.addOnCompleteListener(new CredentialManager$$ExternalSyntheticLambda0(), new OnCompleteListener() { // from class: com.google.firebase.messaging.EnhancedIntentService$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.OnCompleteListener
+            public final void onComplete(Task task) {
+                EnhancedIntentService.this.lambda$onStartCommand$1(intent, task);
+            }
+        });
+        return 3;
+    }
+
+    public final /* synthetic */ void lambda$onStartCommand$1(Intent intent, Task task) {
+        finishTask(intent);
+    }
+
+    @Override // android.app.Service
+    @CallSuper
+    public void onDestroy() {
+        this.executor.shutdown();
+        super.onDestroy();
+    }
+
+    public final void finishTask(Intent intent) {
+        if (intent != null) {
+            WakeLockHolder.completeWakefulIntent(intent);
+        }
+        synchronized (this.lock) {
+            try {
+                int i = this.runningTasks - 1;
+                this.runningTasks = i;
+                if (i == 0) {
+                    stopSelfResultHook(this.lastStartId);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public boolean stopSelfResultHook(int i) {
+        return stopSelfResult(i);
+    }
+}

decompiled/sources/com/google/firebase/messaging/FcmBroadcastProcessor.java

@@ -0,0 +1,117 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.Intent;
+import android.util.Base64;
+import android.util.Log;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.drive.DriveFile;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class FcmBroadcastProcessor {
+    public static WithinAppServiceConnection fcmServiceConn;
+    public static final Object lock = new Object();
+    public final Context context;
+    public final Executor executor = new CredentialManager$$ExternalSyntheticLambda0();
+
+    public FcmBroadcastProcessor(Context context) {
+        this.context = context;
+    }
+
+    public Task process(Intent intent) {
+        String stringExtra = intent.getStringExtra("gcm.rawData64");
+        if (stringExtra != null) {
+            intent.putExtra("rawData", Base64.decode(stringExtra, 0));
+            intent.removeExtra("gcm.rawData64");
+        }
+        return startMessagingService(this.context, intent);
+    }
+
+    public Task startMessagingService(final Context context, final Intent intent) {
+        boolean z = PlatformVersion.isAtLeastO() && context.getApplicationInfo().targetSdkVersion >= 26;
+        final boolean z2 = (intent.getFlags() & DriveFile.MODE_READ_ONLY) != 0;
+        if (z && !z2) {
+            return bindToMessagingService(context, intent, z2);
+        }
+        return Tasks.call(this.executor, new Callable() { // from class: com.google.firebase.messaging.FcmBroadcastProcessor$$ExternalSyntheticLambda0
+            @Override // java.util.concurrent.Callable
+            public final Object call() {
+                Integer lambda$startMessagingService$0;
+                lambda$startMessagingService$0 = FcmBroadcastProcessor.lambda$startMessagingService$0(context, intent);
+                return lambda$startMessagingService$0;
+            }
+        }).continueWithTask(this.executor, new Continuation() { // from class: com.google.firebase.messaging.FcmBroadcastProcessor$$ExternalSyntheticLambda1
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task) {
+                Task lambda$startMessagingService$2;
+                lambda$startMessagingService$2 = FcmBroadcastProcessor.lambda$startMessagingService$2(context, intent, z2, task);
+                return lambda$startMessagingService$2;
+            }
+        });
+    }
+
+    public static /* synthetic */ Integer lambda$startMessagingService$0(Context context, Intent intent) {
+        return Integer.valueOf(ServiceStarter.getInstance().startMessagingService(context, intent));
+    }
+
+    public static /* synthetic */ Task lambda$startMessagingService$2(Context context, Intent intent, boolean z, Task task) {
+        return (PlatformVersion.isAtLeastO() && ((Integer) task.getResult()).intValue() == 402) ? bindToMessagingService(context, intent, z).continueWith(new CredentialManager$$ExternalSyntheticLambda0(), new Continuation() { // from class: com.google.firebase.messaging.FcmBroadcastProcessor$$ExternalSyntheticLambda2
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task2) {
+                Integer lambda$startMessagingService$1;
+                lambda$startMessagingService$1 = FcmBroadcastProcessor.lambda$startMessagingService$1(task2);
+                return lambda$startMessagingService$1;
+            }
+        }) : task;
+    }
+
+    public static /* synthetic */ Integer lambda$startMessagingService$1(Task task) {
+        return 403;
+    }
+
+    public static Task bindToMessagingService(Context context, Intent intent, boolean z) {
+        Log.isLoggable("FirebaseMessaging", 3);
+        WithinAppServiceConnection serviceConnection = getServiceConnection(context, "com.google.firebase.MESSAGING_EVENT");
+        if (z) {
+            if (ServiceStarter.getInstance().hasWakeLockPermission(context)) {
+                WakeLockHolder.sendWakefulServiceIntent(context, serviceConnection, intent);
+            } else {
+                serviceConnection.sendIntent(intent);
+            }
+            return Tasks.forResult(-1);
+        }
+        return serviceConnection.sendIntent(intent).continueWith(new CredentialManager$$ExternalSyntheticLambda0(), new Continuation() { // from class: com.google.firebase.messaging.FcmBroadcastProcessor$$ExternalSyntheticLambda3
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task) {
+                Integer lambda$bindToMessagingService$3;
+                lambda$bindToMessagingService$3 = FcmBroadcastProcessor.lambda$bindToMessagingService$3(task);
+                return lambda$bindToMessagingService$3;
+            }
+        });
+    }
+
+    public static /* synthetic */ Integer lambda$bindToMessagingService$3(Task task) {
+        return -1;
+    }
+
+    public static WithinAppServiceConnection getServiceConnection(Context context, String str) {
+        WithinAppServiceConnection withinAppServiceConnection;
+        synchronized (lock) {
+            try {
+                if (fcmServiceConn == null) {
+                    fcmServiceConn = new WithinAppServiceConnection(context, str);
+                }
+                withinAppServiceConnection = fcmServiceConn;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return withinAppServiceConnection;
+    }
+}

decompiled/sources/com/google/firebase/messaging/FcmExecutors.java

@@ -0,0 +1,44 @@
+package com.google.firebase.messaging;
+
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.firebase.messaging.threads.PoolableExecutors;
+import com.google.firebase.messaging.threads.ThreadPriority;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public abstract class FcmExecutors {
+    public static Executor newFileIOExecutor() {
+        return newCachedSingleThreadExecutor("Firebase-Messaging-File-Io");
+    }
+
+    public static Executor newCachedSingleThreadExecutor(String str) {
+        return new ThreadPoolExecutor(0, 1, 30L, TimeUnit.SECONDS, new LinkedBlockingQueue(), new NamedThreadFactory(str));
+    }
+
+    public static ScheduledExecutorService newTopicsSyncExecutor() {
+        return new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("Firebase-Messaging-Topics-Io"));
+    }
+
+    public static ExecutorService newNetworkIOExecutor() {
+        return Executors.newSingleThreadExecutor(new NamedThreadFactory("Firebase-Messaging-Network-Io"));
+    }
+
+    public static ExecutorService newTaskExecutor() {
+        return Executors.newSingleThreadExecutor(new NamedThreadFactory("Firebase-Messaging-Task"));
+    }
+
+    public static ExecutorService newIntentHandleExecutor() {
+        return PoolableExecutors.factory().newSingleThreadExecutor(new NamedThreadFactory("Firebase-Messaging-Intent-Handle"), ThreadPriority.HIGH_SPEED);
+    }
+
+    public static ScheduledExecutorService newInitExecutor() {
+        return new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("Firebase-Messaging-Init"));
+    }
+}

decompiled/sources/com/google/firebase/messaging/FcmLifecycleCallbacks.java

@@ -0,0 +1,66 @@
+package com.google.firebase.messaging;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import java.util.Collections;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+/* loaded from: classes3.dex */
+public class FcmLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    public final Set seenIntents = Collections.newSetFromMap(new WeakHashMap());
+
+    @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) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStarted(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityStopped(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityCreated(Activity activity, Bundle bundle) {
+        Intent intent = activity.getIntent();
+        if (intent == null || !this.seenIntents.add(intent)) {
+            return;
+        }
+        logNotificationOpen(intent);
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public void onActivityPaused(Activity activity) {
+        if (activity.isFinishing()) {
+            this.seenIntents.remove(activity.getIntent());
+        }
+    }
+
+    public final void logNotificationOpen(Intent intent) {
+        Bundle bundle = null;
+        try {
+            Bundle extras = intent.getExtras();
+            if (extras != null) {
+                bundle = extras.getBundle("gcm.n.analytics_data");
+            }
+        } catch (RuntimeException e) {
+            Log.w("FirebaseMessaging", "Failed trying to get analytics data from Intent extras.", e);
+        }
+        if (MessagingAnalytics.shouldUploadScionMetrics(bundle)) {
+            MessagingAnalytics.logNotificationOpen(bundle);
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/FirebaseMessaging.java

@@ -0,0 +1,413 @@
+package com.google.firebase.messaging;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.Keep;
+import androidx.annotation.NonNull;
+import com.google.android.datatransport.TransportFactory;
+import com.google.android.gms.cloudmessaging.CloudMessage;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.SuccessContinuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.DataCollectionDefaultChange;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.events.Event;
+import com.google.firebase.events.EventHandler;
+import com.google.firebase.events.Subscriber;
+import com.google.firebase.iid.internal.FirebaseInstanceIdInternal;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.messaging.FirebaseMessaging;
+import com.google.firebase.messaging.RequestDeduplicator;
+import com.google.firebase.messaging.Store;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class FirebaseMessaging {
+    public static Store store;
+    public static ScheduledExecutorService syncExecutor;
+    public final AutoInit autoInit;
+    public final Context context;
+    public final Executor fileExecutor;
+    public final FirebaseApp firebaseApp;
+    public final GmsRpc gmsRpc;
+    public final Executor initExecutor;
+    public final Application.ActivityLifecycleCallbacks lifecycleCallbacks;
+    public final Metadata metadata;
+    public final RequestDeduplicator requestDeduplicator;
+    public boolean syncScheduledOrRunning;
+    public final Task topicsSubscriberTask;
+    public static final long MAX_DELAY_SEC = TimeUnit.HOURS.toSeconds(8);
+    public static Provider transportFactory = new Provider() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda0
+        @Override // com.google.firebase.inject.Provider
+        public final Object get() {
+            TransportFactory lambda$static$0;
+            lambda$static$0 = FirebaseMessaging.lambda$static$0();
+            return lambda$static$0;
+        }
+    };
+
+    public static /* synthetic */ TransportFactory lambda$static$0() {
+        return null;
+    }
+
+    public Context getApplicationContext() {
+        return this.context;
+    }
+
+    public static synchronized FirebaseMessaging getInstance() {
+        FirebaseMessaging firebaseMessaging;
+        synchronized (FirebaseMessaging.class) {
+            firebaseMessaging = getInstance(FirebaseApp.getInstance());
+        }
+        return firebaseMessaging;
+    }
+
+    public static synchronized Store getStore(Context context) {
+        Store store2;
+        synchronized (FirebaseMessaging.class) {
+            try {
+                if (store == null) {
+                    store = new Store(context);
+                }
+                store2 = store;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return store2;
+    }
+
+    @NonNull
+    @Keep
+    public static synchronized FirebaseMessaging getInstance(@NonNull FirebaseApp firebaseApp) {
+        FirebaseMessaging firebaseMessaging;
+        synchronized (FirebaseMessaging.class) {
+            firebaseMessaging = (FirebaseMessaging) firebaseApp.get(FirebaseMessaging.class);
+            Preconditions.checkNotNull(firebaseMessaging, "Firebase Messaging component is not present");
+        }
+        return firebaseMessaging;
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi, Provider provider3, Subscriber subscriber) {
+        this(firebaseApp, firebaseInstanceIdInternal, provider, provider2, firebaseInstallationsApi, provider3, subscriber, new Metadata(firebaseApp.getApplicationContext()));
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi, Provider provider3, Subscriber subscriber, Metadata metadata) {
+        this(firebaseApp, firebaseInstanceIdInternal, provider3, subscriber, metadata, new GmsRpc(firebaseApp, metadata, provider, provider2, firebaseInstallationsApi), FcmExecutors.newTaskExecutor(), FcmExecutors.newInitExecutor(), FcmExecutors.newFileIOExecutor());
+    }
+
+    public FirebaseMessaging(FirebaseApp firebaseApp, FirebaseInstanceIdInternal firebaseInstanceIdInternal, Provider provider, Subscriber subscriber, Metadata metadata, GmsRpc gmsRpc, Executor executor, Executor executor2, Executor executor3) {
+        this.syncScheduledOrRunning = false;
+        transportFactory = provider;
+        this.firebaseApp = firebaseApp;
+        this.autoInit = new AutoInit(subscriber);
+        Context applicationContext = firebaseApp.getApplicationContext();
+        this.context = applicationContext;
+        FcmLifecycleCallbacks fcmLifecycleCallbacks = new FcmLifecycleCallbacks();
+        this.lifecycleCallbacks = fcmLifecycleCallbacks;
+        this.metadata = metadata;
+        this.gmsRpc = gmsRpc;
+        this.requestDeduplicator = new RequestDeduplicator(executor);
+        this.initExecutor = executor2;
+        this.fileExecutor = executor3;
+        Context applicationContext2 = firebaseApp.getApplicationContext();
+        if (applicationContext2 instanceof Application) {
+            ((Application) applicationContext2).registerActivityLifecycleCallbacks(fcmLifecycleCallbacks);
+        } else {
+            Log.w("FirebaseMessaging", "Context " + applicationContext2 + " was not an application, can't register for lifecycle callbacks. Some notification events may be dropped as a result.");
+        }
+        if (firebaseInstanceIdInternal != null) {
+            firebaseInstanceIdInternal.addNewTokenListener(new FirebaseInstanceIdInternal.NewTokenListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda1
+            });
+        }
+        executor2.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda2
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$new$2();
+            }
+        });
+        Task createInstance = TopicsSubscriber.createInstance(this, metadata, gmsRpc, applicationContext, FcmExecutors.newTopicsSyncExecutor());
+        this.topicsSubscriberTask = createInstance;
+        createInstance.addOnSuccessListener(executor2, new OnSuccessListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda3
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                FirebaseMessaging.this.lambda$new$3((TopicsSubscriber) obj);
+            }
+        });
+        executor2.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda4
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$new$4();
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$new$2() {
+        if (isAutoInitEnabled()) {
+            startSyncIfNecessary();
+        }
+    }
+
+    public final /* synthetic */ void lambda$new$3(TopicsSubscriber topicsSubscriber) {
+        if (isAutoInitEnabled()) {
+            topicsSubscriber.startTopicsSyncIfNecessary();
+        }
+    }
+
+    /* renamed from: initializeProxyNotifications, reason: merged with bridge method [inline-methods] */
+    public final void lambda$new$4() {
+        ProxyNotificationInitializer.initialize(this.context);
+        ProxyNotificationPreferences.setProxyRetention(this.context, this.gmsRpc, shouldRetainProxyNotifications());
+        if (shouldRetainProxyNotifications()) {
+            handleProxiedNotificationData();
+        }
+    }
+
+    public final boolean shouldRetainProxyNotifications() {
+        ProxyNotificationInitializer.initialize(this.context);
+        if (!ProxyNotificationInitializer.isProxyNotificationEnabled(this.context)) {
+            return false;
+        }
+        if (this.firebaseApp.get(AnalyticsConnector.class) != null) {
+            return true;
+        }
+        return MessagingAnalytics.deliveryMetricsExportToBigQueryEnabled() && transportFactory != null;
+    }
+
+    public final void handleProxiedNotificationData() {
+        this.gmsRpc.getProxyNotificationData().addOnSuccessListener(this.initExecutor, new OnSuccessListener() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda6
+            @Override // com.google.android.gms.tasks.OnSuccessListener
+            public final void onSuccess(Object obj) {
+                FirebaseMessaging.this.lambda$handleProxiedNotificationData$5((CloudMessage) obj);
+            }
+        });
+    }
+
+    public final /* synthetic */ void lambda$handleProxiedNotificationData$5(CloudMessage cloudMessage) {
+        if (cloudMessage != null) {
+            MessagingAnalytics.logNotificationReceived(cloudMessage.getIntent());
+            handleProxiedNotificationData();
+        }
+    }
+
+    public boolean isAutoInitEnabled() {
+        return this.autoInit.isEnabled();
+    }
+
+    public Task getToken() {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.initExecutor.execute(new Runnable() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda5
+            @Override // java.lang.Runnable
+            public final void run() {
+                FirebaseMessaging.this.lambda$getToken$7(taskCompletionSource);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    public final /* synthetic */ void lambda$getToken$7(TaskCompletionSource taskCompletionSource) {
+        try {
+            taskCompletionSource.setResult(blockingGetToken());
+        } catch (Exception e) {
+            taskCompletionSource.setException(e);
+        }
+    }
+
+    public static TransportFactory getTransportFactory() {
+        return (TransportFactory) transportFactory.get();
+    }
+
+    public boolean isGmsCorePresent() {
+        return this.metadata.isGmscorePresent();
+    }
+
+    public synchronized void setSyncScheduledOrRunning(boolean z) {
+        this.syncScheduledOrRunning = z;
+    }
+
+    public synchronized void syncWithDelaySecondsInternal(long j) {
+        enqueueTaskWithDelaySeconds(new SyncTask(this, Math.min(Math.max(30L, 2 * j), MAX_DELAY_SEC)), j);
+        this.syncScheduledOrRunning = true;
+    }
+
+    public void enqueueTaskWithDelaySeconds(Runnable runnable, long j) {
+        synchronized (FirebaseMessaging.class) {
+            try {
+                if (syncExecutor == null) {
+                    syncExecutor = new ScheduledThreadPoolExecutor(1, new NamedThreadFactory("TAG"));
+                }
+                syncExecutor.schedule(runnable, j, TimeUnit.SECONDS);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void startSyncIfNecessary() {
+        if (tokenNeedsRefresh(getTokenWithoutTriggeringSync())) {
+            startSync();
+        }
+    }
+
+    public final synchronized void startSync() {
+        if (!this.syncScheduledOrRunning) {
+            syncWithDelaySecondsInternal(0L);
+        }
+    }
+
+    public Store.Token getTokenWithoutTriggeringSync() {
+        return getStore(this.context).getToken(getSubtype(), Metadata.getDefaultSenderId(this.firebaseApp));
+    }
+
+    public String blockingGetToken() {
+        final Store.Token tokenWithoutTriggeringSync = getTokenWithoutTriggeringSync();
+        if (!tokenNeedsRefresh(tokenWithoutTriggeringSync)) {
+            return tokenWithoutTriggeringSync.token;
+        }
+        final String defaultSenderId = Metadata.getDefaultSenderId(this.firebaseApp);
+        try {
+            return (String) Tasks.await(this.requestDeduplicator.getOrStartGetTokenRequest(defaultSenderId, new RequestDeduplicator.GetTokenRequest() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda7
+                @Override // com.google.firebase.messaging.RequestDeduplicator.GetTokenRequest
+                public final Task start() {
+                    Task lambda$blockingGetToken$14;
+                    lambda$blockingGetToken$14 = FirebaseMessaging.this.lambda$blockingGetToken$14(defaultSenderId, tokenWithoutTriggeringSync);
+                    return lambda$blockingGetToken$14;
+                }
+            }));
+        } catch (InterruptedException | ExecutionException e) {
+            throw new IOException(e);
+        }
+    }
+
+    public final /* synthetic */ Task lambda$blockingGetToken$14(final String str, final Store.Token token) {
+        return this.gmsRpc.getToken().onSuccessTask(this.fileExecutor, new SuccessContinuation() { // from class: com.google.firebase.messaging.FirebaseMessaging$$ExternalSyntheticLambda8
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public final Task then(Object obj) {
+                Task lambda$blockingGetToken$13;
+                lambda$blockingGetToken$13 = FirebaseMessaging.this.lambda$blockingGetToken$13(str, token, (String) obj);
+                return lambda$blockingGetToken$13;
+            }
+        });
+    }
+
+    public final /* synthetic */ Task lambda$blockingGetToken$13(String str, Store.Token token, String str2) {
+        getStore(this.context).saveToken(getSubtype(), str, str2, this.metadata.getAppVersionCode());
+        if (token == null || !str2.equals(token.token)) {
+            invokeOnTokenRefresh(str2);
+        }
+        return Tasks.forResult(str2);
+    }
+
+    public final String getSubtype() {
+        return "[DEFAULT]".equals(this.firebaseApp.getName()) ? "" : this.firebaseApp.getPersistenceKey();
+    }
+
+    public boolean tokenNeedsRefresh(Store.Token token) {
+        return token == null || token.needsRefresh(this.metadata.getAppVersionCode());
+    }
+
+    public final void invokeOnTokenRefresh(String str) {
+        if ("[DEFAULT]".equals(this.firebaseApp.getName())) {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Invoking onNewToken for app: ");
+                sb.append(this.firebaseApp.getName());
+            }
+            Intent intent = new Intent("com.google.firebase.messaging.NEW_TOKEN");
+            intent.putExtra("token", str);
+            new FcmBroadcastProcessor(this.context).process(intent);
+        }
+    }
+
+    public class AutoInit {
+        public Boolean autoInitEnabled;
+        public EventHandler dataCollectionDefaultChangeEventHandler;
+        public boolean initialized;
+        public final Subscriber subscriber;
+
+        public AutoInit(Subscriber subscriber) {
+            this.subscriber = subscriber;
+        }
+
+        public synchronized void initialize() {
+            try {
+                if (this.initialized) {
+                    return;
+                }
+                Boolean readEnabled = readEnabled();
+                this.autoInitEnabled = readEnabled;
+                if (readEnabled == null) {
+                    EventHandler eventHandler = new EventHandler() { // from class: com.google.firebase.messaging.FirebaseMessaging$AutoInit$$ExternalSyntheticLambda0
+                        @Override // com.google.firebase.events.EventHandler
+                        public final void handle(Event event) {
+                            FirebaseMessaging.AutoInit.this.lambda$initialize$0(event);
+                        }
+                    };
+                    this.dataCollectionDefaultChangeEventHandler = eventHandler;
+                    this.subscriber.subscribe(DataCollectionDefaultChange.class, eventHandler);
+                }
+                this.initialized = true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+
+        public final /* synthetic */ void lambda$initialize$0(Event event) {
+            if (isEnabled()) {
+                FirebaseMessaging.this.startSyncIfNecessary();
+            }
+        }
+
+        public synchronized boolean isEnabled() {
+            boolean isDataCollectionDefaultEnabled;
+            try {
+                initialize();
+                Boolean bool = this.autoInitEnabled;
+                if (bool == null) {
+                    isDataCollectionDefaultEnabled = FirebaseMessaging.this.firebaseApp.isDataCollectionDefaultEnabled();
+                } else {
+                    isDataCollectionDefaultEnabled = bool.booleanValue();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+            return isDataCollectionDefaultEnabled;
+        }
+
+        public final Boolean readEnabled() {
+            ApplicationInfo applicationInfo;
+            Bundle bundle;
+            Context applicationContext = FirebaseMessaging.this.firebaseApp.getApplicationContext();
+            SharedPreferences sharedPreferences = applicationContext.getSharedPreferences("com.google.firebase.messaging", 0);
+            if (sharedPreferences.contains("auto_init")) {
+                return Boolean.valueOf(sharedPreferences.getBoolean("auto_init", false));
+            }
+            try {
+                PackageManager packageManager = applicationContext.getPackageManager();
+                if (packageManager == null || (applicationInfo = packageManager.getApplicationInfo(applicationContext.getPackageName(), 128)) == null || (bundle = applicationInfo.metaData) == null || !bundle.containsKey("firebase_messaging_auto_init_enabled")) {
+                    return null;
+                }
+                return Boolean.valueOf(applicationInfo.metaData.getBoolean("firebase_messaging_auto_init_enabled"));
+            } catch (PackageManager.NameNotFoundException unused) {
+                return null;
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/FirebaseMessagingKtxRegistrar.java

@@ -0,0 +1,13 @@
+package com.google.firebase.messaging;
+
+import com.google.firebase.components.ComponentRegistrar;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+
+/* loaded from: classes3.dex */
+public final class FirebaseMessagingKtxRegistrar implements ComponentRegistrar {
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List getComponents() {
+        return CollectionsKt__CollectionsKt.emptyList();
+    }
+}

decompiled/sources/com/google/firebase/messaging/FirebaseMessagingRegistrar.java

@@ -0,0 +1,50 @@
+package com.google.firebase.messaging;
+
+import androidx.annotation.Keep;
+import com.amazonaws.handlers.HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0;
+import com.google.android.datatransport.TransportFactory;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.components.Component;
+import com.google.firebase.components.ComponentContainer;
+import com.google.firebase.components.ComponentFactory;
+import com.google.firebase.components.ComponentRegistrar;
+import com.google.firebase.components.Dependency;
+import com.google.firebase.components.Qualified;
+import com.google.firebase.datatransport.TransportBackend;
+import com.google.firebase.events.Subscriber;
+import com.google.firebase.heartbeatinfo.HeartBeatInfo;
+import com.google.firebase.iid.internal.FirebaseInstanceIdInternal;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.google.firebase.platforminfo.LibraryVersionComponent;
+import com.google.firebase.platforminfo.UserAgentPublisher;
+import java.util.Arrays;
+import java.util.List;
+
+@Keep
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class FirebaseMessagingRegistrar implements ComponentRegistrar {
+    private static final String LIBRARY_NAME = "fire-fcm";
+
+    @Override // com.google.firebase.components.ComponentRegistrar
+    @Keep
+    public List<Component> getComponents() {
+        final Qualified qualified = Qualified.qualified(TransportBackend.class, TransportFactory.class);
+        return Arrays.asList(Component.builder(FirebaseMessaging.class).name(LIBRARY_NAME).add(Dependency.required(FirebaseApp.class)).add(Dependency.optional(FirebaseInstanceIdInternal.class)).add(Dependency.optionalProvider(UserAgentPublisher.class)).add(Dependency.optionalProvider(HeartBeatInfo.class)).add(Dependency.required(FirebaseInstallationsApi.class)).add(Dependency.optionalProvider(qualified)).add(Dependency.required(Subscriber.class)).factory(new ComponentFactory() { // from class: com.google.firebase.messaging.FirebaseMessagingRegistrar$$ExternalSyntheticLambda0
+            @Override // com.google.firebase.components.ComponentFactory
+            public final Object create(ComponentContainer componentContainer) {
+                FirebaseMessaging lambda$getComponents$0;
+                lambda$getComponents$0 = FirebaseMessagingRegistrar.lambda$getComponents$0(Qualified.this, componentContainer);
+                return lambda$getComponents$0;
+            }
+        }).alwaysEager().build(), LibraryVersionComponent.create(LIBRARY_NAME, "24.0.0"));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ FirebaseMessaging lambda$getComponents$0(Qualified qualified, ComponentContainer componentContainer) {
+        FirebaseApp firebaseApp = (FirebaseApp) componentContainer.get(FirebaseApp.class);
+        HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0.m(componentContainer.get(FirebaseInstanceIdInternal.class));
+        return new FirebaseMessaging(firebaseApp, null, componentContainer.getProvider(UserAgentPublisher.class), componentContainer.getProvider(HeartBeatInfo.class), (FirebaseInstallationsApi) componentContainer.get(FirebaseInstallationsApi.class), componentContainer.getProvider(qualified), (Subscriber) componentContainer.get(Subscriber.class));
+    }
+}

decompiled/sources/com/google/firebase/messaging/FirebaseMessagingService.java

@@ -0,0 +1,165 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.cloudmessaging.CloudMessage;
+import com.google.android.gms.cloudmessaging.Rpc;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes3.dex */
+public class FirebaseMessagingService extends EnhancedIntentService {
+    public static final String ACTION_DIRECT_BOOT_REMOTE_INTENT = "com.google.firebase.messaging.RECEIVE_DIRECT_BOOT";
+    static final String ACTION_NEW_TOKEN = "com.google.firebase.messaging.NEW_TOKEN";
+    static final String ACTION_REMOTE_INTENT = "com.google.android.c2dm.intent.RECEIVE";
+    static final String EXTRA_TOKEN = "token";
+    private static final int RECENTLY_RECEIVED_MESSAGE_IDS_MAX_SIZE = 10;
+    private static final Queue<String> recentlyReceivedMessageIds = new ArrayDeque(10);
+    private Rpc rpc;
+
+    @WorkerThread
+    public void onDeletedMessages() {
+    }
+
+    public void onMessageReceived(RemoteMessage remoteMessage) {
+    }
+
+    @WorkerThread
+    public void onMessageSent(@NonNull String str) {
+    }
+
+    public void onNewToken(String str) {
+    }
+
+    @WorkerThread
+    public void onSendError(@NonNull String str, @NonNull Exception exc) {
+    }
+
+    @VisibleForTesting
+    public void setRpcForTesting(Rpc rpc) {
+        this.rpc = rpc;
+    }
+
+    @Override // com.google.firebase.messaging.EnhancedIntentService
+    public Intent getStartCommandIntent(Intent intent) {
+        return ServiceStarter.getInstance().getMessagingEvent();
+    }
+
+    @Override // com.google.firebase.messaging.EnhancedIntentService
+    public void handleIntent(Intent intent) {
+        String action = intent.getAction();
+        if (ACTION_REMOTE_INTENT.equals(action) || ACTION_DIRECT_BOOT_REMOTE_INTENT.equals(action)) {
+            handleMessageIntent(intent);
+        } else {
+            if (ACTION_NEW_TOKEN.equals(action)) {
+                onNewToken(intent.getStringExtra("token"));
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append("Unknown intent action: ");
+            sb.append(intent.getAction());
+        }
+    }
+
+    public final void handleMessageIntent(Intent intent) {
+        if (!alreadyReceivedMessage(intent.getStringExtra("google.message_id"))) {
+            passMessageIntentToSdk(intent);
+        }
+        getRpc(this).messageHandled(new CloudMessage(intent));
+    }
+
+    public final void passMessageIntentToSdk(Intent intent) {
+        String stringExtra;
+        stringExtra = intent.getStringExtra("message_type");
+        if (stringExtra == null) {
+            stringExtra = "gcm";
+        }
+        switch (stringExtra) {
+            case "deleted_messages":
+                onDeletedMessages();
+                break;
+            case "gcm":
+                MessagingAnalytics.logNotificationReceived(intent);
+                dispatchMessage(intent);
+                break;
+            case "send_error":
+                onSendError(getMessageId(intent), new SendException(intent.getStringExtra("error")));
+                break;
+            case "send_event":
+                onMessageSent(intent.getStringExtra("google.message_id"));
+                break;
+            default:
+                Log.w("FirebaseMessaging", "Received message with unknown type: " + stringExtra);
+                break;
+        }
+    }
+
+    public final void dispatchMessage(Intent intent) {
+        Bundle extras = intent.getExtras();
+        if (extras == null) {
+            extras = new Bundle();
+        }
+        extras.remove("androidx.content.wakelockid");
+        if (NotificationParams.isNotification(extras)) {
+            NotificationParams notificationParams = new NotificationParams(extras);
+            ExecutorService newNetworkIOExecutor = FcmExecutors.newNetworkIOExecutor();
+            try {
+                if (new DisplayNotification(this, notificationParams, newNetworkIOExecutor).handleNotification()) {
+                    return;
+                }
+                newNetworkIOExecutor.shutdown();
+                if (MessagingAnalytics.shouldUploadScionMetrics(intent)) {
+                    MessagingAnalytics.logNotificationForeground(intent);
+                }
+            } finally {
+                newNetworkIOExecutor.shutdown();
+            }
+        }
+        onMessageReceived(new RemoteMessage(extras));
+    }
+
+    public final boolean alreadyReceivedMessage(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return false;
+        }
+        Queue<String> queue = recentlyReceivedMessageIds;
+        if (queue.contains(str)) {
+            if (!Log.isLoggable("FirebaseMessaging", 3)) {
+                return true;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append("Received duplicate message: ");
+            sb.append(str);
+            return true;
+        }
+        if (queue.size() >= 10) {
+            queue.remove();
+        }
+        queue.add(str);
+        return false;
+    }
+
+    public final String getMessageId(Intent intent) {
+        String stringExtra = intent.getStringExtra("google.message_id");
+        return stringExtra == null ? intent.getStringExtra("message_id") : stringExtra;
+    }
+
+    public final Rpc getRpc(Context context) {
+        if (this.rpc == null) {
+            this.rpc = new Rpc(context.getApplicationContext());
+        }
+        return this.rpc;
+    }
+
+    @VisibleForTesting
+    public static void resetForTesting() {
+        recentlyReceivedMessageIds.clear();
+    }
+}

decompiled/sources/com/google/firebase/messaging/GmsRpc.java

@@ -0,0 +1,236 @@
+package com.google.firebase.messaging;
+
+import android.os.Bundle;
+import android.util.Base64;
+import android.util.Log;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import androidx.webkit.ProxyConfig;
+import com.google.android.gms.cloudmessaging.Rpc;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.inject.Provider;
+import com.google.firebase.installations.FirebaseInstallationsApi;
+import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.concurrent.ExecutionException;
+
+/* loaded from: classes3.dex */
+public class GmsRpc {
+    public final FirebaseApp app;
+    public final FirebaseInstallationsApi firebaseInstallations;
+    public final Provider heartbeatInfo;
+    public final Metadata metadata;
+    public final Rpc rpc;
+    public final Provider userAgentPublisher;
+
+    public GmsRpc(FirebaseApp firebaseApp, Metadata metadata, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi) {
+        this(firebaseApp, metadata, new Rpc(firebaseApp.getApplicationContext()), provider, provider2, firebaseInstallationsApi);
+    }
+
+    public GmsRpc(FirebaseApp firebaseApp, Metadata metadata, Rpc rpc, Provider provider, Provider provider2, FirebaseInstallationsApi firebaseInstallationsApi) {
+        this.app = firebaseApp;
+        this.metadata = metadata;
+        this.rpc = rpc;
+        this.userAgentPublisher = provider;
+        this.heartbeatInfo = provider2;
+        this.firebaseInstallations = firebaseInstallationsApi;
+    }
+
+    public Task getToken() {
+        return extractResponseWhenComplete(startRpc(Metadata.getDefaultSenderId(this.app), ProxyConfig.MATCH_ALL_SCHEMES, new Bundle()));
+    }
+
+    public Task subscribeToTopic(String str, String str2) {
+        Bundle bundle = new Bundle();
+        bundle.putString("gcm.topic", "/topics/" + str2);
+        return extractResponseWhenComplete(startRpc(str, "/topics/" + str2, bundle));
+    }
+
+    public Task unsubscribeFromTopic(String str, String str2) {
+        Bundle bundle = new Bundle();
+        bundle.putString("gcm.topic", "/topics/" + str2);
+        bundle.putString("delete", "1");
+        return extractResponseWhenComplete(startRpc(str, "/topics/" + str2, bundle));
+    }
+
+    public Task setRetainProxiedNotifications(boolean z) {
+        return this.rpc.setRetainProxiedNotifications(z);
+    }
+
+    public Task getProxyNotificationData() {
+        return this.rpc.getProxiedNotificationData();
+    }
+
+    public final Task startRpc(String str, String str2, Bundle bundle) {
+        try {
+            setDefaultAttributesToBundle(str, str2, bundle);
+            return this.rpc.send(bundle);
+        } catch (InterruptedException | ExecutionException e) {
+            return Tasks.forException(e);
+        }
+    }
+
+    public static String base64UrlSafe(byte[] bArr) {
+        return Base64.encodeToString(bArr, 11);
+    }
+
+    public final String getHashedFirebaseAppName() {
+        try {
+            return base64UrlSafe(MessageDigest.getInstance(AndroidStaticDeviceInfoDataSource.ALGORITHM_SHA1).digest(this.app.getName().getBytes()));
+        } catch (NoSuchAlgorithmException unused) {
+            return "[HASH-ERROR]";
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:17:? A[ADDED_TO_REGION, RETURN, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:9:0x00c0 A[ADDED_TO_REGION] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void setDefaultAttributesToBundle(java.lang.String r3, java.lang.String r4, android.os.Bundle r5) {
+        /*
+            r2 = this;
+            java.lang.String r0 = "FirebaseMessaging"
+            java.lang.String r1 = "scope"
+            r5.putString(r1, r4)
+            java.lang.String r4 = "sender"
+            r5.putString(r4, r3)
+            java.lang.String r4 = "subtype"
+            r5.putString(r4, r3)
+            com.google.firebase.FirebaseApp r3 = r2.app
+            com.google.firebase.FirebaseOptions r3 = r3.getOptions()
+            java.lang.String r3 = r3.getApplicationId()
+            java.lang.String r4 = "gmp_app_id"
+            r5.putString(r4, r3)
+            com.google.firebase.messaging.Metadata r3 = r2.metadata
+            int r3 = r3.getGmsVersionCode()
+            java.lang.String r3 = java.lang.Integer.toString(r3)
+            java.lang.String r4 = "gmsv"
+            r5.putString(r4, r3)
+            int r3 = android.os.Build.VERSION.SDK_INT
+            java.lang.String r3 = java.lang.Integer.toString(r3)
+            java.lang.String r4 = "osv"
+            r5.putString(r4, r3)
+            com.google.firebase.messaging.Metadata r3 = r2.metadata
+            java.lang.String r3 = r3.getAppVersionCode()
+            java.lang.String r4 = "app_ver"
+            r5.putString(r4, r3)
+            com.google.firebase.messaging.Metadata r3 = r2.metadata
+            java.lang.String r3 = r3.getAppVersionName()
+            java.lang.String r4 = "app_ver_name"
+            r5.putString(r4, r3)
+            java.lang.String r3 = "firebase-app-name-hash"
+            java.lang.String r4 = r2.getHashedFirebaseAppName()
+            r5.putString(r3, r4)
+            com.google.firebase.installations.FirebaseInstallationsApi r3 = r2.firebaseInstallations     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            r4 = 0
+            com.google.android.gms.tasks.Task r3 = r3.getToken(r4)     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            java.lang.Object r3 = com.google.android.gms.tasks.Tasks.await(r3)     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            com.google.firebase.installations.InstallationTokenResult r3 = (com.google.firebase.installations.InstallationTokenResult) r3     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            java.lang.String r3 = r3.getToken()     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            boolean r4 = android.text.TextUtils.isEmpty(r3)     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            if (r4 != 0) goto L7a
+            java.lang.String r4 = "Goog-Firebase-Installations-Auth"
+            r5.putString(r4, r3)     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            goto L85
+        L76:
+            r3 = move-exception
+            goto L80
+        L78:
+            r3 = move-exception
+            goto L80
+        L7a:
+            java.lang.String r3 = "FIS auth token is empty"
+            android.util.Log.w(r0, r3)     // Catch: java.lang.InterruptedException -> L76 java.util.concurrent.ExecutionException -> L78
+            goto L85
+        L80:
+            java.lang.String r4 = "Failed to get FIS auth token"
+            android.util.Log.e(r0, r4, r3)
+        L85:
+            com.google.firebase.installations.FirebaseInstallationsApi r3 = r2.firebaseInstallations
+            com.google.android.gms.tasks.Task r3 = r3.getId()
+            java.lang.Object r3 = com.google.android.gms.tasks.Tasks.await(r3)
+            java.lang.String r3 = (java.lang.String) r3
+            java.lang.String r4 = "appid"
+            r5.putString(r4, r3)
+            java.lang.StringBuilder r3 = new java.lang.StringBuilder
+            r3.<init>()
+            java.lang.String r4 = "fcm-"
+            r3.append(r4)
+            java.lang.String r4 = "24.0.0"
+            r3.append(r4)
+            java.lang.String r3 = r3.toString()
+            java.lang.String r4 = "cliv"
+            r5.putString(r4, r3)
+            com.google.firebase.inject.Provider r3 = r2.heartbeatInfo
+            java.lang.Object r3 = r3.get()
+            com.google.firebase.heartbeatinfo.HeartBeatInfo r3 = (com.google.firebase.heartbeatinfo.HeartBeatInfo) r3
+            com.google.firebase.inject.Provider r4 = r2.userAgentPublisher
+            java.lang.Object r4 = r4.get()
+            com.google.firebase.platforminfo.UserAgentPublisher r4 = (com.google.firebase.platforminfo.UserAgentPublisher) r4
+            if (r3 == 0) goto Le2
+            if (r4 == 0) goto Le2
+            java.lang.String r0 = "fire-iid"
+            com.google.firebase.heartbeatinfo.HeartBeatInfo$HeartBeat r3 = r3.getHeartBeatCode(r0)
+            com.google.firebase.heartbeatinfo.HeartBeatInfo$HeartBeat r0 = com.google.firebase.heartbeatinfo.HeartBeatInfo.HeartBeat.NONE
+            if (r3 == r0) goto Le2
+            int r3 = r3.getCode()
+            java.lang.String r3 = java.lang.Integer.toString(r3)
+            java.lang.String r0 = "Firebase-Client-Log-Type"
+            r5.putString(r0, r3)
+            java.lang.String r3 = "Firebase-Client"
+            java.lang.String r4 = r4.getUserAgent()
+            r5.putString(r3, r4)
+        Le2:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.messaging.GmsRpc.setDefaultAttributesToBundle(java.lang.String, java.lang.String, android.os.Bundle):void");
+    }
+
+    public final String handleResponse(Bundle bundle) {
+        if (bundle == null) {
+            throw new IOException("SERVICE_NOT_AVAILABLE");
+        }
+        String string = bundle.getString("registration_id");
+        if (string != null) {
+            return string;
+        }
+        String string2 = bundle.getString("unregistered");
+        if (string2 != null) {
+            return string2;
+        }
+        String string3 = bundle.getString("error");
+        if ("RST".equals(string3)) {
+            throw new IOException("INSTANCE_ID_RESET");
+        }
+        if (string3 != null) {
+            throw new IOException(string3);
+        }
+        Log.w("FirebaseMessaging", "Unexpected response: " + bundle, new Throwable());
+        throw new IOException("SERVICE_NOT_AVAILABLE");
+    }
+
+    public final Task extractResponseWhenComplete(Task task) {
+        return task.continueWith(new CredentialManager$$ExternalSyntheticLambda0(), new Continuation() { // from class: com.google.firebase.messaging.GmsRpc$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task2) {
+                String lambda$extractResponseWhenComplete$0;
+                lambda$extractResponseWhenComplete$0 = GmsRpc.this.lambda$extractResponseWhenComplete$0(task2);
+                return lambda$extractResponseWhenComplete$0;
+            }
+        });
+    }
+
+    public final /* synthetic */ String lambda$extractResponseWhenComplete$0(Task task) {
+        return handleResponse((Bundle) task.getResult(IOException.class));
+    }
+
+    public static boolean isErrorMessageForRetryableError(String str) {
+        return "SERVICE_NOT_AVAILABLE".equals(str) || "INTERNAL_SERVER_ERROR".equals(str) || "InternalServerError".equals(str);
+    }
+}

decompiled/sources/com/google/firebase/messaging/ImageDownload.java

@@ -0,0 +1,121 @@
+package com.google.firebase.messaging;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.text.TextUtils;
+import android.util.Log;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+/* loaded from: classes3.dex */
+public class ImageDownload implements Closeable {
+    public volatile Future future;
+    public Task task;
+    public final URL url;
+
+    public static ImageDownload create(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return new ImageDownload(new URL(str));
+        } catch (MalformedURLException unused) {
+            Log.w("FirebaseMessaging", "Not downloading image, bad URL: " + str);
+            return null;
+        }
+    }
+
+    public ImageDownload(URL url) {
+        this.url = url;
+    }
+
+    public void start(ExecutorService executorService) {
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.future = executorService.submit(new Runnable() { // from class: com.google.firebase.messaging.ImageDownload$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                ImageDownload.this.lambda$start$0(taskCompletionSource);
+            }
+        });
+        this.task = taskCompletionSource.getTask();
+    }
+
+    public final /* synthetic */ void lambda$start$0(TaskCompletionSource taskCompletionSource) {
+        try {
+            taskCompletionSource.setResult(blockingDownload());
+        } catch (Exception e) {
+            taskCompletionSource.setException(e);
+        }
+    }
+
+    public Task getTask() {
+        return (Task) Preconditions.checkNotNull(this.task);
+    }
+
+    public Bitmap blockingDownload() {
+        if (Log.isLoggable("FirebaseMessaging", 4)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("Starting download of: ");
+            sb.append(this.url);
+        }
+        byte[] blockingDownloadBytes = blockingDownloadBytes();
+        Bitmap decodeByteArray = BitmapFactory.decodeByteArray(blockingDownloadBytes, 0, blockingDownloadBytes.length);
+        if (decodeByteArray == null) {
+            throw new IOException("Failed to decode image: " + this.url);
+        }
+        if (Log.isLoggable("FirebaseMessaging", 3)) {
+            StringBuilder sb2 = new StringBuilder();
+            sb2.append("Successfully downloaded image: ");
+            sb2.append(this.url);
+        }
+        return decodeByteArray;
+    }
+
+    public final byte[] blockingDownloadBytes() {
+        URLConnection openConnection = this.url.openConnection();
+        if (openConnection.getContentLength() > 1048576) {
+            throw new IOException("Content-Length exceeds max size of 1048576");
+        }
+        InputStream inputStream = openConnection.getInputStream();
+        try {
+            byte[] byteArray = ByteStreams.toByteArray(ByteStreams.limit(inputStream, 1048577L));
+            if (inputStream != null) {
+                inputStream.close();
+            }
+            if (Log.isLoggable("FirebaseMessaging", 2)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Downloaded ");
+                sb.append(byteArray.length);
+                sb.append(" bytes from ");
+                sb.append(this.url);
+            }
+            if (byteArray.length <= 1048576) {
+                return byteArray;
+            }
+            throw new IOException("Image exceeds max size of 1048576");
+        } catch (Throwable th) {
+            if (inputStream != null) {
+                try {
+                    inputStream.close();
+                } catch (Throwable th2) {
+                    th.addSuppressed(th2);
+                }
+            }
+            throw th;
+        }
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        this.future.cancel(true);
+    }
+}

decompiled/sources/com/google/firebase/messaging/MessagingAnalytics.java

@@ -0,0 +1,372 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import com.ea.eadp.pushnotification.forwarding.FCMMessageService;
+import com.facebook.internal.security.CertificateUtil;
+import com.facebook.share.internal.ShareConstants;
+import com.google.android.datatransport.Encoding;
+import com.google.android.datatransport.Event;
+import com.google.android.datatransport.ProductData;
+import com.google.android.datatransport.Transformer;
+import com.google.android.datatransport.TransportFactory;
+import com.google.android.gms.measurement.AppMeasurement;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.analytics.connector.AnalyticsConnector;
+import com.google.firebase.installations.FirebaseInstallations;
+import com.google.firebase.messaging.reporting.MessagingClientEvent;
+import com.google.firebase.messaging.reporting.MessagingClientEventExtension;
+import com.mbridge.msdk.interstitial.view.MBInterstitialActivity;
+import java.util.concurrent.ExecutionException;
+
+/* loaded from: classes3.dex */
+public abstract class MessagingAnalytics {
+    public static void logNotificationReceived(Intent intent) {
+        if (shouldUploadScionMetrics(intent)) {
+            logToScion("_nr", intent.getExtras());
+        }
+        if (shouldUploadFirelogAnalytics(intent)) {
+            logToFirelog(MessagingClientEvent.Event.MESSAGE_DELIVERED, intent, FirebaseMessaging.getTransportFactory());
+        }
+    }
+
+    public static void logNotificationOpen(Bundle bundle) {
+        setUserPropertyIfRequired(bundle);
+        logToScion("_no", bundle);
+    }
+
+    public static void logNotificationDismiss(Intent intent) {
+        logToScion("_nd", intent.getExtras());
+    }
+
+    public static void logNotificationForeground(Intent intent) {
+        logToScion("_nf", intent.getExtras());
+    }
+
+    public static boolean shouldUploadScionMetrics(Intent intent) {
+        if (intent == null || isDirectBootMessage(intent)) {
+            return false;
+        }
+        return shouldUploadScionMetrics(intent.getExtras());
+    }
+
+    public static boolean shouldUploadScionMetrics(Bundle bundle) {
+        if (bundle == null) {
+            return false;
+        }
+        return "1".equals(bundle.getString("google.c.a.e"));
+    }
+
+    public static boolean shouldUploadFirelogAnalytics(Intent intent) {
+        if (intent == null || isDirectBootMessage(intent)) {
+            return false;
+        }
+        return deliveryMetricsExportToBigQueryEnabled();
+    }
+
+    public static boolean isDirectBootMessage(Intent intent) {
+        return FirebaseMessagingService.ACTION_DIRECT_BOOT_REMOTE_INTENT.equals(intent.getAction());
+    }
+
+    public static boolean deliveryMetricsExportToBigQueryEnabled() {
+        Context applicationContext;
+        SharedPreferences sharedPreferences;
+        ApplicationInfo applicationInfo;
+        Bundle bundle;
+        try {
+            FirebaseApp.getInstance();
+            applicationContext = FirebaseApp.getInstance().getApplicationContext();
+            sharedPreferences = applicationContext.getSharedPreferences("com.google.firebase.messaging", 0);
+        } catch (PackageManager.NameNotFoundException | IllegalStateException unused) {
+        }
+        if (sharedPreferences.contains("export_to_big_query")) {
+            return sharedPreferences.getBoolean("export_to_big_query", false);
+        }
+        PackageManager packageManager = applicationContext.getPackageManager();
+        if (packageManager != null && (applicationInfo = packageManager.getApplicationInfo(applicationContext.getPackageName(), 128)) != null && (bundle = applicationInfo.metaData) != null && bundle.containsKey("delivery_metrics_exported_to_big_query_enabled")) {
+            return applicationInfo.metaData.getBoolean("delivery_metrics_exported_to_big_query_enabled", false);
+        }
+        return false;
+    }
+
+    public static void setUserPropertyIfRequired(Bundle bundle) {
+        if (bundle == null) {
+            return;
+        }
+        if ("1".equals(bundle.getString("google.c.a.tc"))) {
+            AnalyticsConnector analyticsConnector = (AnalyticsConnector) FirebaseApp.getInstance().get(AnalyticsConnector.class);
+            Log.isLoggable("FirebaseMessaging", 3);
+            if (analyticsConnector != null) {
+                String string = bundle.getString("google.c.a.c_id");
+                analyticsConnector.setUserProperty(AppMeasurement.FCM_ORIGIN, "_ln", string);
+                Bundle bundle2 = new Bundle();
+                bundle2.putString(ShareConstants.FEED_SOURCE_PARAM, "Firebase");
+                bundle2.putString("medium", "notification");
+                bundle2.putString(MBInterstitialActivity.INTENT_CAMAPIGN, string);
+                analyticsConnector.logEvent(AppMeasurement.FCM_ORIGIN, "_cmp", bundle2);
+                return;
+            }
+            Log.w("FirebaseMessaging", "Unable to set user property for conversion tracking:  analytics library is missing");
+            return;
+        }
+        Log.isLoggable("FirebaseMessaging", 3);
+    }
+
+    public static void logToScion(String str, Bundle bundle) {
+        try {
+            FirebaseApp.getInstance();
+            if (bundle == null) {
+                bundle = new Bundle();
+            }
+            Bundle bundle2 = new Bundle();
+            String composerId = getComposerId(bundle);
+            if (composerId != null) {
+                bundle2.putString("_nmid", composerId);
+            }
+            String composerLabel = getComposerLabel(bundle);
+            if (composerLabel != null) {
+                bundle2.putString("_nmn", composerLabel);
+            }
+            String messageLabel = getMessageLabel(bundle);
+            if (!TextUtils.isEmpty(messageLabel)) {
+                bundle2.putString("label", messageLabel);
+            }
+            String messageChannel = getMessageChannel(bundle);
+            if (!TextUtils.isEmpty(messageChannel)) {
+                bundle2.putString("message_channel", messageChannel);
+            }
+            String topic = getTopic(bundle);
+            if (topic != null) {
+                bundle2.putString("_nt", topic);
+            }
+            String messageTime = getMessageTime(bundle);
+            if (messageTime != null) {
+                try {
+                    bundle2.putInt("_nmt", Integer.parseInt(messageTime));
+                } catch (NumberFormatException e) {
+                    Log.w("FirebaseMessaging", "Error while parsing timestamp in GCM event", e);
+                }
+            }
+            String useDeviceTime = getUseDeviceTime(bundle);
+            if (useDeviceTime != null) {
+                try {
+                    bundle2.putInt("_ndt", Integer.parseInt(useDeviceTime));
+                } catch (NumberFormatException e2) {
+                    Log.w("FirebaseMessaging", "Error while parsing use_device_time in GCM event", e2);
+                }
+            }
+            String messageTypeForScion = getMessageTypeForScion(bundle);
+            if ("_nr".equals(str) || "_nf".equals(str)) {
+                bundle2.putString("_nmc", messageTypeForScion);
+            }
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Logging to scion event=");
+                sb.append(str);
+                sb.append(" scionPayload=");
+                sb.append(bundle2);
+            }
+            AnalyticsConnector analyticsConnector = (AnalyticsConnector) FirebaseApp.getInstance().get(AnalyticsConnector.class);
+            if (analyticsConnector != null) {
+                analyticsConnector.logEvent(AppMeasurement.FCM_ORIGIN, str, bundle2);
+            } else {
+                Log.w("FirebaseMessaging", "Unable to log event: analytics library is missing");
+            }
+        } catch (IllegalStateException unused) {
+            Log.e("FirebaseMessaging", "Default FirebaseApp has not been initialized. Skip logging event to GA.");
+        }
+    }
+
+    public static void logToFirelog(MessagingClientEvent.Event event, Intent intent, TransportFactory transportFactory) {
+        if (transportFactory == null) {
+            Log.e("FirebaseMessaging", "TransportFactory is null. Skip exporting message delivery metrics to Big Query");
+            return;
+        }
+        MessagingClientEvent eventToProto = eventToProto(event, intent);
+        if (eventToProto == null) {
+            return;
+        }
+        try {
+            transportFactory.getTransport("FCM_CLIENT_EVENT_LOGGING", MessagingClientEventExtension.class, Encoding.of("proto"), new Transformer() { // from class: com.google.firebase.messaging.MessagingAnalytics$$ExternalSyntheticLambda0
+                @Override // com.google.android.datatransport.Transformer
+                public final Object apply(Object obj) {
+                    return ((MessagingClientEventExtension) obj).toByteArray();
+                }
+            }).send(Event.ofData(MessagingClientEventExtension.newBuilder().setMessagingClientEvent(eventToProto).build(), ProductData.withProductId(Integer.valueOf(intent.getIntExtra("google.product_id", 111881503)))));
+        } catch (RuntimeException e) {
+            Log.w("FirebaseMessaging", "Failed to send big query analytics payload.", e);
+        }
+    }
+
+    public static int getTtl(Bundle bundle) {
+        Object obj = bundle.get("google.ttl");
+        if (obj instanceof Integer) {
+            return ((Integer) obj).intValue();
+        }
+        if (!(obj instanceof String)) {
+            return 0;
+        }
+        try {
+            return Integer.parseInt((String) obj);
+        } catch (NumberFormatException unused) {
+            Log.w("FirebaseMessaging", "Invalid TTL: " + obj);
+            return 0;
+        }
+    }
+
+    public static String getCollapseKey(Bundle bundle) {
+        return bundle.getString(FCMMessageService.PushIntentExtraKeys.COLLAPSE_KEY);
+    }
+
+    public static String getComposerId(Bundle bundle) {
+        return bundle.getString("google.c.a.c_id");
+    }
+
+    public static String getComposerLabel(Bundle bundle) {
+        return bundle.getString("google.c.a.c_l");
+    }
+
+    public static String getMessageLabel(Bundle bundle) {
+        return bundle.getString("google.c.a.m_l");
+    }
+
+    public static String getMessageChannel(Bundle bundle) {
+        return bundle.getString("google.c.a.m_c");
+    }
+
+    public static String getMessageTime(Bundle bundle) {
+        return bundle.getString("google.c.a.ts");
+    }
+
+    public static String getMessageId(Bundle bundle) {
+        String string = bundle.getString("google.message_id");
+        return string == null ? bundle.getString("message_id") : string;
+    }
+
+    public static String getPackageName() {
+        return FirebaseApp.getInstance().getApplicationContext().getPackageName();
+    }
+
+    public static String getInstanceId(Bundle bundle) {
+        String string = bundle.getString("google.to");
+        if (!TextUtils.isEmpty(string)) {
+            return string;
+        }
+        try {
+            return (String) Tasks.await(FirebaseInstallations.getInstance(FirebaseApp.getInstance()).getId());
+        } catch (InterruptedException | ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String getMessageTypeForScion(Bundle bundle) {
+        return (bundle == null || !NotificationParams.isNotification(bundle)) ? "data" : "display";
+    }
+
+    public static MessagingClientEvent.MessageType getMessageTypeForFirelog(Bundle bundle) {
+        if (bundle != null && NotificationParams.isNotification(bundle)) {
+            return MessagingClientEvent.MessageType.DISPLAY_NOTIFICATION;
+        }
+        return MessagingClientEvent.MessageType.DATA_MESSAGE;
+    }
+
+    public static String getTopic(Bundle bundle) {
+        String string = bundle.getString("from");
+        if (string == null || !string.startsWith("/topics/")) {
+            return null;
+        }
+        return string;
+    }
+
+    public static String getUseDeviceTime(Bundle bundle) {
+        if (bundle.containsKey("google.c.a.udt")) {
+            return bundle.getString("google.c.a.udt");
+        }
+        return null;
+    }
+
+    public static long getProjectNumber(Bundle bundle) {
+        if (bundle.containsKey("google.c.sender.id")) {
+            try {
+                return Long.parseLong(bundle.getString("google.c.sender.id"));
+            } catch (NumberFormatException e) {
+                Log.w("FirebaseMessaging", "error parsing project number", e);
+            }
+        }
+        FirebaseApp firebaseApp = FirebaseApp.getInstance();
+        String gcmSenderId = firebaseApp.getOptions().getGcmSenderId();
+        if (gcmSenderId != null) {
+            try {
+                return Long.parseLong(gcmSenderId);
+            } catch (NumberFormatException e2) {
+                Log.w("FirebaseMessaging", "error parsing sender ID", e2);
+            }
+        }
+        String applicationId = firebaseApp.getOptions().getApplicationId();
+        if (!applicationId.startsWith("1:")) {
+            try {
+                return Long.parseLong(applicationId);
+            } catch (NumberFormatException e3) {
+                Log.w("FirebaseMessaging", "error parsing app ID", e3);
+            }
+        } else {
+            String[] split = applicationId.split(CertificateUtil.DELIMITER);
+            if (split.length < 2) {
+                return 0L;
+            }
+            String str = split[1];
+            if (str.isEmpty()) {
+                return 0L;
+            }
+            try {
+                return Long.parseLong(str);
+            } catch (NumberFormatException e4) {
+                Log.w("FirebaseMessaging", "error parsing app ID", e4);
+            }
+        }
+        return 0L;
+    }
+
+    public static MessagingClientEvent eventToProto(MessagingClientEvent.Event event, Intent intent) {
+        if (intent == null) {
+            return null;
+        }
+        Bundle extras = intent.getExtras();
+        if (extras == null) {
+            extras = Bundle.EMPTY;
+        }
+        MessagingClientEvent.Builder messageType = MessagingClientEvent.newBuilder().setTtl(getTtl(extras)).setEvent(event).setInstanceId(getInstanceId(extras)).setPackageName(getPackageName()).setSdkPlatform(MessagingClientEvent.SDKPlatform.ANDROID).setMessageType(getMessageTypeForFirelog(extras));
+        String messageId = getMessageId(extras);
+        if (messageId != null) {
+            messageType.setMessageId(messageId);
+        }
+        String topic = getTopic(extras);
+        if (topic != null) {
+            messageType.setTopic(topic);
+        }
+        String collapseKey = getCollapseKey(extras);
+        if (collapseKey != null) {
+            messageType.setCollapseKey(collapseKey);
+        }
+        String messageLabel = getMessageLabel(extras);
+        if (messageLabel != null) {
+            messageType.setAnalyticsLabel(messageLabel);
+        }
+        String composerLabel = getComposerLabel(extras);
+        if (composerLabel != null) {
+            messageType.setComposerLabel(composerLabel);
+        }
+        long projectNumber = getProjectNumber(extras);
+        if (projectNumber > 0) {
+            messageType.setProjectNumber(projectNumber);
+        }
+        return messageType.build();
+    }
+}

decompiled/sources/com/google/firebase/messaging/Metadata.java

@@ -0,0 +1,135 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.util.Log;
+import com.facebook.internal.security.CertificateUtil;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.firebase.FirebaseApp;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public class Metadata {
+    public String appVersionCode;
+    public String appVersionName;
+    public final Context context;
+    public int gmsVersionCode;
+    public int iidImplementation = 0;
+
+    public Metadata(Context context) {
+        this.context = context;
+    }
+
+    public boolean isGmscorePresent() {
+        return getIidImplementation() != 0;
+    }
+
+    public synchronized int getIidImplementation() {
+        int i = this.iidImplementation;
+        if (i != 0) {
+            return i;
+        }
+        PackageManager packageManager = this.context.getPackageManager();
+        if (packageManager.checkPermission("com.google.android.c2dm.permission.SEND", "com.google.android.gms") == -1) {
+            Log.e("FirebaseMessaging", "Google Play services missing or without correct permission.");
+            return 0;
+        }
+        if (!PlatformVersion.isAtLeastO()) {
+            Intent intent = new Intent("com.google.android.c2dm.intent.REGISTER");
+            intent.setPackage("com.google.android.gms");
+            List<ResolveInfo> queryIntentServices = packageManager.queryIntentServices(intent, 0);
+            if (queryIntentServices != null && queryIntentServices.size() > 0) {
+                this.iidImplementation = 1;
+                return 1;
+            }
+        }
+        Intent intent2 = new Intent("com.google.iid.TOKEN_REQUEST");
+        intent2.setPackage("com.google.android.gms");
+        List<ResolveInfo> queryBroadcastReceivers = packageManager.queryBroadcastReceivers(intent2, 0);
+        if (queryBroadcastReceivers != null && queryBroadcastReceivers.size() > 0) {
+            this.iidImplementation = 2;
+            return 2;
+        }
+        Log.w("FirebaseMessaging", "Failed to resolve IID implementation package, falling back");
+        if (PlatformVersion.isAtLeastO()) {
+            this.iidImplementation = 2;
+        } else {
+            this.iidImplementation = 1;
+        }
+        return this.iidImplementation;
+    }
+
+    public static String getDefaultSenderId(FirebaseApp firebaseApp) {
+        String gcmSenderId = firebaseApp.getOptions().getGcmSenderId();
+        if (gcmSenderId != null) {
+            return gcmSenderId;
+        }
+        String applicationId = firebaseApp.getOptions().getApplicationId();
+        if (!applicationId.startsWith("1:")) {
+            return applicationId;
+        }
+        String[] split = applicationId.split(CertificateUtil.DELIMITER);
+        if (split.length < 2) {
+            return null;
+        }
+        String str = split[1];
+        if (str.isEmpty()) {
+            return null;
+        }
+        return str;
+    }
+
+    public synchronized String getAppVersionCode() {
+        try {
+            if (this.appVersionCode == null) {
+                populateAppVersionInfo();
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.appVersionCode;
+    }
+
+    public synchronized String getAppVersionName() {
+        try {
+            if (this.appVersionName == null) {
+                populateAppVersionInfo();
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.appVersionName;
+    }
+
+    public synchronized int getGmsVersionCode() {
+        PackageInfo packageInfo;
+        try {
+            if (this.gmsVersionCode == 0 && (packageInfo = getPackageInfo("com.google.android.gms")) != null) {
+                this.gmsVersionCode = packageInfo.versionCode;
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.gmsVersionCode;
+    }
+
+    public final synchronized void populateAppVersionInfo() {
+        PackageInfo packageInfo = getPackageInfo(this.context.getPackageName());
+        if (packageInfo != null) {
+            this.appVersionCode = Integer.toString(packageInfo.versionCode);
+            this.appVersionName = packageInfo.versionName;
+        }
+    }
+
+    public final PackageInfo getPackageInfo(String str) {
+        try {
+            return this.context.getPackageManager().getPackageInfo(str, 0);
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.w("FirebaseMessaging", "Failed to find package " + e);
+            return null;
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/NotificationParams.java

@@ -0,0 +1,274 @@
+package com.google.firebase.messaging;
+
+import android.content.res.Resources;
+import android.graphics.Color;
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import java.util.Arrays;
+import java.util.MissingFormatArgumentException;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+/* loaded from: classes3.dex */
+public class NotificationParams {
+    public final Bundle data;
+
+    public NotificationParams(Bundle bundle) {
+        if (bundle == null) {
+            throw new NullPointerException("data");
+        }
+        this.data = new Bundle(bundle);
+    }
+
+    public Integer getNotificationCount() {
+        Integer integer = getInteger("gcm.n.notification_count");
+        if (integer == null) {
+            return null;
+        }
+        if (integer.intValue() >= 0) {
+            return integer;
+        }
+        Log.w("FirebaseMessaging", "notificationCount is invalid: " + integer + ". Skipping setting notificationCount.");
+        return null;
+    }
+
+    public Integer getNotificationPriority() {
+        Integer integer = getInteger("gcm.n.notification_priority");
+        if (integer == null) {
+            return null;
+        }
+        if (integer.intValue() >= -2 && integer.intValue() <= 2) {
+            return integer;
+        }
+        Log.w("FirebaseMessaging", "notificationPriority is invalid " + integer + ". Skipping setting notificationPriority.");
+        return null;
+    }
+
+    public Integer getVisibility() {
+        Integer integer = getInteger("gcm.n.visibility");
+        if (integer == null) {
+            return null;
+        }
+        if (integer.intValue() >= -1 && integer.intValue() <= 1) {
+            return integer;
+        }
+        Log.w("NotificationParams", "visibility is invalid: " + integer + ". Skipping setting visibility.");
+        return null;
+    }
+
+    public String getString(String str) {
+        return this.data.getString(normalizePrefix(str));
+    }
+
+    public final String normalizePrefix(String str) {
+        if (!this.data.containsKey(str) && str.startsWith("gcm.n.")) {
+            String keyWithOldPrefix = keyWithOldPrefix(str);
+            if (this.data.containsKey(keyWithOldPrefix)) {
+                return keyWithOldPrefix;
+            }
+        }
+        return str;
+    }
+
+    public boolean getBoolean(String str) {
+        String string = getString(str);
+        return "1".equals(string) || Boolean.parseBoolean(string);
+    }
+
+    public Integer getInteger(String str) {
+        String string = getString(str);
+        if (TextUtils.isEmpty(string)) {
+            return null;
+        }
+        try {
+            return Integer.valueOf(Integer.parseInt(string));
+        } catch (NumberFormatException unused) {
+            Log.w("NotificationParams", "Couldn't parse value of " + userFriendlyKey(str) + "(" + string + ") into an int");
+            return null;
+        }
+    }
+
+    public Long getLong(String str) {
+        String string = getString(str);
+        if (TextUtils.isEmpty(string)) {
+            return null;
+        }
+        try {
+            return Long.valueOf(Long.parseLong(string));
+        } catch (NumberFormatException unused) {
+            Log.w("NotificationParams", "Couldn't parse value of " + userFriendlyKey(str) + "(" + string + ") into a long");
+            return null;
+        }
+    }
+
+    public String getLocalizationResourceForKey(String str) {
+        return getString(str + "_loc_key");
+    }
+
+    public Object[] getLocalizationArgsForKey(String str) {
+        JSONArray jSONArray = getJSONArray(str + "_loc_args");
+        if (jSONArray == null) {
+            return null;
+        }
+        int length = jSONArray.length();
+        String[] strArr = new String[length];
+        for (int i = 0; i < length; i++) {
+            strArr[i] = jSONArray.optString(i);
+        }
+        return strArr;
+    }
+
+    public JSONArray getJSONArray(String str) {
+        String string = getString(str);
+        if (TextUtils.isEmpty(string)) {
+            return null;
+        }
+        try {
+            return new JSONArray(string);
+        } catch (JSONException unused) {
+            Log.w("NotificationParams", "Malformed JSON for key " + userFriendlyKey(str) + ": " + string + ", falling back to default");
+            return null;
+        }
+    }
+
+    public static String userFriendlyKey(String str) {
+        return str.startsWith("gcm.n.") ? str.substring(6) : str;
+    }
+
+    public Uri getLink() {
+        String string = getString("gcm.n.link_android");
+        if (TextUtils.isEmpty(string)) {
+            string = getString("gcm.n.link");
+        }
+        if (TextUtils.isEmpty(string)) {
+            return null;
+        }
+        return Uri.parse(string);
+    }
+
+    public String getSoundResourceName() {
+        String string = getString("gcm.n.sound2");
+        return TextUtils.isEmpty(string) ? getString("gcm.n.sound") : string;
+    }
+
+    public long[] getVibrateTimings() {
+        JSONArray jSONArray = getJSONArray("gcm.n.vibrate_timings");
+        if (jSONArray == null) {
+            return null;
+        }
+        try {
+            if (jSONArray.length() <= 1) {
+                throw new JSONException("vibrateTimings have invalid length");
+            }
+            int length = jSONArray.length();
+            long[] jArr = new long[length];
+            for (int i = 0; i < length; i++) {
+                jArr[i] = jSONArray.optLong(i);
+            }
+            return jArr;
+        } catch (NumberFormatException | JSONException unused) {
+            Log.w("NotificationParams", "User defined vibrateTimings is invalid: " + jSONArray + ". Skipping setting vibrateTimings.");
+            return null;
+        }
+    }
+
+    public int[] getLightSettings() {
+        JSONArray jSONArray = getJSONArray("gcm.n.light_settings");
+        if (jSONArray == null) {
+            return null;
+        }
+        int[] iArr = new int[3];
+        try {
+            if (jSONArray.length() != 3) {
+                throw new JSONException("lightSettings don't have all three fields");
+            }
+            iArr[0] = getLightColor(jSONArray.optString(0));
+            iArr[1] = jSONArray.optInt(1);
+            iArr[2] = jSONArray.optInt(2);
+            return iArr;
+        } catch (IllegalArgumentException e) {
+            Log.w("NotificationParams", "LightSettings is invalid: " + jSONArray + ". " + e.getMessage() + ". Skipping setting LightSettings");
+            return null;
+        } catch (JSONException unused) {
+            Log.w("NotificationParams", "LightSettings is invalid: " + jSONArray + ". Skipping setting LightSettings");
+            return null;
+        }
+    }
+
+    public Bundle paramsWithReservedKeysRemoved() {
+        Bundle bundle = new Bundle(this.data);
+        for (String str : this.data.keySet()) {
+            if (isReservedKey(str)) {
+                bundle.remove(str);
+            }
+        }
+        return bundle;
+    }
+
+    public Bundle paramsForAnalyticsIntent() {
+        Bundle bundle = new Bundle(this.data);
+        for (String str : this.data.keySet()) {
+            if (!isAnalyticsKey(str)) {
+                bundle.remove(str);
+            }
+        }
+        return bundle;
+    }
+
+    public String getLocalizedString(Resources resources, String str, String str2) {
+        String localizationResourceForKey = getLocalizationResourceForKey(str2);
+        if (TextUtils.isEmpty(localizationResourceForKey)) {
+            return null;
+        }
+        int identifier = resources.getIdentifier(localizationResourceForKey, "string", str);
+        if (identifier == 0) {
+            Log.w("NotificationParams", userFriendlyKey(str2 + "_loc_key") + " resource not found: " + str2 + " Default value will be used.");
+            return null;
+        }
+        Object[] localizationArgsForKey = getLocalizationArgsForKey(str2);
+        if (localizationArgsForKey == null) {
+            return resources.getString(identifier);
+        }
+        try {
+            return resources.getString(identifier, localizationArgsForKey);
+        } catch (MissingFormatArgumentException e) {
+            Log.w("NotificationParams", "Missing format argument for " + userFriendlyKey(str2) + ": " + Arrays.toString(localizationArgsForKey) + " Default value will be used.", e);
+            return null;
+        }
+    }
+
+    public String getPossiblyLocalizedString(Resources resources, String str, String str2) {
+        String string = getString(str2);
+        return !TextUtils.isEmpty(string) ? string : getLocalizedString(resources, str, str2);
+    }
+
+    public String getNotificationChannelId() {
+        return getString("gcm.n.android_channel_id");
+    }
+
+    public static boolean isAnalyticsKey(String str) {
+        return str.startsWith("google.c.a.") || str.equals("from");
+    }
+
+    public static boolean isReservedKey(String str) {
+        return str.startsWith("google.c.") || str.startsWith("gcm.n.") || str.startsWith("gcm.notification.");
+    }
+
+    public static int getLightColor(String str) {
+        int parseColor = Color.parseColor(str);
+        if (parseColor != -16777216) {
+            return parseColor;
+        }
+        throw new IllegalArgumentException("Transparent color is invalid");
+    }
+
+    public static boolean isNotification(Bundle bundle) {
+        return "1".equals(bundle.getString("gcm.n.e")) || "1".equals(bundle.getString(keyWithOldPrefix("gcm.n.e")));
+    }
+
+    public static String keyWithOldPrefix(String str) {
+        return !str.startsWith("gcm.n.") ? str : str.replace("gcm.n.", "gcm.notification.");
+    }
+}

decompiled/sources/com/google/firebase/messaging/ProtoEncoderDoNotUse.java

@@ -0,0 +1,12 @@
+package com.google.firebase.messaging;
+
+import com.google.firebase.encoders.proto.ProtobufEncoder;
+
+/* loaded from: classes3.dex */
+public abstract class ProtoEncoderDoNotUse {
+    public static final ProtobufEncoder ENCODER = ProtobufEncoder.builder().configureWith(AutoProtoEncoderDoNotUseEncoder.CONFIG).build();
+
+    public static byte[] encode(Object obj) {
+        return ENCODER.encode(obj);
+    }
+}

decompiled/sources/com/google/firebase/messaging/ProxyNotificationInitializer$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package com.google.firebase.messaging;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class ProxyNotificationInitializer$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/com/google/firebase/messaging/ProxyNotificationInitializer$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package com.google.firebase.messaging;
+
+/* loaded from: classes3.dex */
+public abstract /* synthetic */ class ProxyNotificationInitializer$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/com/google/firebase/messaging/ProxyNotificationInitializer.java

@@ -0,0 +1,98 @@
+package com.google.firebase.messaging;
+
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Binder;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public abstract class ProxyNotificationInitializer {
+    public static Task setEnableProxyNotification(Executor executor, final Context context, final boolean z) {
+        if (!PlatformVersion.isAtLeastQ()) {
+            return Tasks.forResult(null);
+        }
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        executor.execute(new Runnable() { // from class: com.google.firebase.messaging.ProxyNotificationInitializer$$ExternalSyntheticLambda2
+            @Override // java.lang.Runnable
+            public final void run() {
+                ProxyNotificationInitializer.lambda$setEnableProxyNotification$0(context, z, taskCompletionSource);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    public static /* synthetic */ void lambda$setEnableProxyNotification$0(Context context, boolean z, TaskCompletionSource taskCompletionSource) {
+        String notificationDelegate;
+        try {
+            if (!allowedToUse(context)) {
+                Log.e("FirebaseMessaging", "error configuring notification delegate for package " + context.getPackageName());
+                return;
+            }
+            ProxyNotificationPreferences.setProxyNotificationsInitialized(context, true);
+            NotificationManager notificationManager = (NotificationManager) context.getSystemService(NotificationManager.class);
+            if (z) {
+                notificationManager.setNotificationDelegate("com.google.android.gms");
+            } else {
+                notificationDelegate = notificationManager.getNotificationDelegate();
+                if ("com.google.android.gms".equals(notificationDelegate)) {
+                    notificationManager.setNotificationDelegate(null);
+                }
+            }
+        } finally {
+            taskCompletionSource.trySetResult(null);
+        }
+    }
+
+    public static boolean isProxyNotificationEnabled(Context context) {
+        String notificationDelegate;
+        if (!PlatformVersion.isAtLeastQ()) {
+            Log.isLoggable("FirebaseMessaging", 3);
+            return false;
+        }
+        if (!allowedToUse(context)) {
+            Log.e("FirebaseMessaging", "error retrieving notification delegate for package " + context.getPackageName());
+            return false;
+        }
+        notificationDelegate = ((NotificationManager) context.getSystemService(NotificationManager.class)).getNotificationDelegate();
+        if (!"com.google.android.gms".equals(notificationDelegate)) {
+            return false;
+        }
+        Log.isLoggable("FirebaseMessaging", 3);
+        return true;
+    }
+
+    public static boolean shouldEnableProxyNotification(Context context) {
+        ApplicationInfo applicationInfo;
+        Bundle bundle;
+        try {
+            Context applicationContext = context.getApplicationContext();
+            PackageManager packageManager = applicationContext.getPackageManager();
+            if (packageManager == null || (applicationInfo = packageManager.getApplicationInfo(applicationContext.getPackageName(), 128)) == null || (bundle = applicationInfo.metaData) == null || !bundle.containsKey("firebase_messaging_notification_delegation_enabled")) {
+                return true;
+            }
+            return applicationInfo.metaData.getBoolean("firebase_messaging_notification_delegation_enabled");
+        } catch (PackageManager.NameNotFoundException unused) {
+            return true;
+        }
+    }
+
+    public static void initialize(Context context) {
+        if (ProxyNotificationPreferences.isProxyNotificationInitialized(context)) {
+            return;
+        }
+        setEnableProxyNotification(new CredentialManager$$ExternalSyntheticLambda0(), context, shouldEnableProxyNotification(context));
+    }
+
+    public static boolean allowedToUse(Context context) {
+        return Binder.getCallingUid() == context.getApplicationInfo().uid;
+    }
+}

decompiled/sources/com/google/firebase/messaging/ProxyNotificationPreferences.java

@@ -0,0 +1,49 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.tasks.OnSuccessListener;
+
+/* loaded from: classes3.dex */
+public abstract class ProxyNotificationPreferences {
+    public static SharedPreferences getPreference(Context context) {
+        Context applicationContext = context.getApplicationContext();
+        if (applicationContext != null) {
+            context = applicationContext;
+        }
+        return context.getSharedPreferences("com.google.firebase.messaging", 0);
+    }
+
+    public static void setProxyNotificationsInitialized(Context context, boolean z) {
+        SharedPreferences.Editor edit = getPreference(context).edit();
+        edit.putBoolean("proxy_notification_initialized", z);
+        edit.apply();
+    }
+
+    public static void setProxyRetention(final Context context, GmsRpc gmsRpc, final boolean z) {
+        if (PlatformVersion.isAtLeastQ() && !isProxyNotificationRetentionSet(getPreference(context), z)) {
+            gmsRpc.setRetainProxiedNotifications(z).addOnSuccessListener(new CredentialManager$$ExternalSyntheticLambda0(), new OnSuccessListener() { // from class: com.google.firebase.messaging.ProxyNotificationPreferences$$ExternalSyntheticLambda0
+                @Override // com.google.android.gms.tasks.OnSuccessListener
+                public final void onSuccess(Object obj) {
+                    ProxyNotificationPreferences.setProxyRetentionPreferences(context, z);
+                }
+            });
+        }
+    }
+
+    public static boolean isProxyNotificationInitialized(Context context) {
+        return getPreference(context).getBoolean("proxy_notification_initialized", false);
+    }
+
+    public static boolean isProxyNotificationRetentionSet(SharedPreferences sharedPreferences, boolean z) {
+        return sharedPreferences.contains("proxy_retention") && sharedPreferences.getBoolean("proxy_retention", false) == z;
+    }
+
+    public static void setProxyRetentionPreferences(Context context, boolean z) {
+        SharedPreferences.Editor edit = getPreference(context).edit();
+        edit.putBoolean("proxy_retention", z);
+        edit.apply();
+    }
+}

decompiled/sources/com/google/firebase/messaging/R$string.java

@@ -0,0 +1,6 @@
+package com.google.firebase.messaging;
+
+/* loaded from: classes3.dex */
+public final class R$string {
+    public static int fcm_fallback_notification_channel_label = 2131886342;
+}

decompiled/sources/com/google/firebase/messaging/RemoteMessage.java

@@ -0,0 +1,41 @@
+package com.google.firebase.messaging;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.firebase.messaging.Constants;
+import java.util.Map;
+
+@SafeParcelable.Class(creator = "RemoteMessageCreator")
+@SafeParcelable.Reserved({1})
+/* loaded from: classes3.dex */
+public final class RemoteMessage extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<RemoteMessage> CREATOR = new RemoteMessageCreator();
+    public Bundle bundle;
+    public Map data;
+
+    public RemoteMessage(Bundle bundle) {
+        this.bundle = bundle;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        RemoteMessageCreator.writeToParcel(this, parcel, i);
+    }
+
+    public Map getData() {
+        if (this.data == null) {
+            this.data = Constants.MessagePayloadKeys.extractDeveloperDefinedPayload(this.bundle);
+        }
+        return this.data;
+    }
+
+    public Intent toIntent() {
+        Intent intent = new Intent();
+        intent.putExtras(this.bundle);
+        return intent;
+    }
+}

decompiled/sources/com/google/firebase/messaging/RemoteMessageCreator.java

@@ -0,0 +1,37 @@
+package com.google.firebase.messaging;
+
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+
+/* loaded from: classes3.dex */
+public class RemoteMessageCreator implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public RemoteMessage createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        Bundle bundle = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) == 2) {
+                bundle = SafeParcelReader.createBundle(parcel, readHeader);
+            } else {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new RemoteMessage(bundle);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public RemoteMessage[] newArray(int i) {
+        return new RemoteMessage[i];
+    }
+
+    public static void writeToParcel(RemoteMessage remoteMessage, Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeBundle(parcel, 2, remoteMessage.bundle, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+}

decompiled/sources/com/google/firebase/messaging/RequestDeduplicator.java

@@ -0,0 +1,56 @@
+package com.google.firebase.messaging;
+
+import android.util.Log;
+import androidx.collection.ArrayMap;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+import java.util.Map;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public class RequestDeduplicator {
+    public final Executor executor;
+    public final Map getTokenRequests = new ArrayMap();
+
+    public interface GetTokenRequest {
+        Task start();
+    }
+
+    public RequestDeduplicator(Executor executor) {
+        this.executor = executor;
+    }
+
+    public synchronized Task getOrStartGetTokenRequest(final String str, GetTokenRequest getTokenRequest) {
+        Task task = (Task) this.getTokenRequests.get(str);
+        if (task != null) {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Joining ongoing request for: ");
+                sb.append(str);
+            }
+            return task;
+        }
+        if (Log.isLoggable("FirebaseMessaging", 3)) {
+            StringBuilder sb2 = new StringBuilder();
+            sb2.append("Making new request for: ");
+            sb2.append(str);
+        }
+        Task continueWithTask = getTokenRequest.start().continueWithTask(this.executor, new Continuation() { // from class: com.google.firebase.messaging.RequestDeduplicator$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task2) {
+                Task lambda$getOrStartGetTokenRequest$0;
+                lambda$getOrStartGetTokenRequest$0 = RequestDeduplicator.this.lambda$getOrStartGetTokenRequest$0(str, task2);
+                return lambda$getOrStartGetTokenRequest$0;
+            }
+        });
+        this.getTokenRequests.put(str, continueWithTask);
+        return continueWithTask;
+    }
+
+    public final /* synthetic */ Task lambda$getOrStartGetTokenRequest$0(String str, Task task) {
+        synchronized (this) {
+            this.getTokenRequests.remove(str);
+        }
+        return task;
+    }
+}

decompiled/sources/com/google/firebase/messaging/SendException.java

@@ -0,0 +1,24 @@
+package com.google.firebase.messaging;
+
+import java.util.Locale;
+
+/* loaded from: classes3.dex */
+public final class SendException extends Exception {
+    public final int errorCode;
+
+    public SendException(String str) {
+        super(str);
+        this.errorCode = parseErrorCode(str);
+    }
+
+    public final int parseErrorCode(String str) {
+        if (str == null) {
+            return 0;
+        }
+        String lowerCase = str.toLowerCase(Locale.US);
+        lowerCase.hashCode();
+        switch (lowerCase) {
+        }
+        return 0;
+    }
+}

decompiled/sources/com/google/firebase/messaging/ServiceStarter.java

@@ -0,0 +1,126 @@
+package com.google.firebase.messaging;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.util.Log;
+import csdk.gluads.Consts;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/* loaded from: classes3.dex */
+public class ServiceStarter {
+    public static ServiceStarter instance;
+    public String firebaseMessagingServiceClassName = null;
+    public Boolean hasWakeLockPermission = null;
+    public Boolean hasAccessNetworkStatePermission = null;
+    public final Queue messagingEvents = new ArrayDeque();
+
+    public static synchronized ServiceStarter getInstance() {
+        ServiceStarter serviceStarter;
+        synchronized (ServiceStarter.class) {
+            try {
+                if (instance == null) {
+                    instance = new ServiceStarter();
+                }
+                serviceStarter = instance;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return serviceStarter;
+    }
+
+    public Intent getMessagingEvent() {
+        return (Intent) this.messagingEvents.poll();
+    }
+
+    public int startMessagingService(Context context, Intent intent) {
+        Log.isLoggable("FirebaseMessaging", 3);
+        this.messagingEvents.offer(intent);
+        Intent intent2 = new Intent("com.google.firebase.MESSAGING_EVENT");
+        intent2.setPackage(context.getPackageName());
+        return doStartService(context, intent2);
+    }
+
+    public final int doStartService(Context context, Intent intent) {
+        ComponentName startService;
+        String resolveServiceClassName = resolveServiceClassName(context, intent);
+        if (resolveServiceClassName != null) {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Restricting intent to a specific service: ");
+                sb.append(resolveServiceClassName);
+            }
+            intent.setClassName(context.getPackageName(), resolveServiceClassName);
+        }
+        try {
+            if (hasWakeLockPermission(context)) {
+                startService = WakeLockHolder.startWakefulService(context, intent);
+            } else {
+                startService = context.startService(intent);
+            }
+            if (startService != null) {
+                return -1;
+            }
+            Log.e("FirebaseMessaging", "Error while delivering the message: ServiceIntent not found.");
+            return 404;
+        } catch (IllegalStateException e) {
+            Log.e("FirebaseMessaging", "Failed to start service while in background: " + e);
+            return 402;
+        } catch (SecurityException e2) {
+            Log.e("FirebaseMessaging", "Error while delivering the message to the serviceIntent", e2);
+            return 401;
+        }
+    }
+
+    public final synchronized String resolveServiceClassName(Context context, Intent intent) {
+        ServiceInfo serviceInfo;
+        String str;
+        try {
+            String str2 = this.firebaseMessagingServiceClassName;
+            if (str2 != null) {
+                return str2;
+            }
+            ResolveInfo resolveService = context.getPackageManager().resolveService(intent, 0);
+            if (resolveService != null && (serviceInfo = resolveService.serviceInfo) != null) {
+                if (context.getPackageName().equals(serviceInfo.packageName) && (str = serviceInfo.name) != null) {
+                    if (str.startsWith(Consts.STRING_PERIOD)) {
+                        this.firebaseMessagingServiceClassName = context.getPackageName() + serviceInfo.name;
+                    } else {
+                        this.firebaseMessagingServiceClassName = serviceInfo.name;
+                    }
+                    return this.firebaseMessagingServiceClassName;
+                }
+                Log.e("FirebaseMessaging", "Error resolving target intent service, skipping classname enforcement. Resolved service was: " + serviceInfo.packageName + "/" + serviceInfo.name);
+                return null;
+            }
+            Log.e("FirebaseMessaging", "Failed to resolve target intent service, skipping classname enforcement");
+            return null;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public boolean hasWakeLockPermission(Context context) {
+        if (this.hasWakeLockPermission == null) {
+            this.hasWakeLockPermission = Boolean.valueOf(context.checkCallingOrSelfPermission("android.permission.WAKE_LOCK") == 0);
+        }
+        if (!this.hasWakeLockPermission.booleanValue()) {
+            Log.isLoggable("FirebaseMessaging", 3);
+        }
+        return this.hasWakeLockPermission.booleanValue();
+    }
+
+    public boolean hasAccessNetworkStatePermission(Context context) {
+        if (this.hasAccessNetworkStatePermission == null) {
+            this.hasAccessNetworkStatePermission = Boolean.valueOf(context.checkCallingOrSelfPermission("android.permission.ACCESS_NETWORK_STATE") == 0);
+        }
+        if (!this.hasWakeLockPermission.booleanValue()) {
+            Log.isLoggable("FirebaseMessaging", 3);
+        }
+        return this.hasAccessNetworkStatePermission.booleanValue();
+    }
+}

decompiled/sources/com/google/firebase/messaging/SharedPreferencesQueue.java

@@ -0,0 +1,100 @@
+package com.google.firebase.messaging;
+
+import android.content.SharedPreferences;
+import android.text.TextUtils;
+import android.util.Log;
+import java.util.ArrayDeque;
+import java.util.Iterator;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public final class SharedPreferencesQueue {
+    public final String itemSeparator;
+    public final String queueName;
+    public final SharedPreferences sharedPreferences;
+    public final Executor syncExecutor;
+    public final ArrayDeque internalQueue = new ArrayDeque();
+    public boolean bulkOperation = false;
+
+    public SharedPreferencesQueue(SharedPreferences sharedPreferences, String str, String str2, Executor executor) {
+        this.sharedPreferences = sharedPreferences;
+        this.queueName = str;
+        this.itemSeparator = str2;
+        this.syncExecutor = executor;
+    }
+
+    public static SharedPreferencesQueue createInstance(SharedPreferences sharedPreferences, String str, String str2, Executor executor) {
+        SharedPreferencesQueue sharedPreferencesQueue = new SharedPreferencesQueue(sharedPreferences, str, str2, executor);
+        sharedPreferencesQueue.initQueue();
+        return sharedPreferencesQueue;
+    }
+
+    public final void initQueue() {
+        synchronized (this.internalQueue) {
+            try {
+                this.internalQueue.clear();
+                String string = this.sharedPreferences.getString(this.queueName, "");
+                if (!TextUtils.isEmpty(string) && string.contains(this.itemSeparator)) {
+                    String[] split = string.split(this.itemSeparator, -1);
+                    if (split.length == 0) {
+                        Log.e("FirebaseMessaging", "Corrupted queue. Please check the queue contents and item separator provided");
+                    }
+                    for (String str : split) {
+                        if (!TextUtils.isEmpty(str)) {
+                            this.internalQueue.add(str);
+                        }
+                    }
+                }
+            } finally {
+            }
+        }
+    }
+
+    public final boolean checkAndSyncState(boolean z) {
+        if (z && !this.bulkOperation) {
+            syncStateAsync();
+        }
+        return z;
+    }
+
+    public final void syncStateAsync() {
+        this.syncExecutor.execute(new Runnable() { // from class: com.google.firebase.messaging.SharedPreferencesQueue$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                SharedPreferencesQueue.this.syncState();
+            }
+        });
+    }
+
+    public final void syncState() {
+        synchronized (this.internalQueue) {
+            this.sharedPreferences.edit().putString(this.queueName, serialize()).commit();
+        }
+    }
+
+    public String serialize() {
+        StringBuilder sb = new StringBuilder();
+        Iterator it = this.internalQueue.iterator();
+        while (it.hasNext()) {
+            sb.append((String) it.next());
+            sb.append(this.itemSeparator);
+        }
+        return sb.toString();
+    }
+
+    public boolean remove(Object obj) {
+        boolean checkAndSyncState;
+        synchronized (this.internalQueue) {
+            checkAndSyncState = checkAndSyncState(this.internalQueue.remove(obj));
+        }
+        return checkAndSyncState;
+    }
+
+    public String peek() {
+        String str;
+        synchronized (this.internalQueue) {
+            str = (String) this.internalQueue.peek();
+        }
+        return str;
+    }
+}

decompiled/sources/com/google/firebase/messaging/Store.java

@@ -0,0 +1,115 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.core.content.ContextCompat;
+import androidx.webkit.ProxyConfig;
+import com.ironsource.v8;
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes3.dex */
+public class Store {
+    public final SharedPreferences store;
+
+    public Store(Context context) {
+        this.store = context.getSharedPreferences("com.google.android.gms.appid", 0);
+        checkForRestore(context, "com.google.android.gms.appid-no-backup");
+    }
+
+    public final void checkForRestore(Context context, String str) {
+        File file = new File(ContextCompat.getNoBackupFilesDir(context), str);
+        if (file.exists()) {
+            return;
+        }
+        try {
+            if (!file.createNewFile() || isEmpty()) {
+                return;
+            }
+            deleteAll();
+        } catch (IOException e) {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Error creating file in no backup dir: ");
+                sb.append(e.getMessage());
+            }
+        }
+    }
+
+    public synchronized boolean isEmpty() {
+        return this.store.getAll().isEmpty();
+    }
+
+    public final String createTokenKey(String str, String str2) {
+        return str + "|T|" + str2 + "|" + ProxyConfig.MATCH_ALL_SCHEMES;
+    }
+
+    public synchronized void deleteAll() {
+        this.store.edit().clear().commit();
+    }
+
+    public synchronized Token getToken(String str, String str2) {
+        return Token.parse(this.store.getString(createTokenKey(str, str2), null));
+    }
+
+    public synchronized void saveToken(String str, String str2, String str3, String str4) {
+        String encode = Token.encode(str3, str4, System.currentTimeMillis());
+        if (encode == null) {
+            return;
+        }
+        SharedPreferences.Editor edit = this.store.edit();
+        edit.putString(createTokenKey(str, str2), encode);
+        edit.commit();
+    }
+
+    public static class Token {
+        public static final long REFRESH_PERIOD_MILLIS = TimeUnit.DAYS.toMillis(7);
+        public final String appVersion;
+        public final long timestamp;
+        public final String token;
+
+        public Token(String str, String str2, long j) {
+            this.token = str;
+            this.appVersion = str2;
+            this.timestamp = j;
+        }
+
+        public static Token parse(String str) {
+            if (TextUtils.isEmpty(str)) {
+                return null;
+            }
+            if (str.startsWith("{")) {
+                try {
+                    JSONObject jSONObject = new JSONObject(str);
+                    return new Token(jSONObject.getString("token"), jSONObject.getString(v8.i.W), jSONObject.getLong("timestamp"));
+                } catch (JSONException e) {
+                    Log.w("FirebaseMessaging", "Failed to parse token: " + e);
+                    return null;
+                }
+            }
+            return new Token(str, null, 0L);
+        }
+
+        public static String encode(String str, String str2, long j) {
+            try {
+                JSONObject jSONObject = new JSONObject();
+                jSONObject.put("token", str);
+                jSONObject.put(v8.i.W, str2);
+                jSONObject.put("timestamp", j);
+                return jSONObject.toString();
+            } catch (JSONException e) {
+                Log.w("FirebaseMessaging", "Failed to encode token: " + e);
+                return null;
+            }
+        }
+
+        public boolean needsRefresh(String str) {
+            return System.currentTimeMillis() > this.timestamp + REFRESH_PERIOD_MILLIS || !str.equals(this.appVersion);
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/SyncTask.java

@@ -0,0 +1,142 @@
+package com.google.firebase.messaging;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.PowerManager;
+import android.util.Log;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class SyncTask implements Runnable {
+    public final FirebaseMessaging firebaseMessaging;
+    public final long nextDelaySeconds;
+    public ExecutorService processorExecutor = new ThreadPoolExecutor(0, 1, 30, TimeUnit.SECONDS, new LinkedBlockingQueue(), new NamedThreadFactory("firebase-iid-executor"));
+    public final PowerManager.WakeLock syncWakeLock;
+
+    public SyncTask(FirebaseMessaging firebaseMessaging, long j) {
+        this.firebaseMessaging = firebaseMessaging;
+        this.nextDelaySeconds = j;
+        PowerManager.WakeLock newWakeLock = ((PowerManager) getContext().getSystemService("power")).newWakeLock(1, "fiid-sync");
+        this.syncWakeLock = newWakeLock;
+        newWakeLock.setReferenceCounted(false);
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        if (ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+            this.syncWakeLock.acquire();
+        }
+        try {
+            try {
+                this.firebaseMessaging.setSyncScheduledOrRunning(true);
+            } catch (IOException e) {
+                Log.e("FirebaseMessaging", "Topic sync or token retrieval failed on hard failure exceptions: " + e.getMessage() + ". Won't retry the operation.");
+                this.firebaseMessaging.setSyncScheduledOrRunning(false);
+                if (!ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+                    return;
+                }
+            }
+            if (!this.firebaseMessaging.isGmsCorePresent()) {
+                this.firebaseMessaging.setSyncScheduledOrRunning(false);
+                if (ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+                    this.syncWakeLock.release();
+                    return;
+                }
+                return;
+            }
+            if (ServiceStarter.getInstance().hasAccessNetworkStatePermission(getContext()) && !isDeviceConnected()) {
+                new ConnectivityChangeReceiver(this).registerReceiver();
+                if (ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+                    this.syncWakeLock.release();
+                    return;
+                }
+                return;
+            }
+            if (maybeRefreshToken()) {
+                this.firebaseMessaging.setSyncScheduledOrRunning(false);
+            } else {
+                this.firebaseMessaging.syncWithDelaySecondsInternal(this.nextDelaySeconds);
+            }
+            if (!ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+                return;
+            }
+            this.syncWakeLock.release();
+        } catch (Throwable th) {
+            if (ServiceStarter.getInstance().hasWakeLockPermission(getContext())) {
+                this.syncWakeLock.release();
+            }
+            throw th;
+        }
+    }
+
+    public boolean maybeRefreshToken() {
+        try {
+            if (this.firebaseMessaging.blockingGetToken() == null) {
+                Log.e("FirebaseMessaging", "Token retrieval failed: null");
+                return false;
+            }
+            Log.isLoggable("FirebaseMessaging", 3);
+            return true;
+        } catch (IOException e) {
+            if (GmsRpc.isErrorMessageForRetryableError(e.getMessage())) {
+                Log.w("FirebaseMessaging", "Token retrieval failed: " + e.getMessage() + ". Will retry token retrieval");
+                return false;
+            }
+            if (e.getMessage() == null) {
+                Log.w("FirebaseMessaging", "Token retrieval failed without exception message. Will retry token retrieval");
+                return false;
+            }
+            throw e;
+        } catch (SecurityException unused) {
+            Log.w("FirebaseMessaging", "Token retrieval failed with SecurityException. Will retry token retrieval");
+            return false;
+        }
+    }
+
+    public Context getContext() {
+        return this.firebaseMessaging.getApplicationContext();
+    }
+
+    public boolean isDeviceConnected() {
+        ConnectivityManager connectivityManager = (ConnectivityManager) getContext().getSystemService("connectivity");
+        NetworkInfo activeNetworkInfo = connectivityManager != null ? connectivityManager.getActiveNetworkInfo() : null;
+        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
+    }
+
+    public static class ConnectivityChangeReceiver extends BroadcastReceiver {
+        public SyncTask task;
+
+        public ConnectivityChangeReceiver(SyncTask syncTask) {
+            this.task = syncTask;
+        }
+
+        public void registerReceiver() {
+            SyncTask.isDebugLogEnabled();
+            this.task.getContext().registerReceiver(this, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            SyncTask syncTask = this.task;
+            if (syncTask != null && syncTask.isDeviceConnected()) {
+                SyncTask.isDebugLogEnabled();
+                this.task.firebaseMessaging.enqueueTaskWithDelaySeconds(this.task, 0L);
+                this.task.getContext().unregisterReceiver(this);
+                this.task = null;
+            }
+        }
+    }
+
+    public static boolean isDebugLogEnabled() {
+        return Log.isLoggable("FirebaseMessaging", 3);
+    }
+}

decompiled/sources/com/google/firebase/messaging/TopicOperation.java

@@ -0,0 +1,66 @@
+package com.google.firebase.messaging;
+
+import android.text.TextUtils;
+import android.util.Log;
+import com.google.android.gms.common.internal.Objects;
+import java.util.regex.Pattern;
+
+/* loaded from: classes3.dex */
+public final class TopicOperation {
+    public static final Pattern TOPIC_NAME_REGEXP = Pattern.compile("[a-zA-Z0-9-_.~%]{1,900}");
+    public final String operation;
+    public final String serializedString;
+    public final String topic;
+
+    public String getOperation() {
+        return this.operation;
+    }
+
+    public String getTopic() {
+        return this.topic;
+    }
+
+    public String serialize() {
+        return this.serializedString;
+    }
+
+    public TopicOperation(String str, String str2) {
+        this.topic = normalizeTopicOrThrow(str2, str);
+        this.operation = str;
+        this.serializedString = str + "!" + str2;
+    }
+
+    public static String normalizeTopicOrThrow(String str, String str2) {
+        if (str != null && str.startsWith("/topics/")) {
+            Log.w("FirebaseMessaging", String.format("Format /topics/topic-name is deprecated. Only 'topic-name' should be used in %s.", str2));
+            str = str.substring(8);
+        }
+        if (str == null || !TOPIC_NAME_REGEXP.matcher(str).matches()) {
+            throw new IllegalArgumentException(String.format("Invalid topic name: %s does not match the allowed format %s.", str, "[a-zA-Z0-9-_.~%]{1,900}"));
+        }
+        return str;
+    }
+
+    public static TopicOperation from(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        String[] split = str.split("!", -1);
+        if (split.length != 2) {
+            return null;
+        }
+        return new TopicOperation(split[0], split[1]);
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TopicOperation)) {
+            return false;
+        }
+        TopicOperation topicOperation = (TopicOperation) obj;
+        return this.topic.equals(topicOperation.topic) && this.operation.equals(topicOperation.operation);
+    }
+
+    public int hashCode() {
+        return Objects.hashCode(this.operation, this.topic);
+    }
+}

decompiled/sources/com/google/firebase/messaging/TopicsStore.java

@@ -0,0 +1,49 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public final class TopicsStore {
+    public static WeakReference topicsStoreWeakReference;
+    public final SharedPreferences sharedPreferences;
+    public final Executor syncExecutor;
+    public SharedPreferencesQueue topicOperationsQueue;
+
+    public TopicsStore(SharedPreferences sharedPreferences, Executor executor) {
+        this.syncExecutor = executor;
+        this.sharedPreferences = sharedPreferences;
+    }
+
+    public final synchronized void initStore() {
+        this.topicOperationsQueue = SharedPreferencesQueue.createInstance(this.sharedPreferences, "topic_operation_queue", ",", this.syncExecutor);
+    }
+
+    public static synchronized TopicsStore getInstance(Context context, Executor executor) {
+        TopicsStore topicsStore;
+        synchronized (TopicsStore.class) {
+            try {
+                WeakReference weakReference = topicsStoreWeakReference;
+                topicsStore = weakReference != null ? (TopicsStore) weakReference.get() : null;
+                if (topicsStore == null) {
+                    topicsStore = new TopicsStore(context.getSharedPreferences("com.google.android.gms.appid", 0), executor);
+                    topicsStore.initStore();
+                    topicsStoreWeakReference = new WeakReference(topicsStore);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return topicsStore;
+    }
+
+    public synchronized TopicOperation getNextTopicOperation() {
+        return TopicOperation.from(this.topicOperationsQueue.peek());
+    }
+
+    public synchronized boolean removeTopicOperation(TopicOperation topicOperation) {
+        return this.topicOperationsQueue.remove(topicOperation.serialize());
+    }
+}

decompiled/sources/com/google/firebase/messaging/TopicsSubscriber.java

@@ -0,0 +1,272 @@
+package com.google.firebase.messaging;
+
+import android.content.Context;
+import android.util.Log;
+import androidx.collection.ArrayMap;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public class TopicsSubscriber {
+    public static final long MAX_DELAY_SEC = TimeUnit.HOURS.toSeconds(8);
+    public final Context context;
+    public final FirebaseMessaging firebaseMessaging;
+    public final Metadata metadata;
+    public final GmsRpc rpc;
+    public final TopicsStore store;
+    public final ScheduledExecutorService syncExecutor;
+    public final Map pendingOperations = new ArrayMap();
+    public boolean syncScheduledOrRunning = false;
+
+    public static Task createInstance(final FirebaseMessaging firebaseMessaging, final Metadata metadata, final GmsRpc gmsRpc, final Context context, final ScheduledExecutorService scheduledExecutorService) {
+        return Tasks.call(scheduledExecutorService, new Callable() { // from class: com.google.firebase.messaging.TopicsSubscriber$$ExternalSyntheticLambda0
+            @Override // java.util.concurrent.Callable
+            public final Object call() {
+                TopicsSubscriber lambda$createInstance$0;
+                lambda$createInstance$0 = TopicsSubscriber.lambda$createInstance$0(context, scheduledExecutorService, firebaseMessaging, metadata, gmsRpc);
+                return lambda$createInstance$0;
+            }
+        });
+    }
+
+    public static /* synthetic */ TopicsSubscriber lambda$createInstance$0(Context context, ScheduledExecutorService scheduledExecutorService, FirebaseMessaging firebaseMessaging, Metadata metadata, GmsRpc gmsRpc) {
+        return new TopicsSubscriber(firebaseMessaging, metadata, TopicsStore.getInstance(context, scheduledExecutorService), gmsRpc, context, scheduledExecutorService);
+    }
+
+    public TopicsSubscriber(FirebaseMessaging firebaseMessaging, Metadata metadata, TopicsStore topicsStore, GmsRpc gmsRpc, Context context, ScheduledExecutorService scheduledExecutorService) {
+        this.firebaseMessaging = firebaseMessaging;
+        this.metadata = metadata;
+        this.store = topicsStore;
+        this.rpc = gmsRpc;
+        this.context = context;
+        this.syncExecutor = scheduledExecutorService;
+    }
+
+    public boolean hasPendingOperation() {
+        return this.store.getNextTopicOperation() != null;
+    }
+
+    public void startTopicsSyncIfNecessary() {
+        if (hasPendingOperation()) {
+            startSync();
+        }
+    }
+
+    public final void startSync() {
+        if (isSyncScheduledOrRunning()) {
+            return;
+        }
+        syncWithDelaySecondsInternal(0L);
+    }
+
+    public void syncWithDelaySecondsInternal(long j) {
+        scheduleSyncTaskWithDelaySeconds(new TopicsSyncTask(this, this.context, this.metadata, Math.min(Math.max(30L, 2 * j), MAX_DELAY_SEC)), j);
+        setSyncScheduledOrRunning(true);
+    }
+
+    public void scheduleSyncTaskWithDelaySeconds(Runnable runnable, long j) {
+        this.syncExecutor.schedule(runnable, j, TimeUnit.SECONDS);
+    }
+
+    public boolean syncTopics() {
+        while (true) {
+            synchronized (this) {
+                try {
+                    TopicOperation nextTopicOperation = this.store.getNextTopicOperation();
+                    if (nextTopicOperation == null) {
+                        isDebugLogEnabled();
+                        return true;
+                    }
+                    if (!performTopicOperation(nextTopicOperation)) {
+                        return false;
+                    }
+                    this.store.removeTopicOperation(nextTopicOperation);
+                    markCompletePendingOperation(nextTopicOperation);
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    public final void markCompletePendingOperation(TopicOperation topicOperation) {
+        synchronized (this.pendingOperations) {
+            try {
+                String serialize = topicOperation.serialize();
+                if (this.pendingOperations.containsKey(serialize)) {
+                    ArrayDeque arrayDeque = (ArrayDeque) this.pendingOperations.get(serialize);
+                    TaskCompletionSource taskCompletionSource = (TaskCompletionSource) arrayDeque.poll();
+                    if (taskCompletionSource != null) {
+                        taskCompletionSource.setResult(null);
+                    }
+                    if (arrayDeque.isEmpty()) {
+                        this.pendingOperations.remove(serialize);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:11:0x002e  */
+    /* JADX WARN: Removed duplicated region for block: B:20:0x006b A[Catch: IOException -> 0x001d, TryCatch #0 {IOException -> 0x001d, blocks: (B:3:0x0001, B:12:0x0030, B:14:0x0036, B:17:0x0049, B:19:0x0056, B:20:0x006b, B:22:0x0078, B:23:0x0013, B:26:0x001f), top: B:2:0x0001 }] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public boolean performTopicOperation(com.google.firebase.messaging.TopicOperation r6) {
+        /*
+            r5 = this;
+            r0 = 0
+            java.lang.String r1 = r6.getOperation()     // Catch: java.io.IOException -> L1d
+            int r2 = r1.hashCode()     // Catch: java.io.IOException -> L1d
+            r3 = 83
+            r4 = 1
+            if (r2 == r3) goto L1f
+            r3 = 85
+            if (r2 == r3) goto L13
+            goto L29
+        L13:
+            java.lang.String r2 = "U"
+            boolean r1 = r1.equals(r2)     // Catch: java.io.IOException -> L1d
+            if (r1 == 0) goto L29
+            r1 = r4
+            goto L2a
+        L1d:
+            r6 = move-exception
+            goto L8d
+        L1f:
+            java.lang.String r2 = "S"
+            boolean r1 = r1.equals(r2)     // Catch: java.io.IOException -> L1d
+            if (r1 == 0) goto L29
+            r1 = r0
+            goto L2a
+        L29:
+            r1 = -1
+        L2a:
+            java.lang.String r2 = " succeeded."
+            if (r1 == 0) goto L6b
+            if (r1 == r4) goto L49
+            boolean r1 = isDebugLogEnabled()     // Catch: java.io.IOException -> L1d
+            if (r1 == 0) goto L8c
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder     // Catch: java.io.IOException -> L1d
+            r1.<init>()     // Catch: java.io.IOException -> L1d
+            java.lang.String r2 = "Unknown topic operation"
+            r1.append(r2)     // Catch: java.io.IOException -> L1d
+            r1.append(r6)     // Catch: java.io.IOException -> L1d
+            java.lang.String r6 = "."
+            r1.append(r6)     // Catch: java.io.IOException -> L1d
+            goto L8c
+        L49:
+            java.lang.String r1 = r6.getTopic()     // Catch: java.io.IOException -> L1d
+            r5.blockingUnsubscribeFromTopic(r1)     // Catch: java.io.IOException -> L1d
+            boolean r1 = isDebugLogEnabled()     // Catch: java.io.IOException -> L1d
+            if (r1 == 0) goto L8c
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder     // Catch: java.io.IOException -> L1d
+            r1.<init>()     // Catch: java.io.IOException -> L1d
+            java.lang.String r3 = "Unsubscribe from topic: "
+            r1.append(r3)     // Catch: java.io.IOException -> L1d
+            java.lang.String r6 = r6.getTopic()     // Catch: java.io.IOException -> L1d
+            r1.append(r6)     // Catch: java.io.IOException -> L1d
+            r1.append(r2)     // Catch: java.io.IOException -> L1d
+            goto L8c
+        L6b:
+            java.lang.String r1 = r6.getTopic()     // Catch: java.io.IOException -> L1d
+            r5.blockingSubscribeToTopic(r1)     // Catch: java.io.IOException -> L1d
+            boolean r1 = isDebugLogEnabled()     // Catch: java.io.IOException -> L1d
+            if (r1 == 0) goto L8c
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder     // Catch: java.io.IOException -> L1d
+            r1.<init>()     // Catch: java.io.IOException -> L1d
+            java.lang.String r3 = "Subscribe to topic: "
+            r1.append(r3)     // Catch: java.io.IOException -> L1d
+            java.lang.String r6 = r6.getTopic()     // Catch: java.io.IOException -> L1d
+            r1.append(r6)     // Catch: java.io.IOException -> L1d
+            r1.append(r2)     // Catch: java.io.IOException -> L1d
+        L8c:
+            return r4
+        L8d:
+            java.lang.String r1 = "SERVICE_NOT_AVAILABLE"
+            java.lang.String r2 = r6.getMessage()
+            boolean r1 = r1.equals(r2)
+            java.lang.String r2 = "FirebaseMessaging"
+            if (r1 != 0) goto Lb5
+            java.lang.String r1 = "INTERNAL_SERVER_ERROR"
+            java.lang.String r3 = r6.getMessage()
+            boolean r1 = r1.equals(r3)
+            if (r1 == 0) goto La8
+            goto Lb5
+        La8:
+            java.lang.String r1 = r6.getMessage()
+            if (r1 != 0) goto Lb4
+            java.lang.String r6 = "Topic operation failed without exception message. Will retry Topic operation."
+            android.util.Log.e(r2, r6)
+            return r0
+        Lb4:
+            throw r6
+        Lb5:
+            java.lang.StringBuilder r1 = new java.lang.StringBuilder
+            r1.<init>()
+            java.lang.String r3 = "Topic operation failed: "
+            r1.append(r3)
+            java.lang.String r6 = r6.getMessage()
+            r1.append(r6)
+            java.lang.String r6 = ". Will retry Topic operation."
+            r1.append(r6)
+            java.lang.String r6 = r1.toString()
+            android.util.Log.e(r2, r6)
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.firebase.messaging.TopicsSubscriber.performTopicOperation(com.google.firebase.messaging.TopicOperation):boolean");
+    }
+
+    public final void blockingSubscribeToTopic(String str) {
+        awaitTask(this.rpc.subscribeToTopic(this.firebaseMessaging.blockingGetToken(), str));
+    }
+
+    public final void blockingUnsubscribeFromTopic(String str) {
+        awaitTask(this.rpc.unsubscribeFromTopic(this.firebaseMessaging.blockingGetToken(), str));
+    }
+
+    public static void awaitTask(Task task) {
+        try {
+            Tasks.await(task, 30L, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            e = e;
+            throw new IOException("SERVICE_NOT_AVAILABLE", e);
+        } catch (ExecutionException e2) {
+            Throwable cause = e2.getCause();
+            if (cause instanceof IOException) {
+                throw ((IOException) cause);
+            }
+            if (cause instanceof RuntimeException) {
+                throw ((RuntimeException) cause);
+            }
+            throw new IOException(e2);
+        } catch (TimeoutException e3) {
+            e = e3;
+            throw new IOException("SERVICE_NOT_AVAILABLE", e);
+        }
+    }
+
+    public synchronized boolean isSyncScheduledOrRunning() {
+        return this.syncScheduledOrRunning;
+    }
+
+    public synchronized void setSyncScheduledOrRunning(boolean z) {
+        this.syncScheduledOrRunning = z;
+    }
+
+    public static boolean isDebugLogEnabled() {
+        return Log.isLoggable("FirebaseMessaging", 3);
+    }
+}

decompiled/sources/com/google/firebase/messaging/TopicsSyncTask.java

@@ -0,0 +1,195 @@
+package com.google.firebase.messaging;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.PowerManager;
+import android.util.Log;
+import java.io.IOException;
+
+/* loaded from: classes3.dex */
+public class TopicsSyncTask implements Runnable {
+    public static final Object TOPIC_SYNC_TASK_LOCK = new Object();
+    public static Boolean hasAccessNetworkStatePermission;
+    public static Boolean hasWakeLockPermission;
+    public final Context context;
+    public final Metadata metadata;
+    public final long nextDelaySeconds;
+    public final PowerManager.WakeLock syncWakeLock;
+    public final TopicsSubscriber topicsSubscriber;
+
+    public TopicsSyncTask(TopicsSubscriber topicsSubscriber, Context context, Metadata metadata, long j) {
+        this.topicsSubscriber = topicsSubscriber;
+        this.context = context;
+        this.nextDelaySeconds = j;
+        this.metadata = metadata;
+        this.syncWakeLock = ((PowerManager) context.getSystemService("power")).newWakeLock(1, "wake:com.google.firebase.messaging");
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        if (hasWakeLockPermission(this.context)) {
+            this.syncWakeLock.acquire(Constants.WAKE_LOCK_ACQUIRE_TIMEOUT_MILLIS);
+        }
+        try {
+            try {
+                this.topicsSubscriber.setSyncScheduledOrRunning(true);
+            } catch (Throwable th) {
+                if (hasWakeLockPermission(this.context)) {
+                    try {
+                        this.syncWakeLock.release();
+                    } catch (RuntimeException unused) {
+                    }
+                }
+                throw th;
+            }
+        } catch (IOException e) {
+            Log.e("FirebaseMessaging", "Failed to sync topics. Won't retry sync. " + e.getMessage());
+            this.topicsSubscriber.setSyncScheduledOrRunning(false);
+            if (!hasWakeLockPermission(this.context)) {
+                return;
+            }
+        }
+        if (!this.metadata.isGmscorePresent()) {
+            this.topicsSubscriber.setSyncScheduledOrRunning(false);
+            if (hasWakeLockPermission(this.context)) {
+                try {
+                    this.syncWakeLock.release();
+                    return;
+                } catch (RuntimeException unused2) {
+                    return;
+                }
+            }
+            return;
+        }
+        if (hasAccessNetworkStatePermission(this.context) && !isDeviceConnected()) {
+            new ConnectivityChangeReceiver(this).registerReceiver();
+            if (hasWakeLockPermission(this.context)) {
+                try {
+                    this.syncWakeLock.release();
+                    return;
+                } catch (RuntimeException unused3) {
+                    return;
+                }
+            }
+            return;
+        }
+        if (this.topicsSubscriber.syncTopics()) {
+            this.topicsSubscriber.setSyncScheduledOrRunning(false);
+        } else {
+            this.topicsSubscriber.syncWithDelaySecondsInternal(this.nextDelaySeconds);
+        }
+        if (!hasWakeLockPermission(this.context)) {
+            return;
+        }
+        try {
+            this.syncWakeLock.release();
+        } catch (RuntimeException unused4) {
+        }
+    }
+
+    public final synchronized boolean isDeviceConnected() {
+        boolean z;
+        try {
+            ConnectivityManager connectivityManager = (ConnectivityManager) this.context.getSystemService("connectivity");
+            NetworkInfo activeNetworkInfo = connectivityManager != null ? connectivityManager.getActiveNetworkInfo() : null;
+            if (activeNetworkInfo != null) {
+                z = activeNetworkInfo.isConnected();
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return z;
+    }
+
+    public static boolean isLoggable() {
+        return Log.isLoggable("FirebaseMessaging", 3);
+    }
+
+    public static boolean hasWakeLockPermission(Context context) {
+        boolean booleanValue;
+        boolean booleanValue2;
+        synchronized (TOPIC_SYNC_TASK_LOCK) {
+            try {
+                Boolean bool = hasWakeLockPermission;
+                if (bool == null) {
+                    booleanValue = hasPermission(context, "android.permission.WAKE_LOCK", bool);
+                } else {
+                    booleanValue = bool.booleanValue();
+                }
+                Boolean valueOf = Boolean.valueOf(booleanValue);
+                hasWakeLockPermission = valueOf;
+                booleanValue2 = valueOf.booleanValue();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return booleanValue2;
+    }
+
+    public static boolean hasAccessNetworkStatePermission(Context context) {
+        boolean booleanValue;
+        boolean booleanValue2;
+        synchronized (TOPIC_SYNC_TASK_LOCK) {
+            try {
+                Boolean bool = hasAccessNetworkStatePermission;
+                if (bool == null) {
+                    booleanValue = hasPermission(context, "android.permission.ACCESS_NETWORK_STATE", bool);
+                } else {
+                    booleanValue = bool.booleanValue();
+                }
+                Boolean valueOf = Boolean.valueOf(booleanValue);
+                hasAccessNetworkStatePermission = valueOf;
+                booleanValue2 = valueOf.booleanValue();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return booleanValue2;
+    }
+
+    public static boolean hasPermission(Context context, String str, Boolean bool) {
+        if (bool != null) {
+            return bool.booleanValue();
+        }
+        boolean z = context.checkCallingOrSelfPermission(str) == 0;
+        if (!z && Log.isLoggable("FirebaseMessaging", 3)) {
+            createPermissionMissingLog(str);
+        }
+        return z;
+    }
+
+    public static String createPermissionMissingLog(String str) {
+        return "Missing Permission: " + str + ". This permission should normally be included by the manifest merger, but may needed to be manually added to your manifest";
+    }
+
+    public class ConnectivityChangeReceiver extends BroadcastReceiver {
+        public TopicsSyncTask task;
+
+        public ConnectivityChangeReceiver(TopicsSyncTask topicsSyncTask) {
+            this.task = topicsSyncTask;
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public synchronized void onReceive(Context context, Intent intent) {
+            TopicsSyncTask topicsSyncTask = this.task;
+            if (topicsSyncTask == null) {
+                return;
+            }
+            if (topicsSyncTask.isDeviceConnected()) {
+                TopicsSyncTask.isLoggable();
+                this.task.topicsSubscriber.scheduleSyncTaskWithDelaySeconds(this.task, 0L);
+                context.unregisterReceiver(this);
+                this.task = null;
+            }
+        }
+
+        public void registerReceiver() {
+            TopicsSyncTask.isLoggable();
+            TopicsSyncTask.this.context.registerReceiver(this, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/WakeLockHolder.java

@@ -0,0 +1,86 @@
+package com.google.firebase.messaging;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import com.google.android.gms.stats.WakeLock;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public abstract class WakeLockHolder {
+    public static final long WAKE_LOCK_ACQUIRE_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(1);
+    public static final Object syncObject = new Object();
+    public static WakeLock wakeLock;
+
+    public static void checkAndInitWakeLock(Context context) {
+        if (wakeLock == null) {
+            WakeLock wakeLock2 = new WakeLock(context, 1, "wake:com.google.firebase.iid.WakeLockHolder");
+            wakeLock = wakeLock2;
+            wakeLock2.setReferenceCounted(true);
+        }
+    }
+
+    public static ComponentName startWakefulService(Context context, Intent intent) {
+        synchronized (syncObject) {
+            try {
+                checkAndInitWakeLock(context);
+                boolean isWakefulIntent = isWakefulIntent(intent);
+                setAsWakefulIntent(intent, true);
+                ComponentName startService = context.startService(intent);
+                if (startService == null) {
+                    return null;
+                }
+                if (!isWakefulIntent) {
+                    wakeLock.acquire(WAKE_LOCK_ACQUIRE_TIMEOUT_MILLIS);
+                }
+                return startService;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static void sendWakefulServiceIntent(Context context, WithinAppServiceConnection withinAppServiceConnection, final Intent intent) {
+        synchronized (syncObject) {
+            try {
+                checkAndInitWakeLock(context);
+                boolean isWakefulIntent = isWakefulIntent(intent);
+                setAsWakefulIntent(intent, true);
+                if (!isWakefulIntent) {
+                    wakeLock.acquire(WAKE_LOCK_ACQUIRE_TIMEOUT_MILLIS);
+                }
+                withinAppServiceConnection.sendIntent(intent).addOnCompleteListener(new OnCompleteListener() { // from class: com.google.firebase.messaging.WakeLockHolder$$ExternalSyntheticLambda0
+                    @Override // com.google.android.gms.tasks.OnCompleteListener
+                    public final void onComplete(Task task) {
+                        WakeLockHolder.completeWakefulIntent(intent);
+                    }
+                });
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static void setAsWakefulIntent(Intent intent, boolean z) {
+        intent.putExtra("com.google.firebase.iid.WakeLockHolder.wakefulintent", z);
+    }
+
+    public static boolean isWakefulIntent(Intent intent) {
+        return intent.getBooleanExtra("com.google.firebase.iid.WakeLockHolder.wakefulintent", false);
+    }
+
+    public static void completeWakefulIntent(Intent intent) {
+        synchronized (syncObject) {
+            try {
+                if (wakeLock != null && isWakefulIntent(intent)) {
+                    setAsWakefulIntent(intent, false);
+                    wakeLock.release();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/WithinAppServiceBinder.java

@@ -0,0 +1,36 @@
+package com.google.firebase.messaging;
+
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Process;
+import android.util.Log;
+import androidx.credentials.CredentialManager$$ExternalSyntheticLambda0;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.firebase.messaging.WithinAppServiceConnection;
+
+/* loaded from: classes3.dex */
+public class WithinAppServiceBinder extends Binder {
+    public final IntentHandler intentHandler;
+
+    public interface IntentHandler {
+        Task handle(Intent intent);
+    }
+
+    public WithinAppServiceBinder(IntentHandler intentHandler) {
+        this.intentHandler = intentHandler;
+    }
+
+    public void send(final WithinAppServiceConnection.BindRequest bindRequest) {
+        if (Binder.getCallingUid() != Process.myUid()) {
+            throw new SecurityException("Binding only allowed within app");
+        }
+        Log.isLoggable("FirebaseMessaging", 3);
+        this.intentHandler.handle(bindRequest.intent).addOnCompleteListener(new CredentialManager$$ExternalSyntheticLambda0(), new OnCompleteListener() { // from class: com.google.firebase.messaging.WithinAppServiceBinder$$ExternalSyntheticLambda0
+            @Override // com.google.android.gms.tasks.OnCompleteListener
+            public final void onComplete(Task task) {
+                WithinAppServiceConnection.BindRequest.this.finish();
+            }
+        });
+    }
+}

decompiled/sources/com/google/firebase/messaging/WithinAppServiceConnection.java

@@ -0,0 +1,168 @@
+package com.google.firebase.messaging;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import android.util.Log;
+import com.google.android.gms.common.stats.ConnectionTracker;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.firebase.messaging.WithinAppServiceConnection;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public class WithinAppServiceConnection implements ServiceConnection {
+    public WithinAppServiceBinder binder;
+    public boolean connectionInProgress;
+    public final Intent connectionIntent;
+    public final Context context;
+    public final Queue intentQueue;
+    public final ScheduledExecutorService scheduledExecutorService;
+
+    public static class BindRequest {
+        public final Intent intent;
+        public final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+
+        public BindRequest(Intent intent) {
+            this.intent = intent;
+        }
+
+        public void arrangeTimeout(ScheduledExecutorService scheduledExecutorService) {
+            final ScheduledFuture<?> schedule = scheduledExecutorService.schedule(new Runnable() { // from class: com.google.firebase.messaging.WithinAppServiceConnection$BindRequest$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    WithinAppServiceConnection.BindRequest.this.lambda$arrangeTimeout$0();
+                }
+            }, 20L, TimeUnit.SECONDS);
+            getTask().addOnCompleteListener(scheduledExecutorService, new OnCompleteListener() { // from class: com.google.firebase.messaging.WithinAppServiceConnection$BindRequest$$ExternalSyntheticLambda1
+                @Override // com.google.android.gms.tasks.OnCompleteListener
+                public final void onComplete(Task task) {
+                    schedule.cancel(false);
+                }
+            });
+        }
+
+        public final /* synthetic */ void lambda$arrangeTimeout$0() {
+            Log.w("FirebaseMessaging", "Service took too long to process intent: " + this.intent.getAction() + " finishing.");
+            finish();
+        }
+
+        public Task getTask() {
+            return this.taskCompletionSource.getTask();
+        }
+
+        public void finish() {
+            this.taskCompletionSource.trySetResult(null);
+        }
+    }
+
+    public WithinAppServiceConnection(Context context, String str) {
+        this(context, str, new ScheduledThreadPoolExecutor(0, new NamedThreadFactory("Firebase-FirebaseInstanceIdServiceConnection")));
+    }
+
+    public WithinAppServiceConnection(Context context, String str, ScheduledExecutorService scheduledExecutorService) {
+        this.intentQueue = new ArrayDeque();
+        this.connectionInProgress = false;
+        Context applicationContext = context.getApplicationContext();
+        this.context = applicationContext;
+        this.connectionIntent = new Intent(str).setPackage(applicationContext.getPackageName());
+        this.scheduledExecutorService = scheduledExecutorService;
+    }
+
+    public synchronized Task sendIntent(Intent intent) {
+        BindRequest bindRequest;
+        Log.isLoggable("FirebaseMessaging", 3);
+        bindRequest = new BindRequest(intent);
+        bindRequest.arrangeTimeout(this.scheduledExecutorService);
+        this.intentQueue.add(bindRequest);
+        flushQueue();
+        return bindRequest.getTask();
+    }
+
+    public final synchronized void flushQueue() {
+        try {
+            Log.isLoggable("FirebaseMessaging", 3);
+            while (!this.intentQueue.isEmpty()) {
+                Log.isLoggable("FirebaseMessaging", 3);
+                WithinAppServiceBinder withinAppServiceBinder = this.binder;
+                if (withinAppServiceBinder != null && withinAppServiceBinder.isBinderAlive()) {
+                    Log.isLoggable("FirebaseMessaging", 3);
+                    this.binder.send((BindRequest) this.intentQueue.poll());
+                } else {
+                    startConnectionIfNeeded();
+                    return;
+                }
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public final void startConnectionIfNeeded() {
+        if (Log.isLoggable("FirebaseMessaging", 3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("binder is dead. start connection? ");
+            sb.append(!this.connectionInProgress);
+        }
+        if (this.connectionInProgress) {
+            return;
+        }
+        this.connectionInProgress = true;
+        try {
+        } catch (SecurityException e) {
+            Log.e("FirebaseMessaging", "Exception while binding the service", e);
+        }
+        if (ConnectionTracker.getInstance().bindService(this.context, this.connectionIntent, this, 65)) {
+            return;
+        }
+        Log.e("FirebaseMessaging", "binding to the service failed");
+        this.connectionInProgress = false;
+        finishAllInQueue();
+    }
+
+    public final void finishAllInQueue() {
+        while (!this.intentQueue.isEmpty()) {
+            ((BindRequest) this.intentQueue.poll()).finish();
+        }
+    }
+
+    @Override // android.content.ServiceConnection
+    public synchronized void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+        try {
+            if (Log.isLoggable("FirebaseMessaging", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("onServiceConnected: ");
+                sb.append(componentName);
+            }
+            this.connectionInProgress = false;
+            if (!(iBinder instanceof WithinAppServiceBinder)) {
+                Log.e("FirebaseMessaging", "Invalid service connection: " + iBinder);
+                finishAllInQueue();
+                return;
+            }
+            this.binder = (WithinAppServiceBinder) iBinder;
+            flushQueue();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // android.content.ServiceConnection
+    public void onServiceDisconnected(ComponentName componentName) {
+        if (Log.isLoggable("FirebaseMessaging", 3)) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("onServiceDisconnected: ");
+            sb.append(componentName);
+        }
+        flushQueue();
+    }
+}

decompiled/sources/com/google/firebase/messaging/ktx/FirebaseMessagingKtxRegistrar.java

@@ -0,0 +1,13 @@
+package com.google.firebase.messaging.ktx;
+
+import com.google.firebase.components.ComponentRegistrar;
+import java.util.List;
+import kotlin.collections.CollectionsKt__CollectionsKt;
+
+/* loaded from: classes3.dex */
+public final class FirebaseMessagingKtxRegistrar implements ComponentRegistrar {
+    @Override // com.google.firebase.components.ComponentRegistrar
+    public List getComponents() {
+        return CollectionsKt__CollectionsKt.emptyList();
+    }
+}

decompiled/sources/com/google/firebase/messaging/reporting/MessagingClientEvent.java

@@ -0,0 +1,240 @@
+package com.google.firebase.messaging.reporting;
+
+import com.google.firebase.encoders.proto.ProtoEnum;
+
+/* loaded from: classes3.dex */
+public final class MessagingClientEvent {
+    public static final MessagingClientEvent DEFAULT_INSTANCE = new Builder().build();
+    public final String analytics_label_;
+    public final long bulk_id_;
+    public final long campaign_id_;
+    public final String collapse_key_;
+    public final String composer_label_;
+    public final Event event_;
+    public final String instance_id_;
+    public final String message_id_;
+    public final MessageType message_type_;
+    public final String package_name_;
+    public final int priority_;
+    public final long project_number_;
+    public final SDKPlatform sdk_platform_;
+    public final String topic_;
+    public final int ttl_;
+
+    public String getAnalyticsLabel() {
+        return this.analytics_label_;
+    }
+
+    public long getBulkId() {
+        return this.bulk_id_;
+    }
+
+    public long getCampaignId() {
+        return this.campaign_id_;
+    }
+
+    public String getCollapseKey() {
+        return this.collapse_key_;
+    }
+
+    public String getComposerLabel() {
+        return this.composer_label_;
+    }
+
+    public Event getEvent() {
+        return this.event_;
+    }
+
+    public String getInstanceId() {
+        return this.instance_id_;
+    }
+
+    public String getMessageId() {
+        return this.message_id_;
+    }
+
+    public MessageType getMessageType() {
+        return this.message_type_;
+    }
+
+    public String getPackageName() {
+        return this.package_name_;
+    }
+
+    public int getPriority() {
+        return this.priority_;
+    }
+
+    public long getProjectNumber() {
+        return this.project_number_;
+    }
+
+    public SDKPlatform getSdkPlatform() {
+        return this.sdk_platform_;
+    }
+
+    public String getTopic() {
+        return this.topic_;
+    }
+
+    public int getTtl() {
+        return this.ttl_;
+    }
+
+    public MessagingClientEvent(long j, String str, String str2, MessageType messageType, SDKPlatform sDKPlatform, String str3, String str4, int i, int i2, String str5, long j2, Event event, String str6, long j3, String str7) {
+        this.project_number_ = j;
+        this.message_id_ = str;
+        this.instance_id_ = str2;
+        this.message_type_ = messageType;
+        this.sdk_platform_ = sDKPlatform;
+        this.package_name_ = str3;
+        this.collapse_key_ = str4;
+        this.priority_ = i;
+        this.ttl_ = i2;
+        this.topic_ = str5;
+        this.bulk_id_ = j2;
+        this.event_ = event;
+        this.analytics_label_ = str6;
+        this.campaign_id_ = j3;
+        this.composer_label_ = str7;
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public long project_number_ = 0;
+        public String message_id_ = "";
+        public String instance_id_ = "";
+        public MessageType message_type_ = MessageType.UNKNOWN;
+        public SDKPlatform sdk_platform_ = SDKPlatform.UNKNOWN_OS;
+        public String package_name_ = "";
+        public String collapse_key_ = "";
+        public int priority_ = 0;
+        public int ttl_ = 0;
+        public String topic_ = "";
+        public long bulk_id_ = 0;
+        public Event event_ = Event.UNKNOWN_EVENT;
+        public String analytics_label_ = "";
+        public long campaign_id_ = 0;
+        public String composer_label_ = "";
+
+        public Builder setAnalyticsLabel(String str) {
+            this.analytics_label_ = str;
+            return this;
+        }
+
+        public Builder setCollapseKey(String str) {
+            this.collapse_key_ = str;
+            return this;
+        }
+
+        public Builder setComposerLabel(String str) {
+            this.composer_label_ = str;
+            return this;
+        }
+
+        public Builder setEvent(Event event) {
+            this.event_ = event;
+            return this;
+        }
+
+        public Builder setInstanceId(String str) {
+            this.instance_id_ = str;
+            return this;
+        }
+
+        public Builder setMessageId(String str) {
+            this.message_id_ = str;
+            return this;
+        }
+
+        public Builder setMessageType(MessageType messageType) {
+            this.message_type_ = messageType;
+            return this;
+        }
+
+        public Builder setPackageName(String str) {
+            this.package_name_ = str;
+            return this;
+        }
+
+        public Builder setProjectNumber(long j) {
+            this.project_number_ = j;
+            return this;
+        }
+
+        public Builder setSdkPlatform(SDKPlatform sDKPlatform) {
+            this.sdk_platform_ = sDKPlatform;
+            return this;
+        }
+
+        public Builder setTopic(String str) {
+            this.topic_ = str;
+            return this;
+        }
+
+        public Builder setTtl(int i) {
+            this.ttl_ = i;
+            return this;
+        }
+
+        public MessagingClientEvent build() {
+            return new MessagingClientEvent(this.project_number_, this.message_id_, this.instance_id_, this.message_type_, this.sdk_platform_, this.package_name_, this.collapse_key_, this.priority_, this.ttl_, this.topic_, this.bulk_id_, this.event_, this.analytics_label_, this.campaign_id_, this.composer_label_);
+        }
+    }
+
+    public enum MessageType implements ProtoEnum {
+        UNKNOWN(0),
+        DATA_MESSAGE(1),
+        TOPIC(2),
+        DISPLAY_NOTIFICATION(3);
+
+        private final int number_;
+
+        @Override // com.google.firebase.encoders.proto.ProtoEnum
+        public int getNumber() {
+            return this.number_;
+        }
+
+        MessageType(int i) {
+            this.number_ = i;
+        }
+    }
+
+    public enum SDKPlatform implements ProtoEnum {
+        UNKNOWN_OS(0),
+        ANDROID(1),
+        IOS(2),
+        WEB(3);
+
+        private final int number_;
+
+        @Override // com.google.firebase.encoders.proto.ProtoEnum
+        public int getNumber() {
+            return this.number_;
+        }
+
+        SDKPlatform(int i) {
+            this.number_ = i;
+        }
+    }
+
+    public enum Event implements ProtoEnum {
+        UNKNOWN_EVENT(0),
+        MESSAGE_DELIVERED(1),
+        MESSAGE_OPEN(2);
+
+        private final int number_;
+
+        @Override // com.google.firebase.encoders.proto.ProtoEnum
+        public int getNumber() {
+            return this.number_;
+        }
+
+        Event(int i) {
+            this.number_ = i;
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/reporting/MessagingClientEventExtension.java

@@ -0,0 +1,38 @@
+package com.google.firebase.messaging.reporting;
+
+import com.google.firebase.messaging.ProtoEncoderDoNotUse;
+
+/* loaded from: classes3.dex */
+public final class MessagingClientEventExtension {
+    public static final MessagingClientEventExtension DEFAULT_INSTANCE = new Builder().build();
+    public final MessagingClientEvent messaging_client_event_;
+
+    public MessagingClientEvent getMessagingClientEventInternal() {
+        return this.messaging_client_event_;
+    }
+
+    public MessagingClientEventExtension(MessagingClientEvent messagingClientEvent) {
+        this.messaging_client_event_ = messagingClientEvent;
+    }
+
+    public byte[] toByteArray() {
+        return ProtoEncoderDoNotUse.encode(this);
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static final class Builder {
+        public MessagingClientEvent messaging_client_event_ = null;
+
+        public Builder setMessagingClientEvent(MessagingClientEvent messagingClientEvent) {
+            this.messaging_client_event_ = messagingClientEvent;
+            return this;
+        }
+
+        public MessagingClientEventExtension build() {
+            return new MessagingClientEventExtension(this.messaging_client_event_);
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/threads/ExecutorFactory.java

@@ -0,0 +1,9 @@
+package com.google.firebase.messaging.threads;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadFactory;
+
+/* loaded from: classes3.dex */
+public interface ExecutorFactory {
+    ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory, ThreadPriority threadPriority);
+}

decompiled/sources/com/google/firebase/messaging/threads/PoolableExecutors.java

@@ -0,0 +1,40 @@
+package com.google.firebase.messaging.threads;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public abstract class PoolableExecutors {
+    public static final ExecutorFactory DEFAULT_INSTANCE;
+    public static volatile ExecutorFactory instance;
+
+    public static ExecutorFactory factory() {
+        return instance;
+    }
+
+    static {
+        DefaultExecutorFactory defaultExecutorFactory = new DefaultExecutorFactory();
+        DEFAULT_INSTANCE = defaultExecutorFactory;
+        instance = defaultExecutorFactory;
+    }
+
+    public static class DefaultExecutorFactory implements ExecutorFactory {
+        public DefaultExecutorFactory() {
+        }
+
+        public ExecutorService newThreadPool(int i, ThreadFactory threadFactory, ThreadPriority threadPriority) {
+            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(i, i, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(), threadFactory);
+            threadPoolExecutor.allowCoreThreadTimeOut(true);
+            return Executors.unconfigurableExecutorService(threadPoolExecutor);
+        }
+
+        @Override // com.google.firebase.messaging.threads.ExecutorFactory
+        public ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory, ThreadPriority threadPriority) {
+            return newThreadPool(1, threadFactory, threadPriority);
+        }
+    }
+}

decompiled/sources/com/google/firebase/messaging/threads/ThreadPriority.java

@@ -0,0 +1,7 @@
+package com.google.firebase.messaging.threads;
+
+/* loaded from: classes3.dex */
+public enum ThreadPriority {
+    LOW_POWER,
+    HIGH_SPEED
+}