Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/ironsource/environment/ContextProvider.java

@@ -0,0 +1,87 @@
+package com.ironsource.environment;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import com.ironsource.j;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class ContextProvider {
+
+    @SuppressLint({"StaticFieldLeak"})
+    private static volatile ContextProvider d;
+    private Activity a;
+    private Context b;
+    private ConcurrentHashMap<String, a> c = new ConcurrentHashMap<>();
+
+    public interface a {
+        void onPause(Activity activity);
+
+        void onResume(Activity activity);
+    }
+
+    private ContextProvider() {
+    }
+
+    public static ContextProvider getInstance() {
+        if (d == null) {
+            synchronized (ContextProvider.class) {
+                try {
+                    if (d == null) {
+                        d = new ContextProvider();
+                    }
+                } finally {
+                }
+            }
+        }
+        return d;
+    }
+
+    public Context getApplicationContext() {
+        Activity activity;
+        Context context = this.b;
+        return (context != null || (activity = this.a) == null) ? context : activity.getApplicationContext();
+    }
+
+    public Activity getCurrentActiveActivity() {
+        Activity activity = this.a;
+        return activity != null ? activity : j.a.b();
+    }
+
+    public void onPause(Activity activity) {
+        if (activity != null) {
+            Iterator<a> it = this.c.values().iterator();
+            while (it.hasNext()) {
+                it.next().onPause(activity);
+            }
+        }
+    }
+
+    public void onResume(Activity activity) {
+        if (activity != null) {
+            this.a = activity;
+            Iterator<a> it = this.c.values().iterator();
+            while (it.hasNext()) {
+                it.next().onResume(this.a);
+            }
+        }
+    }
+
+    public void registerLifeCycleListener(a aVar) {
+        this.c.put(aVar.getClass().getSimpleName(), aVar);
+    }
+
+    public void updateActivity(Activity activity) {
+        if (activity != null) {
+            this.a = activity;
+        }
+    }
+
+    public void updateAppContext(Context context) {
+        if (context != null) {
+            this.b = context;
+        }
+    }
+}

decompiled/sources/com/ironsource/environment/CrashProvider.java

@@ -0,0 +1,73 @@
+package com.ironsource.environment;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.net.Uri;
+import com.ironsource.s9;
+
+/* loaded from: classes4.dex */
+public class CrashProvider extends ContentProvider {
+    Context a;
+    s9 b;
+    String c;
+    Uri e;
+    String h;
+    String i;
+    UriMatcher d = new UriMatcher(-1);
+    final int f = 1;
+    final int g = 2;
+    final String j = "REPORTS";
+
+    @Override // android.content.ContentProvider
+    public int delete(Uri uri, String str, String[] strArr) {
+        return 0;
+    }
+
+    @Override // android.content.ContentProvider
+    public String getType(Uri uri) {
+        int match = this.d.match(uri);
+        if (match == 1) {
+            return this.h;
+        }
+        if (match == 2) {
+            return this.i;
+        }
+        throw new IllegalArgumentException("Invalid URI: " + uri);
+    }
+
+    @Override // android.content.ContentProvider
+    public Uri insert(Uri uri, ContentValues contentValues) {
+        return null;
+    }
+
+    @Override // android.content.ContentProvider
+    public boolean onCreate() {
+        this.a = getContext();
+        this.b = new s9(this.a);
+        this.c = this.a.getPackageName();
+        this.e = Uri.parse("content://" + this.c + "/REPORTS");
+        this.h = "vnd.android.cursor.dir/CrashReporter.Reports";
+        this.i = "vnd.android.cursor.item/CrashReporter/Reports";
+        return true;
+    }
+
+    @Override // android.content.ContentProvider
+    public Cursor query(Uri uri, String[] strArr, String str, String[] strArr2, String str2) {
+        int match = this.d.match(uri);
+        if (match == 1) {
+            return s9.c();
+        }
+        if (match == 2) {
+            return s9.a(Integer.parseInt(uri.getLastPathSegment()));
+        }
+        throw new IllegalArgumentException("Invalid URI: " + uri);
+    }
+
+    @Override // android.content.ContentProvider
+    public int update(Uri uri, ContentValues contentValues, String str, String[] strArr) {
+        return 0;
+    }
+}

decompiled/sources/com/ironsource/environment/IronSourceSharedPreferencesUtilities.java

