CrackMe.apk
Download file
package com.google.common.util.concurrent;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.AbstractFuture;
import com.google.common.util.concurrent.ForwardingListenableFuture;
import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Delayed;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@ElementTypesAreNonnullByDefault
public final class MoreExecutors {
private MoreExecutors() {
}
public static ExecutorService getExitingExecutorService(ThreadPoolExecutor threadPoolExecutor, long j, TimeUnit timeUnit) {
return new Application().getExitingExecutorService(threadPoolExecutor, j, timeUnit);
}
public static ExecutorService getExitingExecutorService(ThreadPoolExecutor threadPoolExecutor) {
return new Application().getExitingExecutorService(threadPoolExecutor);
}
public static ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor scheduledThreadPoolExecutor, long j, TimeUnit timeUnit) {
return new Application().getExitingScheduledExecutorService(scheduledThreadPoolExecutor, j, timeUnit);
}
public static ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor scheduledThreadPoolExecutor) {
return new Application().getExitingScheduledExecutorService(scheduledThreadPoolExecutor);
}
public static void addDelayedShutdownHook(ExecutorService executorService, long j, TimeUnit timeUnit) {
new Application().addDelayedShutdownHook(executorService, j, timeUnit);
}
static class Application {
Application() {
}
/* access modifiers changed from: package-private */
public final ExecutorService getExitingExecutorService(ThreadPoolExecutor threadPoolExecutor, long j, TimeUnit timeUnit) {
MoreExecutors.useDaemonThreadFactory(threadPoolExecutor);
ExecutorService unconfigurableExecutorService = Executors.unconfigurableExecutorService(threadPoolExecutor);
addDelayedShutdownHook(threadPoolExecutor, j, timeUnit);
return unconfigurableExecutorService;
}
/* access modifiers changed from: package-private */
public final ExecutorService getExitingExecutorService(ThreadPoolExecutor threadPoolExecutor) {
return getExitingExecutorService(threadPoolExecutor, 120, TimeUnit.SECONDS);
}
/* access modifiers changed from: package-private */
public final ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor scheduledThreadPoolExecutor, long j, TimeUnit timeUnit) {
MoreExecutors.useDaemonThreadFactory(scheduledThreadPoolExecutor);
ScheduledExecutorService unconfigurableScheduledExecutorService = Executors.unconfigurableScheduledExecutorService(scheduledThreadPoolExecutor);
addDelayedShutdownHook(scheduledThreadPoolExecutor, j, timeUnit);
return unconfigurableScheduledExecutorService;
}
/* access modifiers changed from: package-private */
public final ScheduledExecutorService getExitingScheduledExecutorService(ScheduledThreadPoolExecutor scheduledThreadPoolExecutor) {
return getExitingScheduledExecutorService(scheduledThreadPoolExecutor, 120, TimeUnit.SECONDS);
}
/* access modifiers changed from: package-private */
public final void addDelayedShutdownHook(ExecutorService executorService, long j, TimeUnit timeUnit) {
Preconditions.checkNotNull(executorService);
Preconditions.checkNotNull(timeUnit);
String valueOf = String.valueOf(executorService);
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 24);
sb.append("DelayedShutdownHook-for-");
sb.append(valueOf);
final ExecutorService executorService2 = executorService;
final long j2 = j;
final TimeUnit timeUnit2 = timeUnit;
addShutdownHook(MoreExecutors.newThread(sb.toString(), new Runnable(this) {
public void run() {
try {
executorService2.shutdown();
executorService2.awaitTermination(j2, timeUnit2);
} catch (InterruptedException unused) {
}
}
}));
}
/* access modifiers changed from: package-private */
public void addShutdownHook(Thread thread) {
Runtime.getRuntime().addShutdownHook(thread);
}
}
/* access modifiers changed from: private */
public static void useDaemonThreadFactory(ThreadPoolExecutor threadPoolExecutor) {
threadPoolExecutor.setThreadFactory(new ThreadFactoryBuilder().setDaemon(true).setThreadFactory(threadPoolExecutor.getThreadFactory()).build());
}
private static final class DirectExecutorService extends AbstractListeningExecutorService {
private final Object lock;
private int runningTasks;
private boolean shutdown;
private DirectExecutorService() {
this.lock = new Object();
this.runningTasks = 0;
this.shutdown = false;
}
public void execute(Runnable runnable) {
startTask();
try {
runnable.run();
} finally {
endTask();
}
}
public boolean isShutdown() {
boolean z;
synchronized (this.lock) {
z = this.shutdown;
}
return z;
}
public void shutdown() {
synchronized (this.lock) {
this.shutdown = true;
if (this.runningTasks == 0) {
this.lock.notifyAll();
}
}
}
public List<Runnable> shutdownNow() {
shutdown();
return Collections.emptyList();
}
public boolean isTerminated() {
boolean z;
synchronized (this.lock) {
z = this.shutdown && this.runningTasks == 0;
}
return z;
}
public boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
long nanos = timeUnit.toNanos(j);
synchronized (this.lock) {
while (true) {
if (this.shutdown && this.runningTasks == 0) {
return true;
}
if (nanos <= 0) {
return false;
}
long nanoTime = System.nanoTime();
TimeUnit.NANOSECONDS.timedWait(this.lock, nanos);
nanos -= System.nanoTime() - nanoTime;
}
}
}
private void startTask() {
synchronized (this.lock) {
if (!this.shutdown) {
this.runningTasks++;
} else {
throw new RejectedExecutionException("Executor already shutdown");
}
}
}
private void endTask() {
synchronized (this.lock) {
int i = this.runningTasks - 1;
this.runningTasks = i;
if (i == 0) {
this.lock.notifyAll();
}
}
}
}
public static ListeningExecutorService newDirectExecutorService() {
return new DirectExecutorService();
}
public static Executor directExecutor() {
return DirectExecutor.INSTANCE;
}
public static Executor newSequentialExecutor(Executor executor) {
return new SequentialExecutor(executor);
}
public static ListeningExecutorService listeningDecorator(ExecutorService executorService) {
ListeningExecutorService listeningExecutorService;
if (executorService instanceof ListeningExecutorService) {
return (ListeningExecutorService) executorService;
}
if (executorService instanceof ScheduledExecutorService) {
listeningExecutorService = new ScheduledListeningDecorator((ScheduledExecutorService) executorService);
} else {
listeningExecutorService = new ListeningDecorator(executorService);
}
return listeningExecutorService;
}
public static ListeningScheduledExecutorService listeningDecorator(ScheduledExecutorService scheduledExecutorService) {
if (scheduledExecutorService instanceof ListeningScheduledExecutorService) {
return (ListeningScheduledExecutorService) scheduledExecutorService;
}
return new ScheduledListeningDecorator(scheduledExecutorService);
}
private static class ListeningDecorator extends AbstractListeningExecutorService {
private final ExecutorService delegate;
ListeningDecorator(ExecutorService executorService) {
this.delegate = (ExecutorService) Preconditions.checkNotNull(executorService);
}
public final boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
return this.delegate.awaitTermination(j, timeUnit);
}
public final boolean isShutdown() {
return this.delegate.isShutdown();
}
public final boolean isTerminated() {
return this.delegate.isTerminated();
}
public final void shutdown() {
this.delegate.shutdown();
}
public final List<Runnable> shutdownNow() {
return this.delegate.shutdownNow();
}
public final void execute(Runnable runnable) {
this.delegate.execute(runnable);
}
public final String toString() {
String obj = super.toString();
String valueOf = String.valueOf(this.delegate);
StringBuilder sb = new StringBuilder(String.valueOf(obj).length() + 2 + String.valueOf(valueOf).length());
sb.append(obj);
sb.append("[");
sb.append(valueOf);
sb.append("]");
return sb.toString();
}
}
private static final class ScheduledListeningDecorator extends ListeningDecorator implements ListeningScheduledExecutorService {
final ScheduledExecutorService delegate;
ScheduledListeningDecorator(ScheduledExecutorService scheduledExecutorService) {
super(scheduledExecutorService);
this.delegate = (ScheduledExecutorService) Preconditions.checkNotNull(scheduledExecutorService);
}
public ListenableScheduledFuture<?> schedule(Runnable runnable, long j, TimeUnit timeUnit) {
TrustedListenableFutureTask create = TrustedListenableFutureTask.create(runnable, null);
return new ListenableScheduledTask(create, this.delegate.schedule(create, j, timeUnit));
}
public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long j, TimeUnit timeUnit) {
TrustedListenableFutureTask<V> create = TrustedListenableFutureTask.create(callable);
return new ListenableScheduledTask(create, this.delegate.schedule(create, j, timeUnit));
}
public ListenableScheduledFuture<?> scheduleAtFixedRate(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
NeverSuccessfulListenableFutureTask neverSuccessfulListenableFutureTask = new NeverSuccessfulListenableFutureTask(runnable);
return new ListenableScheduledTask(neverSuccessfulListenableFutureTask, this.delegate.scheduleAtFixedRate(neverSuccessfulListenableFutureTask, j, j2, timeUnit));
}
public ListenableScheduledFuture<?> scheduleWithFixedDelay(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
NeverSuccessfulListenableFutureTask neverSuccessfulListenableFutureTask = new NeverSuccessfulListenableFutureTask(runnable);
return new ListenableScheduledTask(neverSuccessfulListenableFutureTask, this.delegate.scheduleWithFixedDelay(neverSuccessfulListenableFutureTask, j, j2, timeUnit));
}
private static final class ListenableScheduledTask<V> extends ForwardingListenableFuture.SimpleForwardingListenableFuture<V> implements ListenableScheduledFuture<V> {
private final ScheduledFuture<?> scheduledDelegate;
public ListenableScheduledTask(ListenableFuture<V> listenableFuture, ScheduledFuture<?> scheduledFuture) {
super(listenableFuture);
this.scheduledDelegate = scheduledFuture;
}
public boolean cancel(boolean z) {
boolean cancel = super.cancel(z);
if (cancel) {
this.scheduledDelegate.cancel(z);
}
return cancel;
}
public long getDelay(TimeUnit timeUnit) {
return this.scheduledDelegate.getDelay(timeUnit);
}
public int compareTo(Delayed delayed) {
return this.scheduledDelegate.compareTo(delayed);
}
}
private static final class NeverSuccessfulListenableFutureTask extends AbstractFuture.TrustedFuture<Void> implements Runnable {
private final Runnable delegate;
public NeverSuccessfulListenableFutureTask(Runnable runnable) {
this.delegate = (Runnable) Preconditions.checkNotNull(runnable);
}
public void run() {
try {
this.delegate.run();
} catch (Throwable th) {
setException(th);
throw Throwables.propagate(th);
}
}
/* access modifiers changed from: protected */
public String pendingToString() {
String valueOf = String.valueOf(this.delegate);
StringBuilder sb = new StringBuilder(String.valueOf(valueOf).length() + 7);
sb.append("task=[");
sb.append(valueOf);
sb.append("]");
return sb.toString();
}
}
}
/* JADX WARNING: Removed duplicated region for block: B:30:0x0092 */
/* JADX WARNING: Removed duplicated region for block: B:53:0x00b7 A[SYNTHETIC] */
@com.google.common.util.concurrent.ParametricNullness
/* Code decompiled incorrectly, please refer to instructions dump. */
static <T> T invokeAnyImpl(com.google.common.util.concurrent.ListeningExecutorService r16, java.util.Collection<? extends java.util.concurrent.Callable<T>> r17, boolean r18, long r19, java.util.concurrent.TimeUnit r21) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException, java.util.concurrent.TimeoutException {
/*
r1 = r16
com.google.common.base.Preconditions.checkNotNull(r16)
com.google.common.base.Preconditions.checkNotNull(r21)
int r0 = r17.size()
r2 = 1
if (r0 <= 0) goto L_0x0011
r3 = 1
goto L_0x0012
L_0x0011:
r3 = 0
L_0x0012:
com.google.common.base.Preconditions.checkArgument(r3)
java.util.ArrayList r3 = com.google.common.collect.Lists.newArrayListWithCapacity(r0)
java.util.concurrent.LinkedBlockingQueue r4 = com.google.common.collect.Queues.newLinkedBlockingQueue()
r5 = r19
r7 = r21
long r5 = r7.toNanos(r5)
if (r18 == 0) goto L_0x002f
long r7 = java.lang.System.nanoTime() // Catch:{ all -> 0x002c }
goto L_0x0031
L_0x002c:
r0 = move-exception
goto L_0x00bb
L_0x002f:
r7 = 0
L_0x0031:
java.util.Iterator r9 = r17.iterator() // Catch:{ all -> 0x002c }
java.lang.Object r10 = r9.next() // Catch:{ all -> 0x002c }
java.util.concurrent.Callable r10 = (java.util.concurrent.Callable) r10 // Catch:{ all -> 0x002c }
com.google.common.util.concurrent.ListenableFuture r10 = submitAndAddQueueListener(r1, r10, r4) // Catch:{ all -> 0x002c }
r3.add(r10) // Catch:{ all -> 0x002c }
int r0 = r0 + -1
r10 = 0
r12 = r10
r11 = 1
L_0x0047:
java.lang.Object r13 = r4.poll() // Catch:{ all -> 0x002c }
java.util.concurrent.Future r13 = (java.util.concurrent.Future) r13 // Catch:{ all -> 0x002c }
if (r13 != 0) goto L_0x008d
if (r0 <= 0) goto L_0x0063
int r0 = r0 + -1
java.lang.Object r14 = r9.next() // Catch:{ all -> 0x002c }
java.util.concurrent.Callable r14 = (java.util.concurrent.Callable) r14 // Catch:{ all -> 0x002c }
com.google.common.util.concurrent.ListenableFuture r14 = submitAndAddQueueListener(r1, r14, r4) // Catch:{ all -> 0x002c }
r3.add(r14) // Catch:{ all -> 0x002c }
int r11 = r11 + 1
goto L_0x008d
L_0x0063:
if (r11 != 0) goto L_0x006d
if (r12 != 0) goto L_0x006c
java.util.concurrent.ExecutionException r12 = new java.util.concurrent.ExecutionException // Catch:{ all -> 0x002c }
r12.<init>(r10) // Catch:{ all -> 0x002c }
L_0x006c:
throw r12 // Catch:{ all -> 0x002c }
L_0x006d:
if (r18 == 0) goto L_0x0087
java.util.concurrent.TimeUnit r13 = java.util.concurrent.TimeUnit.NANOSECONDS // Catch:{ all -> 0x002c }
java.lang.Object r13 = r4.poll(r5, r13) // Catch:{ all -> 0x002c }
java.util.concurrent.Future r13 = (java.util.concurrent.Future) r13 // Catch:{ all -> 0x002c }
if (r13 == 0) goto L_0x0081
long r14 = java.lang.System.nanoTime() // Catch:{ all -> 0x002c }
long r7 = r14 - r7
long r5 = r5 - r7
goto L_0x008e
L_0x0081:
java.util.concurrent.TimeoutException r0 = new java.util.concurrent.TimeoutException // Catch:{ all -> 0x002c }
r0.<init>() // Catch:{ all -> 0x002c }
throw r0 // Catch:{ all -> 0x002c }
L_0x0087:
java.lang.Object r13 = r4.take() // Catch:{ all -> 0x002c }
java.util.concurrent.Future r13 = (java.util.concurrent.Future) r13 // Catch:{ all -> 0x002c }
L_0x008d:
r14 = r7
L_0x008e:
r6 = r5
r5 = r0
if (r13 == 0) goto L_0x00b7
int r11 = r11 + -1
java.lang.Object r0 = r13.get() // Catch:{ ExecutionException -> 0x00b5, RuntimeException -> 0x00ad }
java.util.Iterator r1 = r3.iterator()
L_0x009c:
boolean r3 = r1.hasNext()
if (r3 == 0) goto L_0x00ac
java.lang.Object r3 = r1.next()
java.util.concurrent.Future r3 = (java.util.concurrent.Future) r3
r3.cancel(r2)
goto L_0x009c
L_0x00ac:
return r0
L_0x00ad:
r0 = move-exception
r8 = r0
java.util.concurrent.ExecutionException r12 = new java.util.concurrent.ExecutionException // Catch:{ all -> 0x002c }
r12.<init>(r8) // Catch:{ all -> 0x002c }
goto L_0x00b7
L_0x00b5:
r0 = move-exception
r12 = r0
L_0x00b7:
r0 = r5
r5 = r6
r7 = r14
goto L_0x0047
L_0x00bb:
java.util.Iterator r1 = r3.iterator()
L_0x00bf:
boolean r3 = r1.hasNext()
if (r3 == 0) goto L_0x00cf
java.lang.Object r3 = r1.next()
java.util.concurrent.Future r3 = (java.util.concurrent.Future) r3
r3.cancel(r2)
goto L_0x00bf
L_0x00cf:
throw r0
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.util.concurrent.MoreExecutors.invokeAnyImpl(com.google.common.util.concurrent.ListeningExecutorService, java.util.Collection, boolean, long, java.util.concurrent.TimeUnit):java.lang.Object");
}
private static <T> ListenableFuture<T> submitAndAddQueueListener(ListeningExecutorService listeningExecutorService, Callable<T> callable, final BlockingQueue<Future<T>> blockingQueue) {
final ListenableFuture<T> submit = listeningExecutorService.submit(callable);
submit.addListener(new Runnable() {
public void run() {
blockingQueue.add(submit);
}
}, directExecutor());
return submit;
}
public static ThreadFactory platformThreadFactory() {
if (!isAppEngineWithApiClasses()) {
return Executors.defaultThreadFactory();
}
try {
return (ThreadFactory) Class.forName("com.google.appengine.api.ThreadManager").getMethod("currentRequestThreadFactory", new Class[0]).invoke((Object) null, new Object[0]);
} catch (IllegalAccessException e) {
throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", e);
} catch (ClassNotFoundException e2) {
throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", e2);
} catch (NoSuchMethodException e3) {
throw new RuntimeException("Couldn't invoke ThreadManager.currentRequestThreadFactory", e3);
} catch (InvocationTargetException e4) {
throw Throwables.propagate(e4.getCause());
}
}
/* JADX WARNING: Code restructure failed: missing block: B:12:?, code lost:
return false;
*/
/* JADX WARNING: No exception handlers in catch block: Catch:{ } */
/* JADX WARNING: Removed duplicated region for block: B:11:? A[ExcHandler: ClassNotFoundException (unused java.lang.ClassNotFoundException), SYNTHETIC, Splitter:B:7:0x0011] */
/* Code decompiled incorrectly, please refer to instructions dump. */
private static boolean isAppEngineWithApiClasses() {
/*
java.lang.String r0 = "com.google.appengine.runtime.environment"
java.lang.String r0 = java.lang.System.getProperty(r0)
r1 = 0
if (r0 != 0) goto L_0x000a
return r1
L_0x000a:
java.lang.String r0 = "com.google.appengine.api.utils.SystemProperty"
java.lang.Class.forName(r0) // Catch:{ }
java.lang.String r0 = "com.google.apphosting.api.ApiProxy"
java.lang.Class r0 = java.lang.Class.forName(r0) // Catch:{ ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027 }
java.lang.String r2 = "getCurrentEnvironment"
java.lang.Class[] r3 = new java.lang.Class[r1] // Catch:{ ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027 }
java.lang.reflect.Method r0 = r0.getMethod(r2, r3) // Catch:{ ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027 }
r2 = 0
java.lang.Object[] r3 = new java.lang.Object[r1] // Catch:{ ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027 }
java.lang.Object r0 = r0.invoke(r2, r3) // Catch:{ ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027, ClassNotFoundException -> 0x0027 }
if (r0 == 0) goto L_0x0027
r1 = 1
L_0x0027:
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: com.google.common.util.concurrent.MoreExecutors.isAppEngineWithApiClasses():boolean");
}
static Thread newThread(String str, Runnable runnable) {
Preconditions.checkNotNull(str);
Preconditions.checkNotNull(runnable);
Thread newThread = platformThreadFactory().newThread(runnable);
try {
newThread.setName(str);
} catch (SecurityException unused) {
}
return newThread;
}
static Executor renamingDecorator(final Executor executor, final Supplier<String> supplier) {
Preconditions.checkNotNull(executor);
Preconditions.checkNotNull(supplier);
return new Executor() {
public void execute(Runnable runnable) {
executor.execute(Callables.threadRenaming(runnable, (Supplier<String>) supplier));
}
};
}
static ExecutorService renamingDecorator(ExecutorService executorService, final Supplier<String> supplier) {
Preconditions.checkNotNull(executorService);
Preconditions.checkNotNull(supplier);
return new WrappingExecutorService(executorService) {
/* access modifiers changed from: protected */
public <T> Callable<T> wrapTask(Callable<T> callable) {
return Callables.threadRenaming(callable, (Supplier<String>) supplier);
}
/* access modifiers changed from: protected */
public Runnable wrapTask(Runnable runnable) {
return Callables.threadRenaming(runnable, (Supplier<String>) supplier);
}
};
}
static ScheduledExecutorService renamingDecorator(ScheduledExecutorService scheduledExecutorService, final Supplier<String> supplier) {
Preconditions.checkNotNull(scheduledExecutorService);
Preconditions.checkNotNull(supplier);
return new WrappingScheduledExecutorService(scheduledExecutorService) {
/* access modifiers changed from: protected */
public <T> Callable<T> wrapTask(Callable<T> callable) {
return Callables.threadRenaming(callable, (Supplier<String>) supplier);
}
/* access modifiers changed from: protected */
public Runnable wrapTask(Runnable runnable) {
return Callables.threadRenaming(runnable, (Supplier<String>) supplier);
}
};
}
public static boolean shutdownAndAwaitTermination(ExecutorService executorService, long j, TimeUnit timeUnit) {
long nanos = timeUnit.toNanos(j) / 2;
executorService.shutdown();
try {
if (!executorService.awaitTermination(nanos, TimeUnit.NANOSECONDS)) {
executorService.shutdownNow();
executorService.awaitTermination(nanos, TimeUnit.NANOSECONDS);
}
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
executorService.shutdownNow();
}
return executorService.isTerminated();
}
static Executor rejectionPropagatingExecutor(final Executor executor, final AbstractFuture<?> abstractFuture) {
Preconditions.checkNotNull(executor);
Preconditions.checkNotNull(abstractFuture);
if (executor == directExecutor()) {
return executor;
}
return new Executor() {
public void execute(Runnable runnable) {
try {
executor.execute(runnable);
} catch (RejectedExecutionException e) {
abstractFuture.setException(e);
}
}
};
}
}
Download file