package a.b.c.d;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/* JADX INFO: compiled from: SelfDestructiveThread.java */
/* JADX INFO: loaded from: classes.dex */
public class c {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    private HandlerThread f148b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    private Handler f149c;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    private final int f152f;
    private final int g;
    private final String h;

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    private final Object f147a = new Object();

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    private Handler.Callback f151e = new a();

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    private int f150d = 0;

    /* JADX INFO: compiled from: SelfDestructiveThread.java */
    class a implements Handler.Callback {
        a() {
        }

        @Override // android.os.Handler.Callback
        public boolean handleMessage(Message message) {
            int i = message.what;
            if (i == 0) {
                c.this.a();
                return true;
            }
            if (i != 1) {
                return true;
            }
            c.this.b((Runnable) message.obj);
            return true;
        }
    }

    /* JADX INFO: compiled from: SelfDestructiveThread.java */
    class b implements Runnable {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ Callable f154b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        final /* synthetic */ Handler f155c;

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        final /* synthetic */ d f156d;

        /* JADX INFO: compiled from: SelfDestructiveThread.java */
        class a implements Runnable {

            /* JADX INFO: renamed from: b, reason: collision with root package name */
            final /* synthetic */ Object f157b;

            a(Object obj) {
                this.f157b = obj;
            }

            @Override // java.lang.Runnable
            public void run() {
                b.this.f156d.a(this.f157b);
            }
        }

        b(c cVar, Callable callable, Handler handler, d dVar) {
            this.f154b = callable;
            this.f155c = handler;
            this.f156d = dVar;
        }

        @Override // java.lang.Runnable
        public void run() {
            Object objCall;
            try {
                objCall = this.f154b.call();
            } catch (Exception unused) {
                objCall = null;
            }
            this.f155c.post(new a(objCall));
        }
    }

    /* JADX INFO: renamed from: a.b.c.d.c$c, reason: collision with other inner class name */
    /* JADX INFO: compiled from: SelfDestructiveThread.java */
    class RunnableC0008c implements Runnable {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        final /* synthetic */ AtomicReference f159b;

        /* JADX INFO: renamed from: c, reason: collision with root package name */
        final /* synthetic */ Callable f160c;

        /* JADX INFO: renamed from: d, reason: collision with root package name */
        final /* synthetic */ ReentrantLock f161d;

        /* JADX INFO: renamed from: e, reason: collision with root package name */
        final /* synthetic */ AtomicBoolean f162e;

        /* JADX INFO: renamed from: f, reason: collision with root package name */
        final /* synthetic */ Condition f163f;

        RunnableC0008c(c cVar, AtomicReference atomicReference, Callable callable, ReentrantLock reentrantLock, AtomicBoolean atomicBoolean, Condition condition) {
            this.f159b = atomicReference;
            this.f160c = callable;
            this.f161d = reentrantLock;
            this.f162e = atomicBoolean;
            this.f163f = condition;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                this.f159b.set(this.f160c.call());
            } catch (Exception unused) {
            }
            this.f161d.lock();
            try {
                this.f162e.set(false);
                this.f163f.signal();
            } finally {
                this.f161d.unlock();
            }
        }
    }

    /* JADX INFO: compiled from: SelfDestructiveThread.java */
    public interface d<T> {
        void a(T t);
    }

    public c(String str, int i, int i2) {
        this.h = str;
        this.g = i;
        this.f152f = i2;
    }

    private void c(Runnable runnable) {
        synchronized (this.f147a) {
            if (this.f148b == null) {
                HandlerThread handlerThread = new HandlerThread(this.h, this.g);
                this.f148b = handlerThread;
                handlerThread.start();
                this.f149c = new Handler(this.f148b.getLooper(), this.f151e);
                this.f150d++;
            }
            this.f149c.removeMessages(0);
            this.f149c.sendMessage(this.f149c.obtainMessage(1, runnable));
        }
    }

    void a() {
        synchronized (this.f147a) {
            if (this.f149c.hasMessages(1)) {
                return;
            }
            this.f148b.quit();
            this.f148b = null;
            this.f149c = null;
        }
    }

    void b(Runnable runnable) {
        runnable.run();
        synchronized (this.f147a) {
            this.f149c.removeMessages(0);
            this.f149c.sendMessageDelayed(this.f149c.obtainMessage(0), this.f152f);
        }
    }

    public <T> void d(Callable<T> callable, d<T> dVar) {
        c(new b(this, callable, new Handler(), dVar));
    }

    public <T> T e(Callable<T> callable, int i) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition conditionNewCondition = reentrantLock.newCondition();
        AtomicReference atomicReference = new AtomicReference();
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        c(new RunnableC0008c(this, atomicReference, callable, reentrantLock, atomicBoolean, conditionNewCondition));
        reentrantLock.lock();
        try {
            if (!atomicBoolean.get()) {
                return (T) atomicReference.get();
            }
            long nanos = TimeUnit.MILLISECONDS.toNanos(i);
            do {
                try {
                    nanos = conditionNewCondition.awaitNanos(nanos);
                } catch (InterruptedException unused) {
                }
                if (!atomicBoolean.get()) {
                    return (T) atomicReference.get();
                }
            } while (nanos > 0);
            throw new InterruptedException("timeout");
        } finally {
            reentrantLock.unlock();
        }
    }
}