Initial version -- added millennium read funcionality

2026-03-09 22:05:28 +01:00
commit 77c2ded482
2770 changed files with 141927 additions and 0 deletions
@@ -0,0 +1,178 @@
+package com.google.android.gms.common.internal;
+
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
+
+/* JADX INFO: compiled from: com.google.android.gms:play-services-base@@18.4.0 */
+/* JADX INFO: loaded from: classes2.dex */
+public final class zak implements Handler.Callback {
+
+    @NotOnlyInitialized
+    private final zaj zab;
+    private final Handler zah;
+    private final ArrayList zac = new ArrayList();
+    final ArrayList zaa = new ArrayList();
+    private final ArrayList zad = new ArrayList();
+    private volatile boolean zae = false;
+    private final AtomicInteger zaf = new AtomicInteger(0);
+    private boolean zag = false;
+    private final Object zai = new Object();
+
+    public zak(Looper looper, zaj zajVar) {
+        this.zab = zajVar;
+        this.zah = new com.google.android.gms.internal.base.zau(looper, this);
+    }
+
+    @Override // android.os.Handler.Callback
+    public final boolean handleMessage(Message message) {
+        if (message.what != 1) {
+            Log.wtf("GmsClientEvents", "Don't know how to handle message: " + message.what, new Exception());
+            return false;
+        }
+        GoogleApiClient.ConnectionCallbacks connectionCallbacks = (GoogleApiClient.ConnectionCallbacks) message.obj;
+        synchronized (this.zai) {
+            if (this.zae && this.zab.isConnected() && this.zac.contains(connectionCallbacks)) {
+                connectionCallbacks.onConnected(null);
+            }
+        }
+        return true;
+    }
+
+    public final void zaa() {
+        this.zae = false;
+        this.zaf.incrementAndGet();
+    }
+
+    public final void zab() {
+        this.zae = true;
+    }
+
+    public final void zac(ConnectionResult connectionResult) {
+        Preconditions.checkHandlerThread(this.zah, "onConnectionFailure must only be called on the Handler thread");
+        this.zah.removeMessages(1);
+        synchronized (this.zai) {
+            ArrayList<GoogleApiClient.OnConnectionFailedListener> arrayList = new ArrayList(this.zad);
+            int i = this.zaf.get();
+            for (GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener : arrayList) {
+                if (this.zae && this.zaf.get() == i) {
+                    if (this.zad.contains(onConnectionFailedListener)) {
+                        onConnectionFailedListener.onConnectionFailed(connectionResult);
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    public final void zad(Bundle bundle) {
+        Preconditions.checkHandlerThread(this.zah, "onConnectionSuccess must only be called on the Handler thread");
+        synchronized (this.zai) {
+            Preconditions.checkState(!this.zag);
+            this.zah.removeMessages(1);
+            this.zag = true;
+            Preconditions.checkState(this.zaa.isEmpty());
+            ArrayList<GoogleApiClient.ConnectionCallbacks> arrayList = new ArrayList(this.zac);
+            int i = this.zaf.get();
+            for (GoogleApiClient.ConnectionCallbacks connectionCallbacks : arrayList) {
+                if (!this.zae || !this.zab.isConnected() || this.zaf.get() != i) {
+                    break;
+                } else if (!this.zaa.contains(connectionCallbacks)) {
+                    connectionCallbacks.onConnected(bundle);
+                }
+            }
+            this.zaa.clear();
+            this.zag = false;
+        }
+    }
+
+    public final void zae(int i) {
+        Preconditions.checkHandlerThread(this.zah, "onUnintentionalDisconnection must only be called on the Handler thread");
+        this.zah.removeMessages(1);
+        synchronized (this.zai) {
+            this.zag = true;
+            ArrayList<GoogleApiClient.ConnectionCallbacks> arrayList = new ArrayList(this.zac);
+            int i2 = this.zaf.get();
+            for (GoogleApiClient.ConnectionCallbacks connectionCallbacks : arrayList) {
+                if (!this.zae || this.zaf.get() != i2) {
+                    break;
+                } else if (this.zac.contains(connectionCallbacks)) {
+                    connectionCallbacks.onConnectionSuspended(i);
+                }
+            }
+            this.zaa.clear();
+            this.zag = false;
+        }
+    }
+
+    public final void zaf(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        Preconditions.checkNotNull(connectionCallbacks);
+        synchronized (this.zai) {
+            if (this.zac.contains(connectionCallbacks)) {
+                Log.w("GmsClientEvents", "registerConnectionCallbacks(): listener " + String.valueOf(connectionCallbacks) + " is already registered");
+            } else {
+                this.zac.add(connectionCallbacks);
+            }
+        }
+        if (this.zab.isConnected()) {
+            Handler handler = this.zah;
+            handler.sendMessage(handler.obtainMessage(1, connectionCallbacks));
+        }
+    }
+
+    public final void zag(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        Preconditions.checkNotNull(onConnectionFailedListener);
+        synchronized (this.zai) {
+            if (this.zad.contains(onConnectionFailedListener)) {
+                Log.w("GmsClientEvents", "registerConnectionFailedListener(): listener " + String.valueOf(onConnectionFailedListener) + " is already registered");
+            } else {
+                this.zad.add(onConnectionFailedListener);
+            }
+        }
+    }
+
+    public final void zah(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        Preconditions.checkNotNull(connectionCallbacks);
+        synchronized (this.zai) {
+            if (!this.zac.remove(connectionCallbacks)) {
+                Log.w("GmsClientEvents", "unregisterConnectionCallbacks(): listener " + String.valueOf(connectionCallbacks) + " not found");
+            } else if (this.zag) {
+                this.zaa.add(connectionCallbacks);
+            }
+        }
+    }
+
+    public final void zai(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        Preconditions.checkNotNull(onConnectionFailedListener);
+        synchronized (this.zai) {
+            if (!this.zad.remove(onConnectionFailedListener)) {
+                Log.w("GmsClientEvents", "unregisterConnectionFailedListener(): listener " + String.valueOf(onConnectionFailedListener) + " not found");
+            }
+        }
+    }
+
+    public final boolean zaj(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        boolean zContains;
+        Preconditions.checkNotNull(connectionCallbacks);
+        synchronized (this.zai) {
+            zContains = this.zac.contains(connectionCallbacks);
+        }
+        return zContains;
+    }
+
+    public final boolean zak(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        boolean zContains;
+        Preconditions.checkNotNull(onConnectionFailedListener);
+        synchronized (this.zai) {
+            zContains = this.zad.contains(onConnectionFailedListener);
+        }
+        return zContains;
+    }
+}