package a.c.f;

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

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

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

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

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

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

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    private int f227d = 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: c, reason: collision with root package name */
        final /* synthetic */ Callable f232c;

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

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

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

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

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

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

        b(Callable callable, Handler handler, d dVar) {
            this.f232c = callable;
            this.f233d = handler;
            this.f234e = dVar;
        }

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

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

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

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

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

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

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

        RunnableC0009c(AtomicReference atomicReference, Callable callable, ReentrantLock reentrantLock, AtomicBoolean atomicBoolean, Condition condition) {
            this.f238c = atomicReference;
            this.f239d = callable;
            this.f240e = reentrantLock;
            this.f241f = atomicBoolean;
            this.f242g = condition;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                this.f238c.set(this.f239d.call());
            } catch (Exception unused) {
            }
            this.f240e.lock();
            try {
                this.f241f.set(false);
                this.f242g.signal();
            } finally {
                this.f240e.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.f230g = i;
        this.f229f = i2;
    }

    private void c(Runnable runnable) {
        synchronized (this.f224a) {
            if (this.f225b == null) {
                HandlerThread handlerThread = new HandlerThread(this.h, this.f230g);
                this.f225b = handlerThread;
                handlerThread.start();
                this.f226c = new Handler(this.f225b.getLooper(), this.f228e);
                this.f227d++;
            }
            this.f226c.removeMessages(0);
            Handler handler = this.f226c;
            handler.sendMessage(handler.obtainMessage(1, runnable));
        }
    }

    void a() {
        synchronized (this.f224a) {
            if (this.f226c.hasMessages(1)) {
                return;
            }
            this.f225b.quit();
            this.f225b = null;
            this.f226c = null;
        }
    }

    void b(Runnable runnable) {
        runnable.run();
        synchronized (this.f224a) {
            this.f226c.removeMessages(0);
            Handler handler = this.f226c;
            handler.sendMessageDelayed(handler.obtainMessage(0), this.f229f);
        }
    }

    public <T> void d(Callable<T> callable, d<T> dVar) {
        c(new b(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 RunnableC0009c(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();
        }
    }
}