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/android/gms/cloudmessaging/CloudMessage.java

@@ -0,0 +1,189 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import com.ea.eadp.pushnotification.forwarding.FCMMessageService;
+import com.google.android.gms.common.annotation.KeepForSdk;
+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 java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Map;
+import java.util.Objects;
+
+@SafeParcelable.Class(creator = "CloudMessageCreator")
+/* loaded from: classes2.dex */
+public final class CloudMessage extends AbstractSafeParcelable {
+
+    @NonNull
+    public static final Parcelable.Creator<CloudMessage> CREATOR = new zza();
+    public static final int PRIORITY_HIGH = 1;
+    public static final int PRIORITY_NORMAL = 2;
+    public static final int PRIORITY_UNKNOWN = 0;
+
+    @NonNull
+    @SafeParcelable.Field(id = 1)
+    final Intent zza;
+    private Map zzb;
+
+    @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface MessagePriority {
+    }
+
+    @SafeParcelable.Constructor
+    @KeepForSdk
+    public CloudMessage(@NonNull @SafeParcelable.Param(id = 1) Intent intent) {
+        this.zza = intent;
+    }
+
+    private static int zzb(@Nullable String str) {
+        if (Objects.equals(str, "high")) {
+            return 1;
+        }
+        return Objects.equals(str, "normal") ? 2 : 0;
+    }
+
+    @Nullable
+    public String getCollapseKey() {
+        return this.zza.getStringExtra(FCMMessageService.PushIntentExtraKeys.COLLAPSE_KEY);
+    }
+
+    @NonNull
+    public synchronized Map<String, String> getData() {
+        try {
+            if (this.zzb == null) {
+                Bundle extras = this.zza.getExtras();
+                ArrayMap arrayMap = new ArrayMap();
+                if (extras != null) {
+                    for (String str : extras.keySet()) {
+                        Object obj = extras.get(str);
+                        if (obj instanceof String) {
+                            String str2 = (String) obj;
+                            if (!str.startsWith("google.") && !str.equals("from") && !str.equals("message_type") && !str.equals(FCMMessageService.PushIntentExtraKeys.COLLAPSE_KEY)) {
+                                arrayMap.put(str, str2);
+                            }
+                        }
+                    }
+                }
+                this.zzb = arrayMap;
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.zzb;
+    }
+
+    @Nullable
+    public String getFrom() {
+        return this.zza.getStringExtra("from");
+    }
+
+    @NonNull
+    public Intent getIntent() {
+        return this.zza;
+    }
+
+    @Nullable
+    public String getMessageId() {
+        String stringExtra = this.zza.getStringExtra("google.message_id");
+        return stringExtra == null ? this.zza.getStringExtra("message_id") : stringExtra;
+    }
+
+    @Nullable
+    public String getMessageType() {
+        return this.zza.getStringExtra("message_type");
+    }
+
+    public int getOriginalPriority() {
+        String stringExtra = this.zza.getStringExtra("google.original_priority");
+        if (stringExtra == null) {
+            stringExtra = this.zza.getStringExtra("google.priority");
+        }
+        return zzb(stringExtra);
+    }
+
+    public int getPriority() {
+        String stringExtra = this.zza.getStringExtra("google.delivered_priority");
+        if (stringExtra == null) {
+            if (Objects.equals(this.zza.getStringExtra("google.priority_reduced"), "1")) {
+                return 2;
+            }
+            stringExtra = this.zza.getStringExtra("google.priority");
+        }
+        return zzb(stringExtra);
+    }
+
+    @Nullable
+    public byte[] getRawData() {
+        return this.zza.getByteArrayExtra("rawData");
+    }
+
+    @Nullable
+    public String getSenderId() {
+        return this.zza.getStringExtra("google.c.sender.id");
+    }
+
+    public long getSentTime() {
+        Bundle extras = this.zza.getExtras();
+        Object obj = extras != null ? extras.get("google.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;
+        }
+    }
+
+    @Nullable
+    public String getTo() {
+        return this.zza.getStringExtra("google.to");
+    }
+
+    public int getTtl() {
+        Bundle extras = this.zza.getExtras();
+        Object obj = extras != null ? extras.get("google.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(@NonNull Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeParcelable(parcel, 1, this.zza, i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @Nullable
+    public final Integer zza() {
+        if (this.zza.hasExtra("google.product_id")) {
+            return Integer.valueOf(this.zza.getIntExtra("google.product_id", 0));
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,208 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+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.Tasks;
+import java.lang.ref.SoftReference;
+import java.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public abstract class CloudMessagingReceiver extends BroadcastReceiver {
+
+    @Nullable
+    private static SoftReference zza;
+
+    @Nullable
+    private static SoftReference zzb;
+
+    public static final class IntentActionKeys {
+
+        @NonNull
+        public static final String NOTIFICATION_DISMISS = "com.google.firebase.messaging.NOTIFICATION_DISMISS";
+
+        @NonNull
+        public static final String NOTIFICATION_OPEN = "com.google.firebase.messaging.NOTIFICATION_OPEN";
+
+        private IntentActionKeys() {
+        }
+    }
+
+    public static final class IntentKeys {
+
+        @NonNull
+        public static final String PENDING_INTENT = "pending_intent";
+
+        @NonNull
+        public static final String WRAPPED_INTENT = "wrapped_intent";
+
+        private IntentKeys() {
+        }
+    }
+
+    @WorkerThread
+    private final int zzb(@NonNull Context context, @NonNull 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();
+        }
+        if (Objects.equals(intent.getAction(), IntentActionKeys.NOTIFICATION_DISMISS)) {
+            onNotificationDismissed(context, extras);
+            return -1;
+        }
+        Log.e("CloudMessagingReceiver", "Unknown notification action");
+        return 500;
+    }
+
+    @NonNull
+    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;
+    }
+
+    @WorkerThread
+    public abstract int onMessageReceive(@NonNull Context context, @NonNull CloudMessage cloudMessage);
+
+    @WorkerThread
+    public void onNotificationDismissed(@NonNull Context context, @NonNull Bundle bundle) {
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public final void onReceive(@NonNull final Context context, @NonNull 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.zzh
+            @Override // java.lang.Runnable
+            public final void run() {
+                CloudMessagingReceiver.this.zza(intent, context, isOrderedBroadcast, goAsync);
+            }
+        });
+    }
+
+    public final /* synthetic */ void zza(Intent intent, final Context context, boolean z, BroadcastReceiver.PendingResult pendingResult) {
+        Executor executor;
+        int i;
+        try {
+            Parcelable parcelableExtra = intent.getParcelableExtra(IntentKeys.WRAPPED_INTENT);
+            Intent intent2 = parcelableExtra instanceof Intent ? (Intent) parcelableExtra : null;
+            if (intent2 != null) {
+                i = zzb(context, intent2);
+            } else if (intent.getExtras() == null) {
+                i = 500;
+            } else {
+                final CloudMessage cloudMessage = new CloudMessage(intent);
+                final CountDownLatch countDownLatch = new CountDownLatch(1);
+                synchronized (CloudMessagingReceiver.class) {
+                    try {
+                        SoftReference softReference = zzb;
+                        executor = softReference != null ? (Executor) softReference.get() : null;
+                        if (executor == null) {
+                            com.google.android.gms.internal.cloudmessaging.zze.zza();
+                            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(), new NamedThreadFactory("pscm-ack-executor"));
+                            threadPoolExecutor.allowCoreThreadTimeOut(true);
+                            executor = Executors.unconfigurableExecutorService(threadPoolExecutor);
+                            zzb = new SoftReference(executor);
+                        }
+                    } finally {
+                    }
+                }
+                executor.execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzg
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        Task zzc;
+                        CloudMessage cloudMessage2 = cloudMessage;
+                        if (TextUtils.isEmpty(cloudMessage2.getMessageId())) {
+                            zzc = Tasks.forResult(null);
+                        } else {
+                            Bundle bundle = new Bundle();
+                            bundle.putString("google.message_id", cloudMessage2.getMessageId());
+                            Integer zza2 = cloudMessage2.zza();
+                            if (zza2 != null) {
+                                bundle.putInt("google.product_id", zza2.intValue());
+                            }
+                            Context context2 = context;
+                            bundle.putBoolean("supports_message_handled", true);
+                            zzc = zzv.zzb(context2).zzc(2, bundle);
+                        }
+                        final CountDownLatch countDownLatch2 = countDownLatch;
+                        zzc.addOnCompleteListener(new Executor() { // from class: com.google.android.gms.cloudmessaging.zze
+                            @Override // java.util.concurrent.Executor
+                            public final void execute(Runnable runnable) {
+                                runnable.run();
+                            }
+                        }, new OnCompleteListener() { // from class: com.google.android.gms.cloudmessaging.zzf
+                            @Override // com.google.android.gms.tasks.OnCompleteListener
+                            public final void onComplete(Task task) {
+                                countDownLatch2.countDown();
+                            }
+                        });
+                    }
+                });
+                int onMessageReceive = onMessageReceive(context, cloudMessage);
+                try {
+                    if (!countDownLatch.await(TimeUnit.SECONDS.toMillis(1L), TimeUnit.MILLISECONDS)) {
+                        Log.w("CloudMessagingReceiver", "Message ack timed out");
+                    }
+                } catch (InterruptedException e) {
+                    Log.w("CloudMessagingReceiver", "Message ack failed: ".concat(e.toString()));
+                }
+                i = onMessageReceive;
+            }
+            if (z && pendingResult != null) {
+                pendingResult.setResultCode(i);
+            }
+            if (pendingResult != null) {
+                pendingResult.finish();
+            }
+        } catch (Throwable th) {
+            if (pendingResult != null) {
+                pendingResult.finish();
+            }
+            throw th;
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+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;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes2.dex */
+interface IMessengerCompat extends IInterface {
+    public static final String DESCRIPTOR = "com.google.android.gms.iid.IMessengerCompat";
+    public static final int TRANSACTION_SEND = 1;
+
+    public static class Impl extends Binder implements IMessengerCompat {
+        @Override // android.os.IInterface
+        @NonNull
+        public IBinder asBinder() {
+            throw null;
+        }
+
+        @Override // android.os.Binder
+        public boolean onTransact(int i, @NonNull Parcel parcel, @Nullable Parcel parcel2, int i2) throws RemoteException {
+            throw null;
+        }
+
+        @Override // com.google.android.gms.cloudmessaging.IMessengerCompat
+        public void send(@NonNull Message message) throws RemoteException {
+            throw null;
+        }
+    }
+
+    public static class Proxy implements IMessengerCompat {
+        private final IBinder zza;
+
+        public Proxy(@NonNull IBinder iBinder) {
+            this.zza = iBinder;
+        }
+
+        @Override // android.os.IInterface
+        @NonNull
+        public IBinder asBinder() {
+            return this.zza;
+        }
+
+        @Override // com.google.android.gms.cloudmessaging.IMessengerCompat
+        public void send(@NonNull 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(@NonNull Message message) throws RemoteException;
+}

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

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

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

@@ -0,0 +1,332 @@
+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 androidx.annotation.AnyThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.SimpleArrayMap;
+import com.facebook.internal.security.CertificateUtil;
+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.mbridge.msdk.MBridgeConstans;
+import java.io.IOException;
+import java.util.Objects;
+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;
+
+/* loaded from: classes2.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 zzw zzg;
+    private final ScheduledExecutorService zzh;
+    private Messenger zzj;
+    private zzd zzk;
+    private final SimpleArrayMap zze = new SimpleArrayMap();
+    private final Messenger zzi = new Messenger(new zzae(this, Looper.getMainLooper()));
+
+    public Rpc(@NonNull Context context) {
+        this.zzf = context;
+        this.zzg = new zzw(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 /* bridge */ /* synthetic */ void zzc(Rpc rpc, Message message) {
+        if (message != null) {
+            Object obj = message.obj;
+            if (obj instanceof Intent) {
+                Intent intent = (Intent) obj;
+                intent.setExtrasClassLoader(new zzc());
+                if (intent.hasExtra("google.messenger")) {
+                    Parcelable parcelableExtra = intent.getParcelableExtra("google.messenger");
+                    if (parcelableExtra instanceof zzd) {
+                        rpc.zzk = (zzd) parcelableExtra;
+                    }
+                    if (parcelableExtra instanceof Messenger) {
+                        rpc.zzj = (Messenger) parcelableExtra;
+                    }
+                }
+                Intent intent2 = (Intent) message.obj;
+                if (!Objects.equals(intent2.getAction(), "com.google.android.c2dm.intent.REGISTRATION")) {
+                    Log.isLoggable("Rpc", 3);
+                    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()) {
+                        Log.isLoggable("Rpc", 3);
+                        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("error");
+                if (stringExtra2 == null) {
+                    Log.w("Rpc", "Unexpected response, no error or registration id ".concat(String.valueOf(intent2.getExtras())));
+                    return;
+                }
+                Log.isLoggable("Rpc", 3);
+                if (!stringExtra2.startsWith("|")) {
+                    synchronized (rpc.zze) {
+                        for (int i = 0; i < rpc.zze.size(); i++) {
+                            try {
+                                rpc.zzh((String) rpc.zze.keyAt(i), intent2.getExtras());
+                            } catch (Throwable th) {
+                                throw th;
+                            }
+                        }
+                    }
+                    return;
+                }
+                String[] split = stringExtra2.split("\\|");
+                if (split.length <= 2 || !Objects.equals(split[1], "ID")) {
+                    Log.w("Rpc", "Unexpected structured response ".concat(stringExtra2));
+                    return;
+                }
+                String str = split[2];
+                String str2 = split[3];
+                if (str2.startsWith(CertificateUtil.DELIMITER)) {
+                    str2 = str2.substring(1);
+                }
+                rpc.zzh(str, intent2.putExtra("error", str2).getExtras());
+                return;
+            }
+        }
+        Log.w("Rpc", "Dropping invalid message");
+    }
+
+    @AnyThread
+    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)) {
+            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) {
+                Log.isLoggable("Rpc", 3);
+            }
+            final ScheduledFuture<?> schedule = this.zzh.schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzac
+                @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.zzad
+                @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.zzac
+            @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.zzad
+            @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(MBridgeConstans.DYNAMIC_VIEW_WX_APP, zzb);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private final void zzh(String str, @Nullable 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");
+    }
+
+    @NonNull
+    public Task<CloudMessage> getProxiedNotificationData() {
+        return this.zzg.zza() >= 241100000 ? zzv.zzb(this.zzf).zzd(5, Bundle.EMPTY).continueWith(zzc, new Continuation() { // from class: com.google.android.gms.cloudmessaging.zzab
+            @Override // com.google.android.gms.tasks.Continuation
+            public final Object then(Task task) {
+                Intent intent = (Intent) ((Bundle) task.getResult()).getParcelable("notification_data");
+                if (intent != null) {
+                    return new CloudMessage(intent);
+                }
+                return null;
+            }
+        }) : Tasks.forException(new IOException("SERVICE_NOT_AVAILABLE"));
+    }
+
+    @NonNull
+    public Task<Void> messageHandled(@NonNull CloudMessage cloudMessage) {
+        if (this.zzg.zza() < 233700000) {
+            return Tasks.forException(new IOException("SERVICE_NOT_AVAILABLE"));
+        }
+        Bundle bundle = new Bundle();
+        bundle.putString("google.message_id", cloudMessage.getMessageId());
+        Integer zza2 = cloudMessage.zza();
+        if (zza2 != null) {
+            bundle.putInt("google.product_id", zza2.intValue());
+        }
+        return zzv.zzb(this.zzf).zzc(3, bundle);
+    }
+
+    @NonNull
+    public Task<Bundle> send(@NonNull 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")) : zzv.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)) {
+                    task.getException();
+                }
+                throw new IOException("SERVICE_NOT_AVAILABLE", task.getException());
+            }
+        });
+    }
+
+    @NonNull
+    public Task<Void> setRetainProxiedNotifications(boolean z) {
+        if (this.zzg.zza() < 241100000) {
+            return Tasks.forException(new IOException("SERVICE_NOT_AVAILABLE"));
+        }
+        Bundle bundle = new Bundle();
+        bundle.putBoolean("proxy_retention", z);
+        return zzv.zzb(this.zzf).zzc(4, bundle);
+    }
+
+    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);
+    }
+}

