Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/com/google/android/gms/cloudmessaging/CloudMessage.java

@@ -0,0 +1,173 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.firebase.messaging.Constants;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Map;
+import s.j;
+
+@SafeParcelable.Class(creator = "CloudMessageCreator")
+/* loaded from: classes3.dex */
+public final class CloudMessage extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<CloudMessage> CREATOR = new zzb();
+    public static final int PRIORITY_HIGH = 1;
+    public static final int PRIORITY_NORMAL = 2;
+    public static final int PRIORITY_UNKNOWN = 0;
+
+    @SafeParcelable.Field(id = 1)
+    final Intent zza;
+    private Map zzb;
+
+    @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
+    @Retention(RetentionPolicy.SOURCE)
+    /* loaded from: classes3.dex */
+    public @interface MessagePriority {
+    }
+
+    @SafeParcelable.Constructor
+    public CloudMessage(@SafeParcelable.Param(id = 1) Intent intent) {
+        this.zza = intent;
+    }
+
+    private static int zzb(String str) {
+        if (zza.zza(str, "high")) {
+            return 1;
+        }
+        return zza.zza(str, "normal") ? 2 : 0;
+    }
+
+    public String getCollapseKey() {
+        return this.zza.getStringExtra(Constants.MessagePayloadKeys.COLLAPSE_KEY);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [java.util.Map, s.j] */
+    public synchronized Map<String, String> getData() {
+        try {
+            if (this.zzb == null) {
+                Bundle extras = this.zza.getExtras();
+                ?? jVar = new j(0);
+                if (extras != null) {
+                    for (String str : extras.keySet()) {
+                        Object obj = extras.get(str);
+                        if (obj instanceof String) {
+                            String str2 = (String) obj;
+                            if (!str.startsWith(Constants.MessagePayloadKeys.RESERVED_PREFIX) && !str.equals(Constants.MessagePayloadKeys.FROM) && !str.equals(Constants.MessagePayloadKeys.MESSAGE_TYPE) && !str.equals(Constants.MessagePayloadKeys.COLLAPSE_KEY)) {
+                                jVar.put(str, str2);
+                            }
+                        }
+                    }
+                }
+                this.zzb = jVar;
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.zzb;
+    }
+
+    public String getFrom() {
+        return this.zza.getStringExtra(Constants.MessagePayloadKeys.FROM);
+    }
+
+    public Intent getIntent() {
+        return this.zza;
+    }
+
+    public String getMessageId() {
+        String stringExtra = this.zza.getStringExtra(Constants.MessagePayloadKeys.MSGID);
+        return stringExtra == null ? this.zza.getStringExtra(Constants.MessagePayloadKeys.MSGID_SERVER) : stringExtra;
+    }
+
+    public String getMessageType() {
+        return this.zza.getStringExtra(Constants.MessagePayloadKeys.MESSAGE_TYPE);
+    }
+
+    public int getOriginalPriority() {
+        String stringExtra = this.zza.getStringExtra(Constants.MessagePayloadKeys.ORIGINAL_PRIORITY);
+        if (stringExtra == null) {
+            stringExtra = this.zza.getStringExtra(Constants.MessagePayloadKeys.PRIORITY_V19);
+        }
+        return zzb(stringExtra);
+    }
+
+    public int getPriority() {
+        String stringExtra = this.zza.getStringExtra(Constants.MessagePayloadKeys.DELIVERED_PRIORITY);
+        if (stringExtra == null) {
+            if (zza.zza(this.zza.getStringExtra(Constants.MessagePayloadKeys.PRIORITY_REDUCED_V19), "1")) {
+                return 2;
+            }
+            stringExtra = this.zza.getStringExtra(Constants.MessagePayloadKeys.PRIORITY_V19);
+        }
+        return zzb(stringExtra);
+    }
+
+    public byte[] getRawData() {
+        return this.zza.getByteArrayExtra(Constants.MessagePayloadKeys.RAW_DATA);
+    }
+
+    public String getSenderId() {
+        return this.zza.getStringExtra(Constants.MessagePayloadKeys.SENDER_ID);
+    }
+
+    public long getSentTime() {
+        Bundle extras = this.zza.getExtras();
+        Object obj = extras != null ? extras.get(Constants.MessagePayloadKeys.SENT_TIME) : null;
+        if (obj instanceof Long) {
+            return ((Long) obj).longValue();
+        }
+        if (!(obj instanceof String)) {
+            return 0L;
+        }
+        try {
+            return Long.parseLong((String) obj);
+        } catch (NumberFormatException unused) {
+            Log.w("CloudMessage", "Invalid sent time: ".concat(String.valueOf(obj)));
+            return 0L;
+        }
+    }
+
+    public String getTo() {
+        return this.zza.getStringExtra(Constants.MessagePayloadKeys.TO);
+    }
+
+    public int getTtl() {
+        Bundle extras = this.zza.getExtras();
+        Object obj = extras != null ? extras.get(Constants.MessagePayloadKeys.TTL) : null;
+        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("CloudMessage", "Invalid TTL: ".concat(String.valueOf(obj)));
+            return 0;
+        }
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeParcelable(parcel, 1, this.zza, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public final Integer zza() {
+        if (this.zza.hasExtra(Constants.MessagePayloadKeys.PRODUCT_ID)) {
+            return Integer.valueOf(this.zza.getIntExtra(Constants.MessagePayloadKeys.PRODUCT_ID, 0));
+        }
+        return null;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/CloudMessagingReceiver.java

@@ -0,0 +1,150 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.text.TextUtils;
+import android.util.Log;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.messaging.Constants;
+import com.google.firebase.messaging.ServiceStarter;
+import java.lang.ref.SoftReference;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public abstract class CloudMessagingReceiver extends BroadcastReceiver {
+    private static SoftReference zza;
+
+    /* loaded from: classes3.dex */
+    public static final class IntentActionKeys {
+        public static final String NOTIFICATION_DISMISS = "com.google.firebase.messaging.NOTIFICATION_DISMISS";
+        public static final String NOTIFICATION_OPEN = "com.google.firebase.messaging.NOTIFICATION_OPEN";
+
+        private IntentActionKeys() {
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class IntentKeys {
+        public static final String PENDING_INTENT = "pending_intent";
+        public static final String WRAPPED_INTENT = "wrapped_intent";
+
+        private IntentKeys() {
+        }
+    }
+
+    private final int zzb(Context context, Intent intent) {
+        Task zzc;
+        if (intent.getExtras() == null) {
+            return ServiceStarter.ERROR_UNKNOWN;
+        }
+        CloudMessage cloudMessage = new CloudMessage(intent);
+        if (TextUtils.isEmpty(cloudMessage.getMessageId())) {
+            zzc = Tasks.forResult(null);
+        } else {
+            Bundle bundle = new Bundle();
+            bundle.putString(Constants.MessagePayloadKeys.MSGID, cloudMessage.getMessageId());
+            Integer zza2 = cloudMessage.zza();
+            if (zza2 != null) {
+                bundle.putInt(Constants.MessagePayloadKeys.PRODUCT_ID, zza2.intValue());
+            }
+            bundle.putBoolean("supports_message_handled", true);
+            zzc = zzu.zzb(context).zzc(2, bundle);
+        }
+        int onMessageReceive = onMessageReceive(context, cloudMessage);
+        try {
+            Tasks.await(zzc, TimeUnit.SECONDS.toMillis(1L), TimeUnit.MILLISECONDS);
+            return onMessageReceive;
+        } catch (InterruptedException | ExecutionException | TimeoutException e4) {
+            Log.w("CloudMessagingReceiver", "Message ack failed: ".concat(e4.toString()));
+            return onMessageReceive;
+        }
+    }
+
+    private final int zzc(Context context, Intent intent) {
+        PendingIntent pendingIntent = (PendingIntent) intent.getParcelableExtra(IntentKeys.PENDING_INTENT);
+        if (pendingIntent != null) {
+            try {
+                pendingIntent.send();
+            } catch (PendingIntent.CanceledException unused) {
+                Log.e("CloudMessagingReceiver", "Notification pending intent canceled");
+            }
+        }
+        Bundle extras = intent.getExtras();
+        if (extras != null) {
+            extras.remove(IntentKeys.PENDING_INTENT);
+        } else {
+            extras = new Bundle();
+        }
+        String action = intent.getAction();
+        if (action == IntentActionKeys.NOTIFICATION_DISMISS || (action != null && action.equals(IntentActionKeys.NOTIFICATION_DISMISS))) {
+            onNotificationDismissed(context, extras);
+            return -1;
+        }
+        Log.e("CloudMessagingReceiver", "Unknown notification action");
+        return ServiceStarter.ERROR_UNKNOWN;
+    }
+
+    public Executor getBroadcastExecutor() {
+        ExecutorService executorService;
+        synchronized (CloudMessagingReceiver.class) {
+            try {
+                SoftReference softReference = zza;
+                executorService = softReference != null ? (ExecutorService) softReference.get() : null;
+                if (executorService == null) {
+                    com.google.android.gms.internal.cloudmessaging.zze.zza();
+                    executorService = Executors.unconfigurableExecutorService(Executors.newCachedThreadPool(new NamedThreadFactory("firebase-iid-executor")));
+                    zza = new SoftReference(executorService);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return executorService;
+    }
+
+    public abstract int onMessageReceive(Context context, CloudMessage cloudMessage);
+
+    public void onNotificationDismissed(Context context, Bundle bundle) {
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public final void onReceive(final Context context, final Intent intent) {
+        if (intent == null) {
+            return;
+        }
+        final boolean isOrderedBroadcast = isOrderedBroadcast();
+        final BroadcastReceiver.PendingResult goAsync = goAsync();
+        getBroadcastExecutor().execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzf
+            @Override // java.lang.Runnable
+            public final void run() {
+                CloudMessagingReceiver.this.zza(intent, context, isOrderedBroadcast, goAsync);
+            }
+        });
+    }
+
+    public final /* synthetic */ void zza(Intent intent, Context context, boolean z3, BroadcastReceiver.PendingResult pendingResult) {
+        try {
+            Parcelable parcelableExtra = intent.getParcelableExtra(IntentKeys.WRAPPED_INTENT);
+            Intent intent2 = parcelableExtra instanceof Intent ? (Intent) parcelableExtra : null;
+            int zzc = intent2 != null ? zzc(context, intent2) : zzb(context, intent);
+            if (z3) {
+                pendingResult.setResultCode(zzc);
+            }
+            pendingResult.finish();
+        } catch (Throwable th) {
+            pendingResult.finish();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/IMessengerCompat.java

@@ -0,0 +1,61 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Message;
+import android.os.Parcel;
+import android.os.RemoteException;
+
+/* loaded from: classes3.dex */
+interface IMessengerCompat extends IInterface {
+    public static final String DESCRIPTOR = "com.google.android.gms.iid.IMessengerCompat";
+    public static final int TRANSACTION_SEND = 1;
+
+    /* loaded from: classes3.dex */
+    public static class Impl extends Binder implements IMessengerCompat {
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            throw null;
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, Parcel parcel, Parcel parcel2, int i4) throws RemoteException {
+            throw null;
+        }
+
+        @Override // com.google.android.gms.cloudmessaging.IMessengerCompat
+        public void send(Message message) throws RemoteException {
+            throw null;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static class Proxy implements IMessengerCompat {
+        private final IBinder zza;
+
+        public Proxy(IBinder iBinder) {
+            this.zza = iBinder;
+        }
+
+        @Override // android.os.IInterface
+        public IBinder asBinder() {
+            return this.zza;
+        }
+
+        @Override // com.google.android.gms.cloudmessaging.IMessengerCompat
+        public void send(Message message) throws RemoteException {
+            Parcel obtain = Parcel.obtain();
+            obtain.writeInterfaceToken(IMessengerCompat.DESCRIPTOR);
+            obtain.writeInt(1);
+            message.writeToParcel(obtain, 0);
+            try {
+                this.zza.transact(1, obtain, null, 1);
+            } finally {
+                obtain.recycle();
+            }
+        }
+    }
+
+    void send(Message message) throws RemoteException;
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/R.java

@@ -0,0 +1,7 @@
+package com.google.android.gms.cloudmessaging;
+
+/* loaded from: classes3.dex */
+public final class R {
+    private R() {
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/Rpc.java

@@ -0,0 +1,316 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.Parcelable;
+import android.os.RemoteException;
+import android.util.Log;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.OnCompleteListener;
+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.messaging.Constants;
+import java.io.IOException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import s.j;
+
+/* loaded from: classes3.dex */
+public class Rpc {
+    private static int zza;
+    private static PendingIntent zzb;
+    private static final Executor zzc = new Executor() { // from class: com.google.android.gms.cloudmessaging.zzy
+        @Override // java.util.concurrent.Executor
+        public final void execute(Runnable runnable) {
+            runnable.run();
+        }
+    };
+    private static final Pattern zzd = Pattern.compile("\\|ID\\|([^|]+)\\|:?+(.*)");
+    private final Context zzf;
+    private final zzv zzg;
+    private final ScheduledExecutorService zzh;
+    private Messenger zzj;
+    private zze zzk;
+    private final j zze = new j(0);
+    private final Messenger zzi = new Messenger(new zzad(this, Looper.getMainLooper()));
+
+    public Rpc(Context context) {
+        this.zzf = context;
+        this.zzg = new zzv(context);
+        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
+        scheduledThreadPoolExecutor.setKeepAliveTime(60L, TimeUnit.SECONDS);
+        scheduledThreadPoolExecutor.allowCoreThreadTimeOut(true);
+        this.zzh = scheduledThreadPoolExecutor;
+    }
+
+    public static /* synthetic */ Task zza(Bundle bundle) throws Exception {
+        return zzi(bundle) ? Tasks.forResult(null) : Tasks.forResult(bundle);
+    }
+
+    public static void zzc(Rpc rpc, Message message) {
+        if (message != null) {
+            Object obj = message.obj;
+            if (obj instanceof Intent) {
+                Intent intent = (Intent) obj;
+                intent.setExtrasClassLoader(new zzd());
+                if (intent.hasExtra("google.messenger")) {
+                    Parcelable parcelableExtra = intent.getParcelableExtra("google.messenger");
+                    if (parcelableExtra instanceof zze) {
+                        rpc.zzk = (zze) parcelableExtra;
+                    }
+                    if (parcelableExtra instanceof Messenger) {
+                        rpc.zzj = (Messenger) parcelableExtra;
+                    }
+                }
+                Intent intent2 = (Intent) message.obj;
+                String action = intent2.getAction();
+                if (!zzw.zza(action, "com.google.android.c2dm.intent.REGISTRATION")) {
+                    if (Log.isLoggable("Rpc", 3)) {
+                        Log.d("Rpc", "Unexpected response action: ".concat(String.valueOf(action)));
+                        return;
+                    }
+                    return;
+                }
+                String stringExtra = intent2.getStringExtra("registration_id");
+                if (stringExtra == null) {
+                    stringExtra = intent2.getStringExtra("unregistered");
+                }
+                if (stringExtra != null) {
+                    Matcher matcher = zzd.matcher(stringExtra);
+                    if (!matcher.matches()) {
+                        if (Log.isLoggable("Rpc", 3)) {
+                            Log.d("Rpc", "Unexpected response string: ".concat(stringExtra));
+                            return;
+                        }
+                        return;
+                    }
+                    String group = matcher.group(1);
+                    String group2 = matcher.group(2);
+                    if (group != null) {
+                        Bundle extras = intent2.getExtras();
+                        extras.putString("registration_id", group2);
+                        rpc.zzh(group, extras);
+                        return;
+                    }
+                    return;
+                }
+                String stringExtra2 = intent2.getStringExtra(Constants.IPC_BUNDLE_KEY_SEND_ERROR);
+                if (stringExtra2 == null) {
+                    Log.w("Rpc", "Unexpected response, no error or registration id ".concat(String.valueOf(intent2.getExtras())));
+                    return;
+                }
+                if (Log.isLoggable("Rpc", 3)) {
+                    Log.d("Rpc", "Received InstanceID error ".concat(stringExtra2));
+                }
+                if (!stringExtra2.startsWith("|")) {
+                    synchronized (rpc.zze) {
+                        int i = 0;
+                        while (true) {
+                            try {
+                                j jVar = rpc.zze;
+                                if (i < jVar.f8352c) {
+                                    rpc.zzh((String) jVar.f(i), intent2.getExtras());
+                                    i++;
+                                }
+                            } catch (Throwable th) {
+                                throw th;
+                            }
+                        }
+                    }
+                    return;
+                }
+                String[] split = stringExtra2.split("\\|");
+                if (split.length <= 2 || !zzw.zza(split[1], "ID")) {
+                    Log.w("Rpc", "Unexpected structured response ".concat(stringExtra2));
+                    return;
+                }
+                String str = split[2];
+                String str2 = split[3];
+                if (str2.startsWith(":")) {
+                    str2 = str2.substring(1);
+                }
+                rpc.zzh(str, intent2.putExtra(Constants.IPC_BUNDLE_KEY_SEND_ERROR, str2).getExtras());
+                return;
+            }
+        }
+        Log.w("Rpc", "Dropping invalid message");
+    }
+
+    private final Task zze(Bundle bundle) {
+        final String zzf = zzf();
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        synchronized (this.zze) {
+            this.zze.put(zzf, taskCompletionSource);
+        }
+        Intent intent = new Intent();
+        intent.setPackage("com.google.android.gms");
+        if (this.zzg.zzb() == 2) {
+            intent.setAction("com.google.iid.TOKEN_REQUEST");
+        } else {
+            intent.setAction("com.google.android.c2dm.intent.REGISTER");
+        }
+        intent.putExtras(bundle);
+        zzg(this.zzf, intent);
+        intent.putExtra("kid", "|ID|" + zzf + "|");
+        if (Log.isLoggable("Rpc", 3)) {
+            Log.d("Rpc", "Sending ".concat(String.valueOf(intent.getExtras())));
+        }
+        intent.putExtra("google.messenger", this.zzi);
+        if (this.zzj != null || this.zzk != null) {
+            Message obtain = Message.obtain();
+            obtain.obj = intent;
+            try {
+                Messenger messenger = this.zzj;
+                if (messenger != null) {
+                    messenger.send(obtain);
+                } else {
+                    this.zzk.zzb(obtain);
+                }
+            } catch (RemoteException unused) {
+                if (Log.isLoggable("Rpc", 3)) {
+                    Log.d("Rpc", "Messenger failed, fallback to startService");
+                }
+            }
+            final ScheduledFuture<?> schedule = this.zzh.schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzab
+                @Override // java.lang.Runnable
+                public final void run() {
+                    if (TaskCompletionSource.this.trySetException(new IOException("TIMEOUT"))) {
+                        Log.w("Rpc", "No response");
+                    }
+                }
+            }, 30L, TimeUnit.SECONDS);
+            taskCompletionSource.getTask().addOnCompleteListener(zzc, new OnCompleteListener() { // from class: com.google.android.gms.cloudmessaging.zzac
+                @Override // com.google.android.gms.tasks.OnCompleteListener
+                public final void onComplete(Task task) {
+                    Rpc.this.zzd(zzf, schedule, task);
+                }
+            });
+            return taskCompletionSource.getTask();
+        }
+        if (this.zzg.zzb() == 2) {
+            this.zzf.sendBroadcast(intent);
+        } else {
+            this.zzf.startService(intent);
+        }
+        final ScheduledFuture schedule2 = this.zzh.schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzab
+            @Override // java.lang.Runnable
+            public final void run() {
+                if (TaskCompletionSource.this.trySetException(new IOException("TIMEOUT"))) {
+                    Log.w("Rpc", "No response");
+                }
+            }
+        }, 30L, TimeUnit.SECONDS);
+        taskCompletionSource.getTask().addOnCompleteListener(zzc, new OnCompleteListener() { // from class: com.google.android.gms.cloudmessaging.zzac
+            @Override // com.google.android.gms.tasks.OnCompleteListener
+            public final void onComplete(Task task) {
+                Rpc.this.zzd(zzf, schedule2, task);
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    private static synchronized String zzf() {
+        String num;
+        synchronized (Rpc.class) {
+            int i = zza;
+            zza = i + 1;
+            num = Integer.toString(i);
+        }
+        return num;
+    }
+
+    private static synchronized void zzg(Context context, Intent intent) {
+        synchronized (Rpc.class) {
+            try {
+                if (zzb == null) {
+                    Intent intent2 = new Intent();
+                    intent2.setPackage("com.google.example.invalidpackage");
+                    zzb = PendingIntent.getBroadcast(context, 0, intent2, com.google.android.gms.internal.cloudmessaging.zza.zza);
+                }
+                intent.putExtra("app", zzb);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private final void zzh(String str, Bundle bundle) {
+        synchronized (this.zze) {
+            try {
+                TaskCompletionSource taskCompletionSource = (TaskCompletionSource) this.zze.remove(str);
+                if (taskCompletionSource != null) {
+                    taskCompletionSource.setResult(bundle);
+                    return;
+                }
+                Log.w("Rpc", "Missing callback for " + str);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private static boolean zzi(Bundle bundle) {
+        return bundle != null && bundle.containsKey("google.messenger");
+    }
+
+    public Task<Void> messageHandled(CloudMessage cloudMessage) {
+        if (this.zzg.zza() < 233700000) {
+            return Tasks.forException(new IOException("SERVICE_NOT_AVAILABLE"));
+        }
+        Bundle bundle = new Bundle();
+        bundle.putString(Constants.MessagePayloadKeys.MSGID, cloudMessage.getMessageId());
+        Integer zza2 = cloudMessage.zza();
+        if (zza2 != null) {
+            bundle.putInt(Constants.MessagePayloadKeys.PRODUCT_ID, zza2.intValue());
+        }
+        return zzu.zzb(this.zzf).zzc(3, bundle);
+    }
+
+    public Task<Bundle> send(final Bundle bundle) {
+        return this.zzg.zza() < 12000000 ? this.zzg.zzb() != 0 ? zze(bundle).continueWithTask(zzc, new Continuation() { // from class: com.google.android.gms.cloudmessaging.zzz
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task) {
+                return Rpc.this.zzb(bundle, task);
+            }
+        }) : Tasks.forException(new IOException("MISSING_INSTANCEID_SERVICE")) : zzu.zzb(this.zzf).zzd(1, bundle).continueWith(zzc, new Continuation() { // from class: com.google.android.gms.cloudmessaging.zzaa
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task) {
+                if (task.isSuccessful()) {
+                    return (Bundle) task.getResult();
+                }
+                if (Log.isLoggable("Rpc", 3)) {
+                    Log.d("Rpc", "Error making request: ".concat(String.valueOf(task.getException())));
+                }
+                throw new IOException("SERVICE_NOT_AVAILABLE", task.getException());
+            }
+        });
+    }
+
+    public final /* synthetic */ Task zzb(Bundle bundle, Task task) throws Exception {
+        return (task.isSuccessful() && zzi((Bundle) task.getResult())) ? zze(bundle).onSuccessTask(zzc, new SuccessContinuation() { // from class: com.google.android.gms.cloudmessaging.zzx
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public final Task then(Object obj) {
+                return Rpc.zza((Bundle) obj);
+            }
+        }) : task;
+    }
+
+    public final /* synthetic */ void zzd(String str, ScheduledFuture scheduledFuture, Task task) {
+        synchronized (this.zze) {
+            this.zze.remove(str);
+        }
+        scheduledFuture.cancel(false);
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zza.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.cloudmessaging;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class zza {
+    public static /* synthetic */ boolean zza(Object obj, Object obj2) {
+        if (obj != obj2) {
+            return obj != null && obj.equals(obj2);
+        }
+        return true;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzad.java

@@ -0,0 +1,20 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Looper;
+import android.os.Message;
+
+/* loaded from: classes3.dex */
+final class zzad extends com.google.android.gms.internal.cloudmessaging.zzf {
+    final /* synthetic */ Rpc zza;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zzad(Rpc rpc, Looper looper) {
+        super(looper);
+        this.zza = rpc;
+    }
+
+    @Override // android.os.Handler
+    public final void handleMessage(Message message) {
+        Rpc.zzc(this.zza, message);
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzb.java

@@ -0,0 +1,30 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.content.Intent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
+
+/* loaded from: classes3.dex */
+public final class zzb implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
+        Intent intent = null;
+        while (parcel.dataPosition() < validateObjectHeader) {
+            int readHeader = SafeParcelReader.readHeader(parcel);
+            if (SafeParcelReader.getFieldId(readHeader) != 1) {
+                SafeParcelReader.skipUnknownField(parcel, readHeader);
+            } else {
+                intent = (Intent) SafeParcelReader.createParcelable(parcel, readHeader, Intent.CREATOR);
+            }
+        }
+        SafeParcelReader.ensureAtEnd(parcel, validateObjectHeader);
+        return new CloudMessage(intent);
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new CloudMessage[i];
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzc.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/* loaded from: classes3.dex */
+final class zzc implements Parcelable.Creator {
+    @Override // android.os.Parcelable.Creator
+    public final /* bridge */ /* synthetic */ Object createFromParcel(Parcel parcel) {
+        return new zze(parcel.readStrongBinder());
+    }
+
+    @Override // android.os.Parcelable.Creator
+    public final /* synthetic */ Object[] newArray(int i) {
+        return new zze[i];
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzd.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.util.Log;
+
+/* loaded from: classes3.dex */
+public final class zzd extends ClassLoader {
+    @Override // java.lang.ClassLoader
+    public final Class loadClass(String str, boolean z3) throws ClassNotFoundException {
+        if (str != "com.google.android.gms.iid.MessengerCompat" && (str == null || !str.equals("com.google.android.gms.iid.MessengerCompat"))) {
+            return super.loadClass(str, z3);
+        }
+        if (!Log.isLoggable("CloudMessengerCompat", 3)) {
+            return zze.class;
+        }
+        Log.d("CloudMessengerCompat", "Using renamed FirebaseIidMessengerCompat class");
+        return zze.class;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zze.java

@@ -0,0 +1,63 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.RemoteException;
+
+/* loaded from: classes3.dex */
+public final class zze implements Parcelable {
+    public static final Parcelable.Creator<zze> CREATOR = new zzc();
+    Messenger zza;
+    IMessengerCompat zzb;
+
+    public zze(IBinder iBinder) {
+        this.zza = new Messenger(iBinder);
+    }
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    public final boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        try {
+            return zza().equals(((zze) obj).zza());
+        } catch (ClassCastException unused) {
+            return false;
+        }
+    }
+
+    public final int hashCode() {
+        return zza().hashCode();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        Messenger messenger = this.zza;
+        if (messenger != null) {
+            parcel.writeStrongBinder(messenger.getBinder());
+        } else {
+            parcel.writeStrongBinder(this.zzb.asBinder());
+        }
+    }
+
+    public final IBinder zza() {
+        Messenger messenger = this.zza;
+        return messenger != null ? messenger.getBinder() : this.zzb.asBinder();
+    }
+
+    public final void zzb(Message message) throws RemoteException {
+        Messenger messenger = this.zza;
+        if (messenger != null) {
+            messenger.send(message);
+        } else {
+            this.zzb.send(message);
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzn.java

@@ -0,0 +1,268 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.util.Log;
+import android.util.SparseArray;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.stats.ConnectionTracker;
+import com.google.firebase.messaging.Constants;
+import java.util.ArrayDeque;
+import java.util.Iterator;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class zzn implements ServiceConnection {
+    zzp zzc;
+    final /* synthetic */ zzu zzf;
+    int zza = 0;
+    final Messenger zzb = new Messenger(new com.google.android.gms.internal.cloudmessaging.zzf(Looper.getMainLooper(), new Handler.Callback() { // from class: com.google.android.gms.cloudmessaging.zzk
+        @Override // android.os.Handler.Callback
+        public final boolean handleMessage(Message message) {
+            int i = message.arg1;
+            if (Log.isLoggable("MessengerIpcClient", 3)) {
+                Log.d("MessengerIpcClient", "Received response to request: " + i);
+            }
+            zzn zznVar = zzn.this;
+            synchronized (zznVar) {
+                try {
+                    zzr zzrVar = (zzr) zznVar.zze.get(i);
+                    if (zzrVar == null) {
+                        Log.w("MessengerIpcClient", "Received response for unknown request: " + i);
+                        return true;
+                    }
+                    zznVar.zze.remove(i);
+                    zznVar.zzf();
+                    Bundle data = message.getData();
+                    if (data.getBoolean("unsupported", false)) {
+                        zzrVar.zzc(new zzs(4, "Not supported by GmsCore", null));
+                        return true;
+                    }
+                    zzrVar.zza(data);
+                    return true;
+                } finally {
+                }
+            }
+        }
+    }));
+    final Queue zzd = new ArrayDeque();
+    final SparseArray zze = new SparseArray();
+
+    public /* synthetic */ zzn(zzu zzuVar, zzm zzmVar) {
+        this.zzf = zzuVar;
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceConnected(ComponentName componentName, final IBinder iBinder) {
+        if (Log.isLoggable("MessengerIpcClient", 2)) {
+            Log.v("MessengerIpcClient", "Service connected");
+        }
+        zzu.zze(this.zzf).execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzg
+            @Override // java.lang.Runnable
+            public final void run() {
+                zzn zznVar = zzn.this;
+                IBinder iBinder2 = iBinder;
+                synchronized (zznVar) {
+                    if (iBinder2 == null) {
+                        zznVar.zza(0, "Null service connection");
+                        return;
+                    }
+                    try {
+                        zznVar.zzc = new zzp(iBinder2);
+                        zznVar.zza = 2;
+                        zznVar.zzc();
+                    } catch (RemoteException e4) {
+                        zznVar.zza(0, e4.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceDisconnected(ComponentName componentName) {
+        if (Log.isLoggable("MessengerIpcClient", 2)) {
+            Log.v("MessengerIpcClient", "Service disconnected");
+        }
+        zzu.zze(this.zzf).execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzj
+            @Override // java.lang.Runnable
+            public final void run() {
+                zzn.this.zza(2, "Service disconnected");
+            }
+        });
+    }
+
+    public final synchronized void zza(int i, String str) {
+        zzb(i, str, null);
+    }
+
+    public final synchronized void zzb(int i, String str, Throwable th) {
+        try {
+            if (Log.isLoggable("MessengerIpcClient", 3)) {
+                Log.d("MessengerIpcClient", "Disconnected: ".concat(String.valueOf(str)));
+            }
+            int i4 = this.zza;
+            if (i4 == 0) {
+                throw new IllegalStateException();
+            }
+            if (i4 != 1 && i4 != 2) {
+                if (i4 != 3) {
+                    return;
+                }
+                this.zza = 4;
+                return;
+            }
+            if (Log.isLoggable("MessengerIpcClient", 2)) {
+                Log.v("MessengerIpcClient", "Unbinding service");
+            }
+            this.zza = 4;
+            ConnectionTracker.getInstance().unbindService(zzu.zza(this.zzf), this);
+            zzs zzsVar = new zzs(i, str, th);
+            Iterator it = this.zzd.iterator();
+            while (it.hasNext()) {
+                ((zzr) it.next()).zzc(zzsVar);
+            }
+            this.zzd.clear();
+            for (int i5 = 0; i5 < this.zze.size(); i5++) {
+                ((zzr) this.zze.valueAt(i5)).zzc(zzsVar);
+            }
+            this.zze.clear();
+        } catch (Throwable th2) {
+            throw th2;
+        }
+    }
+
+    public final void zzc() {
+        zzu.zze(this.zzf).execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzh
+            @Override // java.lang.Runnable
+            public final void run() {
+                final zzr zzrVar;
+                while (true) {
+                    final zzn zznVar = zzn.this;
+                    synchronized (zznVar) {
+                        try {
+                            if (zznVar.zza != 2) {
+                                return;
+                            }
+                            if (zznVar.zzd.isEmpty()) {
+                                zznVar.zzf();
+                                return;
+                            } else {
+                                zzrVar = (zzr) zznVar.zzd.poll();
+                                zznVar.zze.put(zzrVar.zza, zzrVar);
+                                zzu.zze(zznVar.zzf).schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzl
+                                    @Override // java.lang.Runnable
+                                    public final void run() {
+                                        zzn.this.zze(zzrVar.zza);
+                                    }
+                                }, 30L, TimeUnit.SECONDS);
+                            }
+                        } finally {
+                        }
+                    }
+                    if (Log.isLoggable("MessengerIpcClient", 3)) {
+                        Log.d("MessengerIpcClient", "Sending ".concat(String.valueOf(zzrVar)));
+                    }
+                    zzu zzuVar = zznVar.zzf;
+                    Messenger messenger = zznVar.zzb;
+                    int i = zzrVar.zzc;
+                    Context zza = zzu.zza(zzuVar);
+                    Message obtain = Message.obtain();
+                    obtain.what = i;
+                    obtain.arg1 = zzrVar.zza;
+                    obtain.replyTo = messenger;
+                    Bundle bundle = new Bundle();
+                    bundle.putBoolean("oneWay", zzrVar.zzb());
+                    bundle.putString("pkg", zza.getPackageName());
+                    bundle.putBundle(Constants.ScionAnalytics.MessageType.DATA_MESSAGE, zzrVar.zzd);
+                    obtain.setData(bundle);
+                    try {
+                        zznVar.zzc.zza(obtain);
+                    } catch (RemoteException e4) {
+                        zznVar.zza(2, e4.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    public final synchronized void zzd() {
+        if (this.zza == 1) {
+            zza(1, "Timed out while binding");
+        }
+    }
+
+    public final synchronized void zze(int i) {
+        zzr zzrVar = (zzr) this.zze.get(i);
+        if (zzrVar != null) {
+            Log.w("MessengerIpcClient", "Timing out request: " + i);
+            this.zze.remove(i);
+            zzrVar.zzc(new zzs(3, "Timed out waiting for response", null));
+            zzf();
+        }
+    }
+
+    public final synchronized void zzf() {
+        try {
+            if (this.zza == 2 && this.zzd.isEmpty() && this.zze.size() == 0) {
+                if (Log.isLoggable("MessengerIpcClient", 2)) {
+                    Log.v("MessengerIpcClient", "Finished handling requests, unbinding");
+                }
+                this.zza = 3;
+                ConnectionTracker.getInstance().unbindService(zzu.zza(this.zzf), this);
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public final synchronized boolean zzg(zzr zzrVar) {
+        int i = this.zza;
+        if (i != 0) {
+            if (i == 1) {
+                this.zzd.add(zzrVar);
+                return true;
+            }
+            if (i != 2) {
+                return false;
+            }
+            this.zzd.add(zzrVar);
+            zzc();
+            return true;
+        }
+        this.zzd.add(zzrVar);
+        Preconditions.checkState(this.zza == 0);
+        if (Log.isLoggable("MessengerIpcClient", 2)) {
+            Log.v("MessengerIpcClient", "Starting bind to GmsCore");
+        }
+        this.zza = 1;
+        Intent intent = new Intent("com.google.android.c2dm.intent.REGISTER");
+        intent.setPackage("com.google.android.gms");
+        try {
+            if (ConnectionTracker.getInstance().bindService(zzu.zza(this.zzf), intent, this, 1)) {
+                zzu.zze(this.zzf).schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzi
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        zzn.this.zzd();
+                    }
+                }, 30L, TimeUnit.SECONDS);
+            } else {
+                zza(0, "Unable to bind to service");
+            }
+        } catch (SecurityException e4) {
+            zzb(0, "Unable to bind to service", e4);
+        }
+        return true;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzo.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.cloudmessaging;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class zzo {
+    public static /* synthetic */ boolean zza(Object obj, Object obj2) {
+        if (obj != obj2) {
+            return obj != null && obj.equals(obj2);
+        }
+        return true;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzp.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.util.Log;
+
+/* loaded from: classes3.dex */
+final class zzp {
+    private final Messenger zza;
+    private final zze zzb;
+
+    public zzp(IBinder iBinder) throws RemoteException {
+        String interfaceDescriptor = iBinder.getInterfaceDescriptor();
+        if (zzo.zza(interfaceDescriptor, "android.os.IMessenger")) {
+            this.zza = new Messenger(iBinder);
+            this.zzb = null;
+        } else {
+            if (!zzo.zza(interfaceDescriptor, IMessengerCompat.DESCRIPTOR)) {
+                Log.w("MessengerIpcClient", "Invalid interface descriptor: ".concat(String.valueOf(interfaceDescriptor)));
+                throw new RemoteException();
+            }
+            this.zzb = new zze(iBinder);
+            this.zza = null;
+        }
+    }
+
+    public final void zza(Message message) throws RemoteException {
+        Messenger messenger = this.zza;
+        if (messenger != null) {
+            messenger.send(message);
+            return;
+        }
+        zze zzeVar = this.zzb;
+        if (zzeVar == null) {
+            throw new IllegalStateException("Both messengers are null");
+        }
+        zzeVar.zzb(message);
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzq.java

@@ -0,0 +1,24 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Bundle;
+
+/* loaded from: classes3.dex */
+final class zzq extends zzr {
+    public zzq(int i, int i4, Bundle bundle) {
+        super(i, i4, bundle);
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzr
+    public final void zza(Bundle bundle) {
+        if (bundle.getBoolean("ack", false)) {
+            zzd(null);
+        } else {
+            zzc(new zzs(4, "Invalid response to one way request", null));
+        }
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzr
+    public final boolean zzb() {
+        return true;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzr.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Bundle;
+import android.util.Log;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class zzr {
+    final int zza;
+    final TaskCompletionSource zzb = new TaskCompletionSource();
+    final int zzc;
+    final Bundle zzd;
+
+    public zzr(int i, int i4, Bundle bundle) {
+        this.zza = i;
+        this.zzc = i4;
+        this.zzd = bundle;
+    }
+
+    public final String toString() {
+        return "Request { what=" + this.zzc + " id=" + this.zza + " oneWay=" + zzb() + "}";
+    }
+
+    public abstract void zza(Bundle bundle);
+
+    public abstract boolean zzb();
+
+    public final void zzc(zzs zzsVar) {
+        if (Log.isLoggable("MessengerIpcClient", 3)) {
+            Log.d("MessengerIpcClient", "Failing " + toString() + " with " + zzsVar.toString());
+        }
+        this.zzb.setException(zzsVar);
+    }
+
+    public final void zzd(Object obj) {
+        if (Log.isLoggable("MessengerIpcClient", 3)) {
+            Log.d("MessengerIpcClient", "Finishing " + toString() + " with " + String.valueOf(obj));
+        }
+        this.zzb.setResult(obj);
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzs.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.cloudmessaging;
+
+/* loaded from: classes3.dex */
+public final class zzs extends Exception {
+    public zzs(int i, String str, Throwable th) {
+        super(str, th);
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzt.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Bundle;
+import com.google.firebase.messaging.Constants;
+
+/* loaded from: classes3.dex */
+final class zzt extends zzr {
+    public zzt(int i, int i4, Bundle bundle) {
+        super(i, 1, bundle);
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzr
+    public final void zza(Bundle bundle) {
+        Bundle bundle2 = bundle.getBundle(Constants.ScionAnalytics.MessageType.DATA_MESSAGE);
+        if (bundle2 == null) {
+            bundle2 = Bundle.EMPTY;
+        }
+        zzd(bundle2);
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzr
+    public final boolean zzb() {
+        return false;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzu.java

@@ -0,0 +1,78 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.util.Log;
+import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
+import com.google.android.gms.tasks.Task;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+/* loaded from: classes3.dex */
+public final class zzu {
+    private static zzu zza;
+    private final Context zzb;
+    private final ScheduledExecutorService zzc;
+    private zzn zzd = new zzn(this, null);
+    private int zze = 1;
+
+    public zzu(Context context, ScheduledExecutorService scheduledExecutorService) {
+        this.zzc = scheduledExecutorService;
+        this.zzb = context.getApplicationContext();
+    }
+
+    public static /* bridge */ /* synthetic */ Context zza(zzu zzuVar) {
+        return zzuVar.zzb;
+    }
+
+    public static synchronized zzu zzb(Context context) {
+        zzu zzuVar;
+        synchronized (zzu.class) {
+            try {
+                if (zza == null) {
+                    com.google.android.gms.internal.cloudmessaging.zze.zza();
+                    zza = new zzu(context, Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(1, new NamedThreadFactory("MessengerIpcClient"))));
+                }
+                zzuVar = zza;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zzuVar;
+    }
+
+    public static /* bridge */ /* synthetic */ ScheduledExecutorService zze(zzu zzuVar) {
+        return zzuVar.zzc;
+    }
+
+    private final synchronized int zzf() {
+        int i;
+        i = this.zze;
+        this.zze = i + 1;
+        return i;
+    }
+
+    private final synchronized Task zzg(zzr zzrVar) {
+        try {
+            if (Log.isLoggable("MessengerIpcClient", 3)) {
+                Log.d("MessengerIpcClient", "Queueing ".concat(zzrVar.toString()));
+            }
+            if (!this.zzd.zzg(zzrVar)) {
+                zzn zznVar = new zzn(this, null);
+                this.zzd = zznVar;
+                zznVar.zzg(zzrVar);
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return zzrVar.zzb.getTask();
+    }
+
+    public final Task zzc(int i, Bundle bundle) {
+        return zzg(new zzq(zzf(), i, bundle));
+    }
+
+    public final Task zzd(int i, Bundle bundle) {
+        return zzg(new zzt(zzf(), 1, bundle));
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzv.java

@@ -0,0 +1,75 @@
+package com.google.android.gms.cloudmessaging;
+
+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.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.common.wrappers.Wrappers;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class zzv {
+    private final Context zza;
+    private int zzb;
+    private int zzc = 0;
+
+    public zzv(Context context) {
+        this.zza = context;
+    }
+
+    public final synchronized int zza() {
+        PackageInfo packageInfo;
+        if (this.zzb == 0) {
+            try {
+                packageInfo = Wrappers.packageManager(this.zza).getPackageInfo("com.google.android.gms", 0);
+            } catch (PackageManager.NameNotFoundException e4) {
+                Log.w("Metadata", "Failed to find package ".concat(e4.toString()));
+                packageInfo = null;
+            }
+            if (packageInfo != null) {
+                this.zzb = packageInfo.versionCode;
+            }
+        }
+        return this.zzb;
+    }
+
+    public final synchronized int zzb() {
+        int i = this.zzc;
+        if (i != 0) {
+            return i;
+        }
+        Context context = this.zza;
+        PackageManager packageManager = context.getPackageManager();
+        if (Wrappers.packageManager(context).checkPermission("com.google.android.c2dm.permission.SEND", "com.google.android.gms") == -1) {
+            Log.e("Metadata", "Google Play services missing or without correct permission.");
+            return 0;
+        }
+        int i4 = 1;
+        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.isEmpty()) {
+                this.zzc = i4;
+                return i4;
+            }
+        }
+        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.isEmpty()) {
+            i4 = 2;
+            this.zzc = i4;
+            return i4;
+        }
+        Log.w("Metadata", "Failed to resolve IID implementation package, falling back");
+        if (true == PlatformVersion.isAtLeastO()) {
+            i4 = 2;
+        }
+        this.zzc = i4;
+        return i4;
+    }
+}

apk_decompiled/sources/com/google/android/gms/cloudmessaging/zzw.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.cloudmessaging;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class zzw {
+    public static /* synthetic */ boolean zza(Object obj, Object obj2) {
+        if (obj != obj2) {
+            return obj != null && obj.equals(obj2);
+        }
+        return true;
+    }
+}