@@ -0,0 +1,63 @@
+package com.ironsource.environment;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+/* loaded from: classes4.dex */
+public class IronSourceSharedPreferencesUtilities {
+    private static final String a = "_preferences";
+
+    public static int a(Context context, String str, String str2, int i) {
+        return context == null ? i : context.getSharedPreferences(str, 0).getInt(str2, i);
+    }
+
+    public static void a(Context context, String str, String str2, boolean z) {
+        if (context == null) {
+            return;
+        }
+        SharedPreferences.Editor edit = context.getSharedPreferences(str, 0).edit();
+        edit.putBoolean(str2, z);
+        edit.apply();
+    }
+
+    public static boolean getBooleanFromSharedPrefs(Context context, String str, String str2, boolean z) {
+        return context == null ? z : context.getSharedPreferences(str, 0).getBoolean(str2, z);
+    }
+
+    public static String getDefaultSharedPrefName(Context context, String str) {
+        if (context == null) {
+            return str;
+        }
+        return context.getPackageName() + a;
+    }
+
+    public static int getIntFromDefaultSharedPrefs(Context context, String str, int i) {
+        return a(context, getDefaultSharedPrefName(context, ""), str, i);
+    }
+
+    public static String getStringFromDefaultSharedPrefs(Context context, String str, String str2) {
+        return getStringFromSharedPrefs(context, getDefaultSharedPrefName(context, ""), str, str2);
+    }
+
+    public static String getStringFromSharedPrefs(Context context, String str, String str2, String str3) {
+        return context == null ? str3 : context.getSharedPreferences(str, 0).getString(str2, str3);
+    }
+
+    public static void saveIntToSharedPrefs(Context context, String str, String str2, int i) {
+        if (context == null) {
+            return;
+        }
+        SharedPreferences.Editor edit = context.getSharedPreferences(str, 0).edit();
+        edit.putInt(str2, i);
+        edit.apply();
+    }
+
+    public static void saveStringToSharedPrefs(Context context, String str, String str2, String str3) {
+        if (context == null) {
+            return;
+        }
+        SharedPreferences.Editor edit = context.getSharedPreferences(str, 0).edit();
+        edit.putString(str2, str3);
+        edit.apply();
+    }
+}

decompiled/sources/com/ironsource/environment/NetworkStateReceiver.java