decompiled/sources/com/google/android/gms/cloudmessaging/zza.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: classes2.dex */
+public final class zza 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];
+    }
+}

decompiled/sources/com/google/android/gms/cloudmessaging/zzae.java

@@ -0,0 +1,20 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Looper;
+import android.os.Message;
+
+/* loaded from: classes2.dex */
+final class zzae 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 zzae(Rpc rpc, Looper looper) {
+        super(looper);
+        this.zza = rpc;
+    }
+
+    @Override // android.os.Handler
+    public final void handleMessage(Message message) {
+        Rpc.zzc(this.zza, message);
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.util.Log;
+import java.util.Objects;
+
+/* loaded from: classes2.dex */
+public final class zzc extends ClassLoader {
+    @Override // java.lang.ClassLoader
+    public final Class loadClass(String str, boolean z) throws ClassNotFoundException {
+        if (!Objects.equals(str, "com.google.android.gms.iid.MessengerCompat")) {
+            return super.loadClass(str, z);
+        }
+        Log.isLoggable("CloudMessengerCompat", 3);
+        return zzd.class;
+    }
+}

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

@@ -0,0 +1,64 @@
+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;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes2.dex */
+public final class zzd implements Parcelable {
+    public static final Parcelable.Creator<zzd> CREATOR = new zzb();
+    Messenger zza;
+    IMessengerCompat zzb;
+
+    public zzd(IBinder iBinder) {
+        this.zza = new Messenger(iBinder);
+    }
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        try {
+            return zza().equals(((zzd) 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);
+        }
+    }
+}

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

@@ -0,0 +1,274 @@
+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 androidx.annotation.MainThread;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.stats.ConnectionTracker;
+import csdk.gluads.Consts;
+import java.util.ArrayDeque;
+import java.util.Iterator;
+import java.util.Queue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+final class zzp implements ServiceConnection {
+    zzq zzc;
+    final /* synthetic */ zzv 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.zzm
+        @Override // android.os.Handler.Callback
+        public final boolean handleMessage(Message message) {
+            int i = message.arg1;
+            if (Log.isLoggable("MessengerIpcClient", 3)) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Received response to request: ");
+                sb.append(i);
+            }
+            zzp zzpVar = zzp.this;
+            synchronized (zzpVar) {
+                try {
+                    zzs zzsVar = (zzs) zzpVar.zze.get(i);
+                    if (zzsVar == null) {
+                        Log.w("MessengerIpcClient", "Received response for unknown request: " + i);
+                        return true;
+                    }
+                    zzpVar.zze.remove(i);
+                    zzpVar.zzf();
+                    Bundle data = message.getData();
+                    if (data.getBoolean(Consts.SDK_PRIVACY_STAGE_UNSUPPORTED, false)) {
+                        zzsVar.zzc(new zzt(4, "Not supported by GmsCore", null));
+                        return true;
+                    }
+                    zzsVar.zza(data);
+                    return true;
+                } finally {
+                }
+            }
+        }
+    }));
+    final Queue zzd = new ArrayDeque();
+    final SparseArray zze = new SparseArray();
+
+    public /* synthetic */ zzp(zzv zzvVar, zzo zzoVar) {
+        this.zzf = zzvVar;
+    }
+
+    @Override // android.content.ServiceConnection
+    @MainThread
+    public final void onServiceConnected(ComponentName componentName, final IBinder iBinder) {
+        ScheduledExecutorService scheduledExecutorService;
+        Log.isLoggable("MessengerIpcClient", 2);
+        scheduledExecutorService = this.zzf.zzc;
+        scheduledExecutorService.execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzi
+            @Override // java.lang.Runnable
+            public final void run() {
+                zzp zzpVar = zzp.this;
+                IBinder iBinder2 = iBinder;
+                synchronized (zzpVar) {
+                    if (iBinder2 == null) {
+                        zzpVar.zza(0, "Null service connection");
+                        return;
+                    }
+                    try {
+                        zzpVar.zzc = new zzq(iBinder2);
+                        zzpVar.zza = 2;
+                        zzpVar.zzc();
+                    } catch (RemoteException e) {
+                        zzpVar.zza(0, e.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    @Override // android.content.ServiceConnection
+    @MainThread
+    public final void onServiceDisconnected(ComponentName componentName) {
+        ScheduledExecutorService scheduledExecutorService;
+        Log.isLoggable("MessengerIpcClient", 2);
+        scheduledExecutorService = this.zzf.zzc;
+        scheduledExecutorService.execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzl
+            @Override // java.lang.Runnable
+            public final void run() {
+                zzp.this.zza(2, "Service disconnected");
+            }
+        });
+    }
+
+    public final synchronized void zza(int i, @Nullable String str) {
+        zzb(i, str, null);
+    }
+
+    public final synchronized void zzb(int i, @Nullable String str, @Nullable Throwable th) {
+        Context context;
+        Log.isLoggable("MessengerIpcClient", 3);
+        int i2 = this.zza;
+        if (i2 == 0) {
+            throw new IllegalStateException();
+        }
+        if (i2 != 1 && i2 != 2) {
+            if (i2 != 3) {
+                return;
+            }
+            this.zza = 4;
+            return;
+        }
+        Log.isLoggable("MessengerIpcClient", 2);
+        this.zza = 4;
+        zzv zzvVar = this.zzf;
+        ConnectionTracker connectionTracker = ConnectionTracker.getInstance();
+        context = zzvVar.zzb;
+        connectionTracker.unbindService(context, this);
+        zzt zztVar = new zzt(i, str, th);
+        Iterator it = this.zzd.iterator();
+        while (it.hasNext()) {
+            ((zzs) it.next()).zzc(zztVar);
+        }
+        this.zzd.clear();
+        for (int i3 = 0; i3 < this.zze.size(); i3++) {
+            ((zzs) this.zze.valueAt(i3)).zzc(zztVar);
+        }
+        this.zze.clear();
+    }
+
+    public final void zzc() {
+        ScheduledExecutorService scheduledExecutorService;
+        scheduledExecutorService = this.zzf.zzc;
+        scheduledExecutorService.execute(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzj
+            @Override // java.lang.Runnable
+            public final void run() {
+                final zzs zzsVar;
+                ScheduledExecutorService scheduledExecutorService2;
+                Context context;
+                while (true) {
+                    final zzp zzpVar = zzp.this;
+                    synchronized (zzpVar) {
+                        try {
+                            if (zzpVar.zza != 2) {
+                                return;
+                            }
+                            if (zzpVar.zzd.isEmpty()) {
+                                zzpVar.zzf();
+                                return;
+                            }
+                            zzsVar = (zzs) zzpVar.zzd.poll();
+                            zzpVar.zze.put(zzsVar.zza, zzsVar);
+                            scheduledExecutorService2 = zzpVar.zzf.zzc;
+                            scheduledExecutorService2.schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzn
+                                @Override // java.lang.Runnable
+                                public final void run() {
+                                    zzp.this.zze(zzsVar.zza);
+                                }
+                            }, 30L, TimeUnit.SECONDS);
+                        } catch (Throwable th) {
+                            throw th;
+                        }
+                    }
+                    Log.isLoggable("MessengerIpcClient", 3);
+                    zzv zzvVar = zzpVar.zzf;
+                    Messenger messenger = zzpVar.zzb;
+                    int i = zzsVar.zzc;
+                    context = zzvVar.zzb;
+                    Message obtain = Message.obtain();
+                    obtain.what = i;
+                    obtain.arg1 = zzsVar.zza;
+                    obtain.replyTo = messenger;
+                    Bundle bundle = new Bundle();
+                    bundle.putBoolean("oneWay", zzsVar.zzb());
+                    bundle.putString("pkg", context.getPackageName());
+                    bundle.putBundle("data", zzsVar.zzd);
+                    obtain.setData(bundle);
+                    try {
+                        zzpVar.zzc.zza(obtain);
+                    } catch (RemoteException e) {
+                        zzpVar.zza(2, e.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    public final synchronized void zzd() {
+        if (this.zza == 1) {
+            zza(1, "Timed out while binding");
+        }
+    }
+
+    public final synchronized void zze(int i) {
+        zzs zzsVar = (zzs) this.zze.get(i);
+        if (zzsVar != null) {
+            Log.w("MessengerIpcClient", "Timing out request: " + i);
+            this.zze.remove(i);
+            zzsVar.zzc(new zzt(3, "Timed out waiting for response", null));
+            zzf();
+        }
+    }
+
+    public final synchronized void zzf() {
+        Context context;
+        if (this.zza == 2 && this.zzd.isEmpty() && this.zze.size() == 0) {
+            Log.isLoggable("MessengerIpcClient", 2);
+            this.zza = 3;
+            zzv zzvVar = this.zzf;
+            ConnectionTracker connectionTracker = ConnectionTracker.getInstance();
+            context = zzvVar.zzb;
+            connectionTracker.unbindService(context, this);
+        }
+    }
+
+    public final synchronized boolean zzg(zzs zzsVar) {
+        Context context;
+        ScheduledExecutorService scheduledExecutorService;
+        int i = this.zza;
+        if (i != 0) {
+            if (i == 1) {
+                this.zzd.add(zzsVar);
+                return true;
+            }
+            if (i != 2) {
+                return false;
+            }
+            this.zzd.add(zzsVar);
+            zzc();
+            return true;
+        }
+        this.zzd.add(zzsVar);
+        Preconditions.checkState(this.zza == 0);
+        Log.isLoggable("MessengerIpcClient", 2);
+        this.zza = 1;
+        Intent intent = new Intent("com.google.android.c2dm.intent.REGISTER");
+        intent.setPackage("com.google.android.gms");
+        try {
+            ConnectionTracker connectionTracker = ConnectionTracker.getInstance();
+            context = this.zzf.zzb;
+            if (connectionTracker.bindService(context, intent, this, 1)) {
+                scheduledExecutorService = this.zzf.zzc;
+                scheduledExecutorService.schedule(new Runnable() { // from class: com.google.android.gms.cloudmessaging.zzk
+                    @Override // java.lang.Runnable
+                    public final void run() {
+                        zzp.this.zzd();
+                    }
+                }, 30L, TimeUnit.SECONDS);
+            } else {
+                zza(0, "Unable to bind to service");
+            }
+        } catch (SecurityException e) {
+            zzb(0, "Unable to bind to service", e);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,47 @@
+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;
+import androidx.annotation.Nullable;
+import java.util.Objects;
+
+/* loaded from: classes2.dex */
+final class zzq {
+
+    @Nullable
+    private final Messenger zza;
+
+    @Nullable
+    private final zzd zzb;
+
+    public zzq(IBinder iBinder) throws RemoteException {
+        String interfaceDescriptor = iBinder.getInterfaceDescriptor();
+        if (Objects.equals(interfaceDescriptor, "android.os.IMessenger")) {
+            this.zza = new Messenger(iBinder);
+            this.zzb = null;
+        } else {
+            if (!Objects.equals(interfaceDescriptor, IMessengerCompat.DESCRIPTOR)) {
+                Log.w("MessengerIpcClient", "Invalid interface descriptor: ".concat(String.valueOf(interfaceDescriptor)));
+                throw new RemoteException();
+            }
+            this.zzb = new zzd(iBinder);
+            this.zza = null;
+        }
+    }
+
+    public final void zza(Message message) throws RemoteException {
+        Messenger messenger = this.zza;
+        if (messenger != null) {
+            messenger.send(message);
+            return;
+        }
+        zzd zzdVar = this.zzb;
+        if (zzdVar == null) {
+            throw new IllegalStateException("Both messengers are null");
+        }
+        zzdVar.zzb(message);
+    }
+}

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

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

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

@@ -0,0 +1,53 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Bundle;
+import android.util.Log;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes2.dex */
+abstract class zzs {
+    final int zza;
+    final TaskCompletionSource zzb = new TaskCompletionSource();
+    final int zzc;
+    final Bundle zzd;
+
+    public zzs(int i, int i2, Bundle bundle) {
+        this.zza = i;
+        this.zzc = i2;
+        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(zzt zztVar) {
+        if (Log.isLoggable("MessengerIpcClient", 3)) {
+            String obj = toString();
+            String obj2 = zztVar.toString();
+            StringBuilder sb = new StringBuilder();
+            sb.append("Failing ");
+            sb.append(obj);
+            sb.append(" with ");
+            sb.append(obj2);
+        }
+        this.zzb.setException(zztVar);
+    }
+
+    public final void zzd(Object obj) {
+        if (Log.isLoggable("MessengerIpcClient", 3)) {
+            String obj2 = toString();
+            String valueOf = String.valueOf(obj);
+            StringBuilder sb = new StringBuilder();
+            sb.append("Finishing ");
+            sb.append(obj2);
+            sb.append(" with ");
+            sb.append(valueOf);
+        }
+        this.zzb.setResult(obj);
+    }
+}

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

@@ -0,0 +1,10 @@
+package com.google.android.gms.cloudmessaging;
+
+import androidx.annotation.Nullable;
+
+/* loaded from: classes2.dex */
+public final class zzt extends Exception {
+    public zzt(int i, @Nullable String str, @Nullable Throwable th) {
+        super(str, th);
+    }
+}

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

@@ -0,0 +1,24 @@
+package com.google.android.gms.cloudmessaging;
+
+import android.os.Bundle;
+
+/* loaded from: classes2.dex */
+final class zzu extends zzs {
+    public zzu(int i, int i2, Bundle bundle) {
+        super(i, i2, bundle);
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzs
+    public final void zza(Bundle bundle) {
+        Bundle bundle2 = bundle.getBundle("data");
+        if (bundle2 == null) {
+            bundle2 = Bundle.EMPTY;
+        }
+        zzd(bundle2);
+    }
+
+    @Override // com.google.android.gms.cloudmessaging.zzs
+    public final boolean zzb() {
+        return false;
+    }
+}

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.os.Bundle;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+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: classes2.dex */
+public final class zzv {
+
+    @Nullable
+    private static zzv zza;
+    private final Context zzb;
+    private final ScheduledExecutorService zzc;
+    private zzp zzd = new zzp(this, null);
+    private int zze = 1;
+
+    @VisibleForTesting
+    public zzv(Context context, ScheduledExecutorService scheduledExecutorService) {
+        this.zzc = scheduledExecutorService;
+        this.zzb = context.getApplicationContext();
+    }
+
+    public static synchronized zzv zzb(Context context) {
+        zzv zzvVar;
+        synchronized (zzv.class) {
+            try {
+                if (zza == null) {
+                    com.google.android.gms.internal.cloudmessaging.zze.zza();
+                    zza = new zzv(context, Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(1, new NamedThreadFactory("MessengerIpcClient"))));
+                }
+                zzvVar = zza;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zzvVar;
+    }
+
+    private final synchronized int zzf() {
+        int i;
+        i = this.zze;
+        this.zze = i + 1;
+        return i;
+    }
+
+    private final synchronized Task zzg(zzs zzsVar) {
+        try {
+            if (Log.isLoggable("MessengerIpcClient", 3)) {
+                zzsVar.toString();
+            }
+            if (!this.zzd.zzg(zzsVar)) {
+                zzp zzpVar = new zzp(this, null);
+                this.zzd = zzpVar;
+                zzpVar.zzg(zzsVar);
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return zzsVar.zzb.getTask();
+    }
+
+    public final Task zzc(int i, Bundle bundle) {
+        return zzg(new zzr(zzf(), i, bundle));
+    }
+
+    public final Task zzd(int i, Bundle bundle) {
+        return zzg(new zzu(zzf(), i, bundle));
+    }
+}

decompiled/sources/com/google/android/gms/cloudmessaging/zzw.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: classes2.dex */
+public final class zzw {
+    private final Context zza;
+    private int zzb;
+    private int zzc = 0;
+
+    public zzw(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 e) {
+                Log.w("Metadata", "Failed to find package ".concat(e.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 i2 = 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 = i2;
+                return i2;
+            }
+        }
+        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()) {
+            i2 = 2;
+            this.zzc = i2;
+            return i2;
+        }
+        Log.w("Metadata", "Failed to resolve IID implementation package, falling back");
+        if (true == PlatformVersion.isAtLeastO()) {
+            i2 = 2;
+        }
+        this.zzc = i2;
+        return i2;
+    }
+}