package androidx.lifecycle;

import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.SafeIterableMap;
import androidx.lifecycle.Lifecycle;

/* loaded from: classes.dex */
public abstract class LiveData<T> {
    static final Object i = new Object();
    final Object a = new Object();
    private SafeIterableMap<Observer<? super T>, LiveData<T>.ObserverWrapper> b = new SafeIterableMap<>();
    int c = 0;
    private volatile Object d;
    volatile Object e;
    private int f;
    private boolean g;
    private boolean h;

    private abstract class ObserverWrapper {
        final Observer<? super T> a;
        boolean b;
        int c = -1;

        ObserverWrapper(Observer<? super T> observer) {
            this.a = observer;
        }

        void a() {
        }

        void a(boolean z) {
            if (z == this.b) {
                return;
            }
            this.b = z;
            boolean z2 = LiveData.this.c == 0;
            LiveData.this.c += this.b ? 1 : -1;
            if (z2 && this.b) {
                LiveData.this.a();
            }
            LiveData liveData = LiveData.this;
            if (liveData.c == 0 && !this.b) {
                liveData.b();
            }
            if (this.b) {
                LiveData.this.a(this);
            }
        }

        boolean a(LifecycleOwner lifecycleOwner) {
            return false;
        }

        abstract boolean b();
    }

    public LiveData() {
        Object obj = i;
        this.d = obj;
        this.e = obj;
        this.f = -1;
        new Runnable() { // from class: androidx.lifecycle.LiveData.1
            /* JADX WARN: Multi-variable type inference failed */
            @Override // java.lang.Runnable
            public void run() {
                Object obj2;
                synchronized (LiveData.this.a) {
                    obj2 = LiveData.this.e;
                    LiveData.this.e = LiveData.i;
                }
                LiveData.this.a((LiveData) obj2);
            }
        };
    }

    private void b(LiveData<T>.ObserverWrapper observerWrapper) {
        if (observerWrapper.b) {
            if (!observerWrapper.b()) {
                observerWrapper.a(false);
                return;
            }
            int i2 = observerWrapper.c;
            int i3 = this.f;
            if (i2 >= i3) {
                return;
            }
            observerWrapper.c = i3;
            observerWrapper.a.a((Object) this.d);
        }
    }

    protected void a() {
    }

    void a(LiveData<T>.ObserverWrapper observerWrapper) {
        if (this.g) {
            this.h = true;
            return;
        }
        this.g = true;
        do {
            this.h = false;
            if (observerWrapper != null) {
                b(observerWrapper);
                observerWrapper = null;
            } else {
                SafeIterableMap<Observer<? super T>, LiveData<T>.ObserverWrapper>.IteratorWithAdditions b = this.b.b();
                while (b.hasNext()) {
                    b((ObserverWrapper) b.next().getValue());
                    if (this.h) {
                        break;
                    }
                }
            }
        } while (this.h);
        this.g = false;
    }

    protected void b() {
    }

    class LifecycleBoundObserver extends LiveData<T>.ObserverWrapper implements GenericLifecycleObserver {
        final LifecycleOwner e;

        LifecycleBoundObserver(LifecycleOwner lifecycleOwner, Observer<? super T> observer) {
            super(observer);
            this.e = lifecycleOwner;
        }

        @Override // androidx.lifecycle.GenericLifecycleObserver
        public void a(LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
            if (this.e.getLifecycle().a() == Lifecycle.State.DESTROYED) {
                LiveData.this.a((Observer) this.a);
            } else {
                a(b());
            }
        }

        @Override // androidx.lifecycle.LiveData.ObserverWrapper
        boolean b() {
            return this.e.getLifecycle().a().isAtLeast(Lifecycle.State.STARTED);
        }

        @Override // androidx.lifecycle.LiveData.ObserverWrapper
        boolean a(LifecycleOwner lifecycleOwner) {
            return this.e == lifecycleOwner;
        }

        @Override // androidx.lifecycle.LiveData.ObserverWrapper
        void a() {
            this.e.getLifecycle().b(this);
        }
    }

    public void a(LifecycleOwner lifecycleOwner, Observer<? super T> observer) {
        a("observe");
        if (lifecycleOwner.getLifecycle().a() == Lifecycle.State.DESTROYED) {
            return;
        }
        LifecycleBoundObserver lifecycleBoundObserver = new LifecycleBoundObserver(lifecycleOwner, observer);
        LiveData<T>.ObserverWrapper b = this.b.b(observer, lifecycleBoundObserver);
        if (b != null && !b.a(lifecycleOwner)) {
            throw new IllegalArgumentException("Cannot add the same observer with different lifecycles");
        }
        if (b != null) {
            return;
        }
        lifecycleOwner.getLifecycle().a(lifecycleBoundObserver);
    }

    public void a(Observer<? super T> observer) {
        a("removeObserver");
        LiveData<T>.ObserverWrapper remove = this.b.remove(observer);
        if (remove == null) {
            return;
        }
        remove.a();
        remove.a(false);
    }

    protected void a(T t) {
        a("setValue");
        this.f++;
        this.d = t;
        a((ObserverWrapper) null);
    }

    private static void a(String str) {
        if (ArchTaskExecutor.b().a()) {
            return;
        }
        throw new IllegalStateException("Cannot invoke " + str + " on a background thread");
    }
}