Initial commit
This commit is contained in:
@@ -0,0 +1,242 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import android.os.Handler;
|
||||
import android.os.Looper;
|
||||
import android.os.Message;
|
||||
import android.os.Process;
|
||||
import android.util.Log;
|
||||
import com.ubtrobot.jimu.robotapi.PeripheralType;
|
||||
import java.util.LinkedList;
|
||||
import java.util.concurrent.BlockingQueue;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.CancellationException;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.Executor;
|
||||
import java.util.concurrent.FutureTask;
|
||||
import java.util.concurrent.LinkedBlockingQueue;
|
||||
import java.util.concurrent.ThreadFactory;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public abstract class AsyncTask<Params, Progress, Result> {
|
||||
private static final int f = Runtime.getRuntime().availableProcessors();
|
||||
private static final int g;
|
||||
private static final int h;
|
||||
private static final ThreadFactory i;
|
||||
private static final BlockingQueue<Runnable> j;
|
||||
public static final Executor k;
|
||||
public static final Executor l;
|
||||
private static final InternalHandler m;
|
||||
private volatile Status c = Status.PENDING;
|
||||
private final AtomicBoolean d = new AtomicBoolean();
|
||||
private final AtomicBoolean e = new AtomicBoolean();
|
||||
private final WorkerRunnable<Params, Result> a = new WorkerRunnable<Params, Result>() { // from class: io.fabric.sdk.android.services.concurrency.AsyncTask.2
|
||||
@Override // java.util.concurrent.Callable
|
||||
public Result call() throws Exception {
|
||||
AsyncTask.this.e.set(true);
|
||||
Process.setThreadPriority(10);
|
||||
AsyncTask asyncTask = AsyncTask.this;
|
||||
Result result = (Result) asyncTask.a(this.a);
|
||||
AsyncTask.a(asyncTask, result);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
private final FutureTask<Result> b = new FutureTask<Result>(this.a) { // from class: io.fabric.sdk.android.services.concurrency.AsyncTask.3
|
||||
@Override // java.util.concurrent.FutureTask
|
||||
protected void done() {
|
||||
try {
|
||||
AsyncTask.this.f(get());
|
||||
} catch (InterruptedException e) {
|
||||
Log.w("AsyncTask", e);
|
||||
} catch (CancellationException unused) {
|
||||
AsyncTask.this.f(null);
|
||||
} catch (ExecutionException e2) {
|
||||
throw new RuntimeException("An error occured while executing doInBackground()", e2.getCause());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/* renamed from: io.fabric.sdk.android.services.concurrency.AsyncTask$4, reason: invalid class name */
|
||||
static /* synthetic */ class AnonymousClass4 {
|
||||
static final /* synthetic */ int[] a = new int[Status.values().length];
|
||||
|
||||
static {
|
||||
try {
|
||||
a[Status.RUNNING.ordinal()] = 1;
|
||||
} catch (NoSuchFieldError unused) {
|
||||
}
|
||||
try {
|
||||
a[Status.FINISHED.ordinal()] = 2;
|
||||
} catch (NoSuchFieldError unused2) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class AsyncTaskResult<Data> {
|
||||
final AsyncTask a;
|
||||
final Data[] b;
|
||||
|
||||
AsyncTaskResult(AsyncTask asyncTask, Data... dataArr) {
|
||||
this.a = asyncTask;
|
||||
this.b = dataArr;
|
||||
}
|
||||
}
|
||||
|
||||
private static class InternalHandler extends Handler {
|
||||
public InternalHandler() {
|
||||
super(Looper.getMainLooper());
|
||||
}
|
||||
|
||||
@Override // android.os.Handler
|
||||
public void handleMessage(Message message) {
|
||||
AsyncTaskResult asyncTaskResult = (AsyncTaskResult) message.obj;
|
||||
int i = message.what;
|
||||
if (i == 1) {
|
||||
asyncTaskResult.a.d(asyncTaskResult.b[0]);
|
||||
} else {
|
||||
if (i != 2) {
|
||||
return;
|
||||
}
|
||||
asyncTaskResult.a.b((Object[]) asyncTaskResult.b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class SerialExecutor implements Executor {
|
||||
final LinkedList<Runnable> a;
|
||||
Runnable b;
|
||||
|
||||
private SerialExecutor() {
|
||||
this.a = new LinkedList<>();
|
||||
}
|
||||
|
||||
protected synchronized void a() {
|
||||
Runnable poll = this.a.poll();
|
||||
this.b = poll;
|
||||
if (poll != null) {
|
||||
AsyncTask.k.execute(this.b);
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Executor
|
||||
public synchronized void execute(final Runnable runnable) {
|
||||
this.a.offer(new Runnable() { // from class: io.fabric.sdk.android.services.concurrency.AsyncTask.SerialExecutor.1
|
||||
@Override // java.lang.Runnable
|
||||
public void run() {
|
||||
try {
|
||||
runnable.run();
|
||||
} finally {
|
||||
SerialExecutor.this.a();
|
||||
}
|
||||
}
|
||||
});
|
||||
if (this.b == null) {
|
||||
a();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum Status {
|
||||
PENDING,
|
||||
RUNNING,
|
||||
FINISHED
|
||||
}
|
||||
|
||||
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
|
||||
Params[] a;
|
||||
|
||||
private WorkerRunnable() {
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
int i2 = f;
|
||||
g = i2 + 1;
|
||||
h = (i2 * 2) + 1;
|
||||
i = new ThreadFactory() { // from class: io.fabric.sdk.android.services.concurrency.AsyncTask.1
|
||||
private final AtomicInteger a = new AtomicInteger(1);
|
||||
|
||||
@Override // java.util.concurrent.ThreadFactory
|
||||
public Thread newThread(Runnable runnable) {
|
||||
return new Thread(runnable, "AsyncTask #" + this.a.getAndIncrement());
|
||||
}
|
||||
};
|
||||
j = new LinkedBlockingQueue(PeripheralType.SERVO);
|
||||
k = new ThreadPoolExecutor(g, h, 1L, TimeUnit.SECONDS, j, i);
|
||||
l = new SerialExecutor();
|
||||
m = new InternalHandler();
|
||||
}
|
||||
|
||||
private Result e(Result result) {
|
||||
m.obtainMessage(1, new AsyncTaskResult(this, result)).sendToTarget();
|
||||
return result;
|
||||
}
|
||||
|
||||
/* JADX INFO: Access modifiers changed from: private */
|
||||
public void f(Result result) {
|
||||
if (this.e.get()) {
|
||||
return;
|
||||
}
|
||||
e(result);
|
||||
}
|
||||
|
||||
protected abstract Result a(Params... paramsArr);
|
||||
|
||||
protected abstract void b(Result result);
|
||||
|
||||
protected void b(Progress... progressArr) {
|
||||
}
|
||||
|
||||
protected abstract void c(Result result);
|
||||
|
||||
public final Status d() {
|
||||
return this.c;
|
||||
}
|
||||
|
||||
protected void f() {
|
||||
}
|
||||
|
||||
static /* synthetic */ Object a(AsyncTask asyncTask, Object obj) {
|
||||
asyncTask.e(obj);
|
||||
return obj;
|
||||
}
|
||||
|
||||
/* JADX INFO: Access modifiers changed from: private */
|
||||
public void d(Result result) {
|
||||
if (e()) {
|
||||
b((AsyncTask<Params, Progress, Result>) result);
|
||||
} else {
|
||||
c(result);
|
||||
}
|
||||
this.c = Status.FINISHED;
|
||||
}
|
||||
|
||||
public final boolean b(boolean z) {
|
||||
this.d.set(true);
|
||||
return this.b.cancel(z);
|
||||
}
|
||||
|
||||
public final AsyncTask<Params, Progress, Result> a(Executor executor, Params... paramsArr) {
|
||||
if (this.c != Status.PENDING) {
|
||||
int i2 = AnonymousClass4.a[this.c.ordinal()];
|
||||
if (i2 == 1) {
|
||||
throw new IllegalStateException("Cannot execute task: the task is already running.");
|
||||
}
|
||||
if (i2 == 2) {
|
||||
throw new IllegalStateException("Cannot execute task: the task has already been executed (a task can be executed only once)");
|
||||
}
|
||||
}
|
||||
this.c = Status.RUNNING;
|
||||
f();
|
||||
this.a.a = paramsArr;
|
||||
executor.execute(this.b);
|
||||
return this;
|
||||
}
|
||||
|
||||
public final boolean e() {
|
||||
return this.d.get();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public interface DelegateProvider {
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public interface Dependency<T> {
|
||||
void a(T t);
|
||||
|
||||
boolean c();
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import io.fabric.sdk.android.services.concurrency.Dependency;
|
||||
import io.fabric.sdk.android.services.concurrency.PriorityProvider;
|
||||
import io.fabric.sdk.android.services.concurrency.Task;
|
||||
import java.lang.reflect.Array;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Queue;
|
||||
import java.util.concurrent.PriorityBlockingQueue;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public class DependencyPriorityBlockingQueue<E extends Dependency & Task & PriorityProvider> extends PriorityBlockingQueue<E> {
|
||||
static final int PEEK = 1;
|
||||
static final int POLL = 2;
|
||||
static final int POLL_WITH_TIMEOUT = 3;
|
||||
static final int TAKE = 0;
|
||||
final Queue<E> blockedQueue = new LinkedList();
|
||||
private final ReentrantLock lock = new ReentrantLock();
|
||||
|
||||
boolean canProcess(E e) {
|
||||
return e.c();
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractQueue, java.util.AbstractCollection, java.util.Collection
|
||||
public void clear() {
|
||||
try {
|
||||
this.lock.lock();
|
||||
this.blockedQueue.clear();
|
||||
super.clear();
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
<T> T[] concatenate(T[] tArr, T[] tArr2) {
|
||||
int length = tArr.length;
|
||||
int length2 = tArr2.length;
|
||||
T[] tArr3 = (T[]) ((Object[]) Array.newInstance(tArr.getClass().getComponentType(), length + length2));
|
||||
System.arraycopy(tArr, 0, tArr3, 0, length);
|
||||
System.arraycopy(tArr2, 0, tArr3, length, length2);
|
||||
return tArr3;
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection, java.util.concurrent.BlockingQueue
|
||||
public boolean contains(Object obj) {
|
||||
boolean z;
|
||||
try {
|
||||
this.lock.lock();
|
||||
if (!super.contains(obj)) {
|
||||
if (!this.blockedQueue.contains(obj)) {
|
||||
z = false;
|
||||
return z;
|
||||
}
|
||||
}
|
||||
z = true;
|
||||
return z;
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.concurrent.BlockingQueue
|
||||
public int drainTo(Collection<? super E> collection) {
|
||||
try {
|
||||
this.lock.lock();
|
||||
int drainTo = super.drainTo(collection) + this.blockedQueue.size();
|
||||
while (!this.blockedQueue.isEmpty()) {
|
||||
collection.add(this.blockedQueue.poll());
|
||||
}
|
||||
return drainTo;
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
E get(int i, Long l, TimeUnit timeUnit) throws InterruptedException {
|
||||
E performOperation;
|
||||
while (true) {
|
||||
performOperation = performOperation(i, l, timeUnit);
|
||||
if (performOperation == null || canProcess(performOperation)) {
|
||||
break;
|
||||
}
|
||||
offerBlockedResult(i, performOperation);
|
||||
}
|
||||
return performOperation;
|
||||
}
|
||||
|
||||
boolean offerBlockedResult(int i, E e) {
|
||||
try {
|
||||
this.lock.lock();
|
||||
if (i == 1) {
|
||||
super.remove(e);
|
||||
}
|
||||
return this.blockedQueue.offer(e);
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
E performOperation(int i, Long l, TimeUnit timeUnit) throws InterruptedException {
|
||||
if (i == 0) {
|
||||
return (E) ((Dependency) super.take());
|
||||
}
|
||||
if (i == 1) {
|
||||
return (E) ((Dependency) super.peek());
|
||||
}
|
||||
if (i == 2) {
|
||||
return (E) ((Dependency) super.poll());
|
||||
}
|
||||
if (i != 3) {
|
||||
return null;
|
||||
}
|
||||
return (E) ((Dependency) super.poll(l.longValue(), timeUnit));
|
||||
}
|
||||
|
||||
public void recycleBlockedQueue() {
|
||||
try {
|
||||
this.lock.lock();
|
||||
Iterator<E> it = this.blockedQueue.iterator();
|
||||
while (it.hasNext()) {
|
||||
E next = it.next();
|
||||
if (canProcess(next)) {
|
||||
super.offer(next);
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection, java.util.concurrent.BlockingQueue
|
||||
public boolean remove(Object obj) {
|
||||
boolean z;
|
||||
try {
|
||||
this.lock.lock();
|
||||
if (!super.remove(obj)) {
|
||||
if (!this.blockedQueue.remove(obj)) {
|
||||
z = false;
|
||||
return z;
|
||||
}
|
||||
}
|
||||
z = true;
|
||||
return z;
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection
|
||||
public boolean removeAll(Collection<?> collection) {
|
||||
try {
|
||||
this.lock.lock();
|
||||
return this.blockedQueue.removeAll(collection) | super.removeAll(collection);
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection
|
||||
public int size() {
|
||||
try {
|
||||
this.lock.lock();
|
||||
return this.blockedQueue.size() + super.size();
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection
|
||||
public <T> T[] toArray(T[] tArr) {
|
||||
try {
|
||||
this.lock.lock();
|
||||
return (T[]) concatenate(super.toArray(tArr), this.blockedQueue.toArray(tArr));
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.Queue
|
||||
public E peek() {
|
||||
try {
|
||||
return get(1, null, null);
|
||||
} catch (InterruptedException unused) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.concurrent.BlockingQueue
|
||||
public E take() throws InterruptedException {
|
||||
return get(0, null, null);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.concurrent.BlockingQueue
|
||||
public E poll(long j, TimeUnit timeUnit) throws InterruptedException {
|
||||
return get(3, Long.valueOf(j), timeUnit);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.Queue
|
||||
public E poll() {
|
||||
try {
|
||||
return get(2, null, null);
|
||||
} catch (InterruptedException unused) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.AbstractCollection, java.util.Collection
|
||||
public Object[] toArray() {
|
||||
try {
|
||||
this.lock.lock();
|
||||
return concatenate(super.toArray(), this.blockedQueue.toArray());
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.PriorityBlockingQueue, java.util.concurrent.BlockingQueue
|
||||
public int drainTo(Collection<? super E> collection, int i) {
|
||||
try {
|
||||
this.lock.lock();
|
||||
int drainTo = super.drainTo(collection, i);
|
||||
while (!this.blockedQueue.isEmpty() && drainTo <= i) {
|
||||
collection.add(this.blockedQueue.poll());
|
||||
drainTo++;
|
||||
}
|
||||
return drainTo;
|
||||
} finally {
|
||||
this.lock.unlock();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
/* loaded from: classes2.dex */
|
||||
public @interface DependsOn {
|
||||
Class<?>[] value();
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public enum Priority {
|
||||
LOW,
|
||||
NORMAL,
|
||||
HIGH,
|
||||
IMMEDIATE;
|
||||
|
||||
static <Y> int compareTo(PriorityProvider priorityProvider, Y y) {
|
||||
return (y instanceof PriorityProvider ? ((PriorityProvider) y).a() : NORMAL).ordinal() - priorityProvider.a().ordinal();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import io.fabric.sdk.android.services.concurrency.AsyncTask;
|
||||
import java.util.concurrent.Executor;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public abstract class PriorityAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> implements Dependency<Task>, PriorityProvider, Task, DelegateProvider {
|
||||
private final PriorityTask n = new PriorityTask();
|
||||
|
||||
private static class ProxyExecutor<Result> implements Executor {
|
||||
private final Executor a;
|
||||
private final PriorityAsyncTask b;
|
||||
|
||||
public ProxyExecutor(Executor executor, PriorityAsyncTask priorityAsyncTask) {
|
||||
this.a = executor;
|
||||
this.b = priorityAsyncTask;
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.Executor
|
||||
public void execute(Runnable runnable) {
|
||||
this.a.execute(new PriorityFutureTask<Result>(runnable, null) { // from class: io.fabric.sdk.android.services.concurrency.PriorityAsyncTask.ProxyExecutor.1
|
||||
/* JADX WARN: Incorrect return type in method signature: <T::Lio/fabric/sdk/android/services/concurrency/Dependency<Lio/fabric/sdk/android/services/concurrency/Task;>;:Lio/fabric/sdk/android/services/concurrency/PriorityProvider;:Lio/fabric/sdk/android/services/concurrency/Task;>()TT; */
|
||||
@Override // io.fabric.sdk.android.services.concurrency.PriorityFutureTask
|
||||
public Dependency d() {
|
||||
return ProxyExecutor.this.b;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public boolean b() {
|
||||
return ((Task) ((PriorityProvider) g())).b();
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public boolean c() {
|
||||
return ((Dependency) ((PriorityProvider) g())).c();
|
||||
}
|
||||
|
||||
@Override // java.lang.Comparable
|
||||
public int compareTo(Object obj) {
|
||||
return Priority.compareTo(this, obj);
|
||||
}
|
||||
|
||||
/* JADX WARN: Incorrect return type in method signature: <T::Lio/fabric/sdk/android/services/concurrency/Dependency<Lio/fabric/sdk/android/services/concurrency/Task;>;:Lio/fabric/sdk/android/services/concurrency/PriorityProvider;:Lio/fabric/sdk/android/services/concurrency/Task;>()TT; */
|
||||
public Dependency g() {
|
||||
return this.n;
|
||||
}
|
||||
|
||||
public final void a(ExecutorService executorService, Params... paramsArr) {
|
||||
super.a(new ProxyExecutor(executorService, this), paramsArr);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public void a(Task task) {
|
||||
if (d() == AsyncTask.Status.PENDING) {
|
||||
((Dependency) ((PriorityProvider) g())).a(task);
|
||||
return;
|
||||
}
|
||||
throw new IllegalStateException("Must not add Dependency after task is running");
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public void a(boolean z) {
|
||||
((Task) ((PriorityProvider) g())).a(z);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public void a(Throwable th) {
|
||||
((Task) ((PriorityProvider) g())).a(th);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.FutureTask;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public class PriorityFutureTask<V> extends FutureTask<V> implements Dependency<Task>, PriorityProvider, Task, DelegateProvider {
|
||||
final Object a;
|
||||
|
||||
public PriorityFutureTask(Callable<V> callable) {
|
||||
super(callable);
|
||||
this.a = b(callable);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public boolean b() {
|
||||
return ((Task) ((PriorityProvider) d())).b();
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public boolean c() {
|
||||
return ((Dependency) ((PriorityProvider) d())).c();
|
||||
}
|
||||
|
||||
@Override // java.lang.Comparable
|
||||
public int compareTo(Object obj) {
|
||||
return ((PriorityProvider) d()).compareTo(obj);
|
||||
}
|
||||
|
||||
/* JADX WARN: Incorrect return type in method signature: <T::Lio/fabric/sdk/android/services/concurrency/Dependency<Lio/fabric/sdk/android/services/concurrency/Task;>;:Lio/fabric/sdk/android/services/concurrency/PriorityProvider;:Lio/fabric/sdk/android/services/concurrency/Task;>()TT; */
|
||||
public Dependency d() {
|
||||
return (Dependency) this.a;
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public void a(Task task) {
|
||||
((Dependency) ((PriorityProvider) d())).a(task);
|
||||
}
|
||||
|
||||
/* JADX WARN: Incorrect return type in method signature: <T::Lio/fabric/sdk/android/services/concurrency/Dependency<Lio/fabric/sdk/android/services/concurrency/Task;>;:Lio/fabric/sdk/android/services/concurrency/PriorityProvider;:Lio/fabric/sdk/android/services/concurrency/Task;>(Ljava/lang/Object;)TT; */
|
||||
protected Dependency b(Object obj) {
|
||||
return PriorityTask.b(obj) ? (Dependency) obj : new PriorityTask();
|
||||
}
|
||||
|
||||
public PriorityFutureTask(Runnable runnable, V v) {
|
||||
super(runnable, v);
|
||||
this.a = b(runnable);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.PriorityProvider
|
||||
public Priority a() {
|
||||
return ((PriorityProvider) d()).a();
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public void a(boolean z) {
|
||||
((Task) ((PriorityProvider) d())).a(z);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public void a(Throwable th) {
|
||||
((Task) ((PriorityProvider) d())).a(th);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public interface PriorityProvider<T> extends Comparable<T> {
|
||||
Priority a();
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public class PriorityTask implements Dependency<Task>, PriorityProvider, Task {
|
||||
private final List<Task> a = new ArrayList();
|
||||
private final AtomicBoolean b = new AtomicBoolean(false);
|
||||
private final AtomicReference<Throwable> c = new AtomicReference<>(null);
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public boolean b() {
|
||||
return this.b.get();
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public boolean c() {
|
||||
Iterator<Task> it = d().iterator();
|
||||
while (it.hasNext()) {
|
||||
if (!it.next().b()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override // java.lang.Comparable
|
||||
public int compareTo(Object obj) {
|
||||
return Priority.compareTo(this, obj);
|
||||
}
|
||||
|
||||
public synchronized Collection<Task> d() {
|
||||
return Collections.unmodifiableCollection(this.a);
|
||||
}
|
||||
|
||||
public static boolean b(Object obj) {
|
||||
try {
|
||||
return (((Dependency) obj) == null || ((Task) obj) == null || ((PriorityProvider) obj) == null) ? false : true;
|
||||
} catch (ClassCastException unused) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Dependency
|
||||
public synchronized void a(Task task) {
|
||||
this.a.add(task);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public synchronized void a(boolean z) {
|
||||
this.b.set(z);
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.PriorityProvider
|
||||
public Priority a() {
|
||||
return Priority.NORMAL;
|
||||
}
|
||||
|
||||
@Override // io.fabric.sdk.android.services.concurrency.Task
|
||||
public void a(Throwable th) {
|
||||
this.c.set(th);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
import android.annotation.TargetApi;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.RunnableFuture;
|
||||
import java.util.concurrent.ThreadFactory;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public class PriorityThreadPoolExecutor extends ThreadPoolExecutor {
|
||||
private static final int a = Runtime.getRuntime().availableProcessors();
|
||||
private static final int b;
|
||||
private static final int c;
|
||||
|
||||
protected static final class PriorityThreadFactory implements ThreadFactory {
|
||||
private final int a;
|
||||
|
||||
public PriorityThreadFactory(int i) {
|
||||
this.a = i;
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.ThreadFactory
|
||||
public Thread newThread(Runnable runnable) {
|
||||
Thread thread = new Thread(runnable);
|
||||
thread.setPriority(this.a);
|
||||
thread.setName("Queue");
|
||||
return thread;
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
int i = a;
|
||||
b = i + 1;
|
||||
c = (i * 2) + 1;
|
||||
}
|
||||
|
||||
<T extends Runnable & Dependency & Task & PriorityProvider> PriorityThreadPoolExecutor(int i, int i2, long j, TimeUnit timeUnit, DependencyPriorityBlockingQueue<T> dependencyPriorityBlockingQueue, ThreadFactory threadFactory) {
|
||||
super(i, i2, j, timeUnit, dependencyPriorityBlockingQueue, threadFactory);
|
||||
prestartAllCoreThreads();
|
||||
}
|
||||
|
||||
public static <T extends Runnable & Dependency & Task & PriorityProvider> PriorityThreadPoolExecutor a(int i, int i2) {
|
||||
return new PriorityThreadPoolExecutor(i, i2, 1L, TimeUnit.SECONDS, new DependencyPriorityBlockingQueue(), new PriorityThreadFactory(10));
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.ThreadPoolExecutor
|
||||
protected void afterExecute(Runnable runnable, Throwable th) {
|
||||
Task task = (Task) runnable;
|
||||
task.a(true);
|
||||
task.a(th);
|
||||
getQueue().recycleBlockedQueue();
|
||||
super.afterExecute(runnable, th);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.ThreadPoolExecutor, java.util.concurrent.Executor
|
||||
@TargetApi(9)
|
||||
public void execute(Runnable runnable) {
|
||||
if (PriorityTask.b(runnable)) {
|
||||
super.execute(runnable);
|
||||
} else {
|
||||
super.execute(newTaskFor(runnable, null));
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.AbstractExecutorService
|
||||
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T t) {
|
||||
return new PriorityFutureTask(runnable, t);
|
||||
}
|
||||
|
||||
public static PriorityThreadPoolExecutor a() {
|
||||
return a(b, c);
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.ThreadPoolExecutor
|
||||
public DependencyPriorityBlockingQueue getQueue() {
|
||||
return (DependencyPriorityBlockingQueue) super.getQueue();
|
||||
}
|
||||
|
||||
@Override // java.util.concurrent.AbstractExecutorService
|
||||
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
|
||||
return new PriorityFutureTask(callable);
|
||||
}
|
||||
}
|
||||
10
sources/io/fabric/sdk/android/services/concurrency/Task.java
Normal file
10
sources/io/fabric/sdk/android/services/concurrency/Task.java
Normal file
@@ -0,0 +1,10 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public interface Task {
|
||||
void a(Throwable th);
|
||||
|
||||
void a(boolean z);
|
||||
|
||||
boolean b();
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
package io.fabric.sdk.android.services.concurrency;
|
||||
|
||||
/* loaded from: classes2.dex */
|
||||
public class UnmetDependencyException extends RuntimeException {
|
||||
public UnmetDependencyException() {
|
||||
}
|
||||
|
||||
public UnmetDependencyException(String str) {
|
||||
super(str);
|
||||
}
|
||||
|
||||
public UnmetDependencyException(String str, Throwable th) {
|
||||
super(str, th);
|
||||
}
|
||||
|
||||
public UnmetDependencyException(Throwable th) {
|
||||
super(th);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user