package c.f.i;

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 f1417b;

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

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    private final int f1421f;

    /* JADX INFO: renamed from: g, reason: collision with root package name */
    private final int f1422g;

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

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

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

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

        @Override // android.os.Handler.Callback
        public boolean handleMessage(Message message) {
            int i2 = message.what;
            if (i2 == 0) {
                c.this.a();
                return true;
            }
            if (i2 != 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 f1425b;

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

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

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

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

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

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

        b(c cVar, Callable callable, Handler handler, d dVar) {
            this.f1425b = callable;
            this.f1426f = handler;
            this.f1427g = dVar;
        }

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

    /* JADX INFO: renamed from: c.f.i.c$c, reason: collision with other inner class name */
    /* JADX INFO: compiled from: SelfDestructiveThread.java */
    class RunnableC0029c implements Runnable {

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

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

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

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

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

        RunnableC0029c(c cVar, AtomicReference atomicReference, Callable callable, ReentrantLock reentrantLock, AtomicBoolean atomicBoolean, Condition condition) {
            this.f1430b = atomicReference;
            this.f1431f = callable;
            this.f1432g = reentrantLock;
            this.f1433h = atomicBoolean;
            this.f1434i = condition;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                this.f1430b.set(this.f1431f.call());
            } catch (Exception unused) {
            }
            this.f1432g.lock();
            try {
                this.f1433h.set(false);
                this.f1434i.signal();
            } finally {
                this.f1432g.unlock();
            }
        }
    }

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

    public c(String str, int i2, int i3) {
        this.f1423h = str;
        this.f1422g = i2;
        this.f1421f = i3;
    }

    private void c(Runnable runnable) {
        synchronized (this.a) {
            if (this.f1417b == null) {
                HandlerThread handlerThread = new HandlerThread(this.f1423h, this.f1422g);
                this.f1417b = handlerThread;
                handlerThread.start();
                this.f1418c = new Handler(this.f1417b.getLooper(), this.f1420e);
                this.f1419d++;
            }
            this.f1418c.removeMessages(0);
            this.f1418c.sendMessage(this.f1418c.obtainMessage(1, runnable));
        }
    }

    void a() {
        synchronized (this.a) {
            if (this.f1418c.hasMessages(1)) {
                return;
            }
            this.f1417b.quit();
            this.f1417b = null;
            this.f1418c = null;
        }
    }

    void b(Runnable runnable) {
        runnable.run();
        synchronized (this.a) {
            this.f1418c.removeMessages(0);
            this.f1418c.sendMessageDelayed(this.f1418c.obtainMessage(0), this.f1421f);
        }
    }

    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 i2) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition conditionNewCondition = reentrantLock.newCondition();
        AtomicReference atomicReference = new AtomicReference();
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        c(new RunnableC0029c(this, atomicReference, callable, reentrantLock, atomicBoolean, conditionNewCondition));
        reentrantLock.lock();
        try {
            if (!atomicBoolean.get()) {
                return (T) atomicReference.get();
            }
            long nanos = TimeUnit.MILLISECONDS.toNanos(i2);
            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();
        }
    }
}