package androidx.media3.session;

import android.os.Handler;
import androidx.annotation.GuardedBy;
import androidx.annotation.Nullable;
import androidx.collection.ArrayMap;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.Util;
import com.google.common.util.concurrent.AbstractFuture;
import java.util.ArrayList;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
final class SequencedFutureManager {
    private static final String TAG = "SequencedFutureManager";

    @GuardedBy("lock")
    private boolean isReleased;

    @GuardedBy("lock")
    private int nextSequenceNumber;

    @Nullable
    @GuardedBy("lock")
    private Runnable pendingLazyReleaseCallback;

    @Nullable
    @GuardedBy("lock")
    private Handler releaseCallbackHandler;
    private final Object lock = new Object();

    @GuardedBy("lock")
    private final ArrayMap<Integer, SequencedFuture<?>> seqToFutureMap = new ArrayMap<>();

    public static final class SequencedFuture<T> extends AbstractFuture<T> {
        private final T resultWhenClosed;
        private final int sequenceNumber;

        private SequencedFuture(int i2, T t2) {
            this.sequenceNumber = i2;
            this.resultWhenClosed = t2;
        }

        public static <T> SequencedFuture<T> create(int i2, T t2) {
            return new SequencedFuture<>(i2, t2);
        }

        public T getResultWhenClosed() {
            return this.resultWhenClosed;
        }

        public int getSequenceNumber() {
            return this.sequenceNumber;
        }

        public boolean set(T t2) {
            return super.set(t2);
        }

        public void setWithTheValueOfResultWhenClosed() {
            set(this.resultWhenClosed);
        }
    }

    public <T> SequencedFuture<T> createSequencedFuture(T t2) {
        SequencedFuture<T> sequencedFutureCreate;
        synchronized (this.lock) {
            try {
                int iObtainNextSequenceNumber = obtainNextSequenceNumber();
                sequencedFutureCreate = SequencedFuture.create(iObtainNextSequenceNumber, t2);
                if (this.isReleased) {
                    sequencedFutureCreate.setWithTheValueOfResultWhenClosed();
                } else {
                    this.seqToFutureMap.put(Integer.valueOf(iObtainNextSequenceNumber), sequencedFutureCreate);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        return sequencedFutureCreate;
    }

    public void lazyRelease(long j2, Runnable runnable) {
        synchronized (this.lock) {
            try {
                Handler handlerCreateHandlerForCurrentLooper = Util.createHandlerForCurrentLooper();
                this.releaseCallbackHandler = handlerCreateHandlerForCurrentLooper;
                this.pendingLazyReleaseCallback = runnable;
                if (this.seqToFutureMap.isEmpty()) {
                    release();
                } else {
                    handlerCreateHandlerForCurrentLooper.postDelayed(new Runnable() { // from class: androidx.media3.session.O5
                        @Override // java.lang.Runnable
                        public final void run() {
                            this.f2427b.release();
                        }
                    }, j2);
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public int obtainNextSequenceNumber() {
        int i2;
        synchronized (this.lock) {
            i2 = this.nextSequenceNumber;
            this.nextSequenceNumber = i2 + 1;
        }
        return i2;
    }

    public void release() {
        ArrayList arrayList;
        synchronized (this.lock) {
            try {
                this.isReleased = true;
                arrayList = new ArrayList(this.seqToFutureMap.values());
                this.seqToFutureMap.clear();
                if (this.pendingLazyReleaseCallback != null) {
                    ((Handler) Assertions.checkNotNull(this.releaseCallbackHandler)).post(this.pendingLazyReleaseCallback);
                    this.pendingLazyReleaseCallback = null;
                    this.releaseCallbackHandler = null;
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            ((SequencedFuture) it.next()).setWithTheValueOfResultWhenClosed();
        }
    }

    public <T> void setFutureResult(int i2, T t2) {
        synchronized (this.lock) {
            try {
                SequencedFuture<?> sequencedFutureRemove = this.seqToFutureMap.remove(Integer.valueOf(i2));
                if (sequencedFutureRemove != null) {
                    if (sequencedFutureRemove.getResultWhenClosed().getClass() == t2.getClass()) {
                        sequencedFutureRemove.set(t2);
                    } else {
                        Log.w(TAG, "Type mismatch, expected " + sequencedFutureRemove.getResultWhenClosed().getClass() + ", but was " + t2.getClass());
                    }
                }
                if (this.pendingLazyReleaseCallback != null && this.seqToFutureMap.isEmpty()) {
                    release();
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }
}