@@ -0,0 +1,92 @@
+package com.ironsource.environment;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import com.ironsource.environment.thread.IronSourceThreadManager;
+import com.ironsource.vm;
+
+/* loaded from: classes4.dex */
+public class NetworkStateReceiver extends BroadcastReceiver {
+    private ConnectivityManager a;
+    private vm b;
+    private boolean c = false;
+
+    public class a implements Runnable {
+        public a() {
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (NetworkStateReceiver.this.b != null) {
+                NetworkStateReceiver.this.b.a(NetworkStateReceiver.this.c);
+            }
+        }
+    }
+
+    public NetworkStateReceiver(Context context, vm vmVar) {
+        this.b = vmVar;
+        if (context != null) {
+            this.a = (ConnectivityManager) context.getSystemService("connectivity");
+        }
+        a();
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:6:0x002a  */
+    /* JADX WARN: Removed duplicated region for block: B:9:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private boolean a() {
+        /*
+            r5 = this;
+            boolean r0 = r5.c
+            android.net.ConnectivityManager r1 = r5.a
+            r2 = 1
+            r3 = 0
+            if (r1 == 0) goto L23
+            android.net.NetworkInfo r1 = r1.getActiveNetworkInfo()     // Catch: java.lang.Exception -> L16
+            if (r1 == 0) goto L18
+            boolean r1 = r1.isConnectedOrConnecting()     // Catch: java.lang.Exception -> L16
+            if (r1 == 0) goto L18
+            r1 = r2
+            goto L19
+        L16:
+            r1 = move-exception
+            goto L1c
+        L18:
+            r1 = r3
+        L19:
+            r5.c = r1     // Catch: java.lang.Exception -> L16
+            goto L25
+        L1c:
+            com.ironsource.i9 r4 = com.ironsource.i9.d()
+            r4.a(r1)
+        L23:
+            r5.c = r3
+        L25:
+            boolean r1 = r5.c
+            if (r0 == r1) goto L2a
+            goto L2b
+        L2a:
+            r2 = r3
+        L2b:
+            return r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.ironsource.environment.NetworkStateReceiver.a():boolean");
+    }
+
+    private void b() {
+        IronSourceThreadManager.INSTANCE.postMediationBackgroundTask(new a());
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null || intent.getExtras() == null || !a()) {
+            return;
+        }
+        b();
+    }
+}

decompiled/sources/com/ironsource/environment/StringUtils.java

@@ -0,0 +1,36 @@
+package com.ironsource.environment;
+
+import com.ironsource.i9;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.Locale;
+
+/* loaded from: classes4.dex */
+public class StringUtils {
+    public static String decodeURI(String str) {
+        try {
+            return URLDecoder.decode(str, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            i9.d().a(e);
+            return "";
+        }
+    }
+
+    public static String encodeURI(String str) {
+        try {
+            return URLEncoder.encode(str, "UTF-8").replace("+", "%20");
+        } catch (UnsupportedEncodingException e) {
+            i9.d().a(e);
+            return "";
+        }
+    }
+
+    public static String toLowerCase(String str) {
+        return str == null ? "" : str.toLowerCase(Locale.ENGLISH);
+    }
+
+    public static String toUpperCase(String str) {
+        return str == null ? "" : str.toUpperCase(Locale.ENGLISH);
+    }
+}

decompiled/sources/com/ironsource/environment/thread/IronSourceThreadManager.java

@@ -0,0 +1,270 @@
+package com.ironsource.environment.thread;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import com.ironsource.i9;
+import com.ironsource.ti;
+import com.ironsource.zp;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import kotlin.Lazy;
+import kotlin.LazyKt__LazyJVMKt;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@SourceDebugExtension({"SMAP\nIronSourceThreadManager.kt\nKotlin\n*S Kotlin\n*F\n+ 1 IronSourceThreadManager.kt\ncom/ironsource/environment/thread/IronSourceThreadManager\n+ 2 _Collections.kt\nkotlin/collections/CollectionsKt___CollectionsKt\n*L\n1#1,147:1\n1855#2,2:148\n1855#2,2:150\n1855#2,2:152\n*S KotlinDebug\n*F\n+ 1 IronSourceThreadManager.kt\ncom/ironsource/environment/thread/IronSourceThreadManager\n*L\n70#1:148,2\n77#1:150,2\n84#1:152,2\n*E\n"})
+/* loaded from: classes4.dex */
+public final class IronSourceThreadManager {
+    private static boolean a;
+    private static final Handler c;
+    private static final ti d;
+    private static final ti e;
+    private static final ti f;
+    private static final Lazy g;
+    private static final Lazy h;
+    public static final IronSourceThreadManager INSTANCE = new IronSourceThreadManager();
+    private static final Handler b = new Handler(Looper.getMainLooper());
+
+    public static final class a extends Lambda implements Function0 {
+        public static final a a = new a();
+
+        public a() {
+            super(0);
+        }
+
+        @Override // kotlin.jvm.functions.Function0
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public final zp invoke() {
+            return new zp(0, null, null, 7, null);
+        }
+    }
+
+    public static final class b extends Lambda implements Function0 {
+        public static final b a = new b();
+
+        public b() {
+            super(0);
+        }
+
+        @Override // kotlin.jvm.functions.Function0
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public final ti invoke() {
+            ti tiVar = new ti("managersThread");
+            tiVar.start();
+            tiVar.a();
+            return tiVar;
+        }
+    }
+
+    static {
+        Lazy lazy;
+        Lazy lazy2;
+        HandlerThread handlerThread = new HandlerThread("IronSourceInitiatorHandler");
+        handlerThread.start();
+        c = new Handler(handlerThread.getLooper());
+        ti tiVar = new ti("mediationBackground");
+        tiVar.start();
+        tiVar.a();
+        d = tiVar;
+        ti tiVar2 = new ti("adapterBackground");
+        tiVar2.start();
+        tiVar2.a();
+        e = tiVar2;
+        ti tiVar3 = new ti("publisher-callbacks");
+        tiVar3.start();
+        tiVar3.a();
+        f = tiVar3;
+        lazy = LazyKt__LazyJVMKt.lazy(a.a);
+        g = lazy;
+        lazy2 = LazyKt__LazyJVMKt.lazy(b.a);
+        h = lazy2;
+    }
+
+    private IronSourceThreadManager() {
+    }
+
+    private final zp a() {
+        return (zp) g.getValue();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void a(Runnable it, final CountDownLatch latch) {
+        Intrinsics.checkNotNullParameter(it, "$it");
+        Intrinsics.checkNotNullParameter(latch, "$latch");
+        it.run();
+        new Runnable() { // from class: com.ironsource.environment.thread.IronSourceThreadManager$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                IronSourceThreadManager.a(latch);
+            }
+        }.run();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void a(CountDownLatch latch) {
+        Intrinsics.checkNotNullParameter(latch, "$latch");
+        latch.countDown();
+    }
+
+    private final boolean a(Runnable runnable) {
+        return a && a().getQueue().contains(runnable);
+    }
+
+    public static /* synthetic */ void postAdapterBackgroundTask$default(IronSourceThreadManager ironSourceThreadManager, Runnable runnable, long j, int i, Object obj) {
+        if ((i & 2) != 0) {
+            j = 0;
+        }
+        ironSourceThreadManager.postAdapterBackgroundTask(runnable, j);
+    }
+
+    public static /* synthetic */ void postMediationBackgroundTask$default(IronSourceThreadManager ironSourceThreadManager, Runnable runnable, long j, int i, Object obj) {
+        if ((i & 2) != 0) {
+            j = 0;
+        }
+        ironSourceThreadManager.postMediationBackgroundTask(runnable, j);
+    }
+
+    public static /* synthetic */ void postOnUiThreadTask$default(IronSourceThreadManager ironSourceThreadManager, Runnable runnable, long j, int i, Object obj) {
+        if ((i & 2) != 0) {
+            j = 0;
+        }
+        ironSourceThreadManager.postOnUiThreadTask(runnable, j);
+    }
+
+    public static /* synthetic */ void postPublisherCallback$default(IronSourceThreadManager ironSourceThreadManager, Runnable runnable, long j, int i, Object obj) {
+        if ((i & 2) != 0) {
+            j = 0;
+        }
+        ironSourceThreadManager.postPublisherCallback(runnable, j);
+    }
+
+    public final void executeTasks(boolean z, boolean z2, List<? extends Runnable> tasks) {
+        Intrinsics.checkNotNullParameter(tasks, "tasks");
+        if (!z) {
+            Iterator<T> it = tasks.iterator();
+            while (it.hasNext()) {
+                ((Runnable) it.next()).run();
+            }
+            return;
+        }
+        if (!z2) {
+            Iterator<T> it2 = tasks.iterator();
+            while (it2.hasNext()) {
+                postMediationBackgroundTask$default(INSTANCE, (Runnable) it2.next(), 0L, 2, null);
+            }
+            return;
+        }
+        final CountDownLatch countDownLatch = new CountDownLatch(tasks.size());
+        for (final Runnable runnable : tasks) {
+            postMediationBackgroundTask$default(INSTANCE, new Runnable() { // from class: com.ironsource.environment.thread.IronSourceThreadManager$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    IronSourceThreadManager.a(runnable, countDownLatch);
+                }
+            }, 0L, 2, null);
+        }
+        try {
+            countDownLatch.await();
+        } catch (InterruptedException e2) {
+            i9.d().a(e2);
+        }
+    }
+
+    public final Handler getInitHandler() {
+        return c;
+    }
+
+    public final ti getSharedManagersThread() {
+        return (ti) h.getValue();
+    }
+
+    public final ThreadPoolExecutor getThreadPoolExecutor() {
+        return new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(), Long.MAX_VALUE, TimeUnit.NANOSECONDS, new LinkedBlockingQueue());
+    }
+
+    public final boolean getUseSharedExecutorService() {
+        return a;
+    }
+
+    public final void postAdapterBackgroundTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        postAdapterBackgroundTask$default(this, action, 0L, 2, null);
+    }
+
+    public final void postAdapterBackgroundTask(Runnable action, long j) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        if (a) {
+            a().schedule(action, j, TimeUnit.MILLISECONDS);
+        } else {
+            e.a(action, j);
+        }
+    }
+
+    public final void postMediationBackgroundTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        postMediationBackgroundTask$default(this, action, 0L, 2, null);
+    }
+
+    public final void postMediationBackgroundTask(Runnable action, long j) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        if (a) {
+            a().schedule(action, j, TimeUnit.MILLISECONDS);
+        } else {
+            d.a(action, j);
+        }
+    }
+
+    public final void postOnUiThreadTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        postOnUiThreadTask$default(this, action, 0L, 2, null);
+    }
+
+    public final void postOnUiThreadTask(Runnable action, long j) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        b.postDelayed(action, j);
+    }
+
+    public final void postPublisherCallback(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        postPublisherCallback$default(this, action, 0L, 2, null);
+    }
+
+    public final void postPublisherCallback(Runnable action, long j) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        f.a(action, j);
+    }
+
+    public final void removeAdapterBackgroundTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        if (a(action)) {
+            a().remove(action);
+        } else {
+            e.b(action);
+        }
+    }
+
+    public final void removeMediationBackgroundTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        if (a(action)) {
+            a().remove(action);
+        } else {
+            d.b(action);
+        }
+    }
+
+    public final void removeUiThreadTask(Runnable action) {
+        Intrinsics.checkNotNullParameter(action, "action");
+        b.removeCallbacks(action);
+    }
+
+    public final void setUseSharedExecutorService(boolean z) {
+        a = z;
+    }
+}

decompiled/sources/com/ironsource/environment/workerthread/WorkerManager.java

@@ -0,0 +1,79 @@
+package com.ironsource.environment.workerthread;
+
+import com.ironsource.environment.workerthread.WorkerResult;
+import com.ironsource.i9;
+import com.ironsource.mediationsdk.logger.IronLog;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public class WorkerManager<T> {
+    List<Callable<T>> a = new ArrayList();
+    private final ExecutorService b;
+
+    public interface WorkEndedListener<T> {
+        void onWorkCompleted(List<WorkerResult<T>> list, long j);
+
+        void onWorkFailed(String str);
+    }
+
+    public WorkerManager(ExecutorService executorService) {
+        this.b = executorService;
+    }
+
+    public void addCallable(Callable<T> callable) {
+        this.a.add(callable);
+    }
+
+    public void startWork(WorkEndedListener<T> workEndedListener, long j, TimeUnit timeUnit) {
+        WorkerResult.Canceled canceled;
+        if (this.b.isShutdown()) {
+            workEndedListener.onWorkFailed("can not start work, executor has been shut down");
+            return;
+        }
+        if (this.a.isEmpty()) {
+            workEndedListener.onWorkFailed("can not start work, callable list is empty");
+            return;
+        }
+        long currentTimeMillis = System.currentTimeMillis();
+        ArrayList arrayList = new ArrayList();
+        try {
+            List<Future<T>> invokeAll = this.b.invokeAll(this.a, j, timeUnit);
+            for (int i = 0; i < invokeAll.size(); i++) {
+                Future<T> future = invokeAll.get(i);
+                if (!future.isDone() || future.isCancelled()) {
+                    canceled = new WorkerResult.Canceled(this.a.get(i));
+                } else {
+                    try {
+                        arrayList.add(new WorkerResult.Completed(future.get()));
+                    } catch (InterruptedException e) {
+                        e = e;
+                        i9.d().a(e);
+                        arrayList.add(new WorkerResult.Failed(this.a.get(i), e));
+                    } catch (CancellationException e2) {
+                        i9.d().a(e2);
+                        canceled = new WorkerResult.Canceled(this.a.get(i));
+                    } catch (ExecutionException e3) {
+                        e = e3;
+                        i9.d().a(e);
+                        arrayList.add(new WorkerResult.Failed(this.a.get(i), e));
+                    }
+                }
+                arrayList.add(canceled);
+            }
+            workEndedListener.onWorkCompleted(arrayList, System.currentTimeMillis() - currentTimeMillis);
+            this.b.shutdownNow();
+        } catch (Exception e4) {
+            i9.d().a(e4);
+            IronLog.INTERNAL.error(e4.toString());
+            workEndedListener.onWorkFailed("failed to invoke callables, error= " + e4.getMessage());
+            this.b.shutdownNow();
+        }
+    }
+}

decompiled/sources/com/ironsource/environment/workerthread/WorkerResult.java

@@ -0,0 +1,39 @@
+package com.ironsource.environment.workerthread;
+
+import java.util.concurrent.Callable;
+
+/* loaded from: classes4.dex */
+public abstract class WorkerResult<T> {
+
+    public static final class Canceled<T> extends WorkerResult<T> {
+        public Callable<T> callable;
+
+        public Canceled(Callable<T> callable) {
+            super();
+            this.callable = callable;
+        }
+    }
+
+    public static final class Completed<T> extends WorkerResult<T> {
+        public T data;
+
+        public Completed(T t) {
+            super();
+            this.data = t;
+        }
+    }
+
+    public static final class Failed<T> extends WorkerResult<T> {
+        public Callable<T> callable;
+        public Exception exception;
+
+        public Failed(Callable<T> callable, Exception exc) {
+            super();
+            this.callable = callable;
+            this.exception = exc;
+        }
+    }
+
+    private WorkerResult() {
+    }
+}