APK反编译源代码展示 - 南明离火平台提供

应用版本信息

反编译源代码说明

package x2;

import java.lang.Thread;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import u2.a0;
import u2.s;

public abstract class c implements s {

    private ScheduledThreadPoolExecutor f14176a;

    class a extends ScheduledThreadPoolExecutor {
        a(int i9, ThreadFactory threadFactory) {
            super(i9, threadFactory);
        }

        @Override
        protected void afterExecute(Runnable runnable, Throwable th) {
            super.afterExecute(runnable, th);
            if (th == null && (runnable instanceof Future)) {
                Future future = (Future) runnable;
                try {
                    if (future.isDone()) {
                        future.get();
                    }
                } catch (InterruptedException unused) {
                    Thread.currentThread().interrupt();
                } catch (CancellationException unused2) {
                } catch (ExecutionException e9) {
                    th = e9.getCause();
                }
            }
            if (th != null) {
                c.this.g(th);
            }
        }
    }

    private class b implements ThreadFactory {

        class a implements Thread.UncaughtExceptionHandler {
            a() {
            }

            @Override
            public void uncaughtException(Thread thread, Throwable th) {
                c.this.g(th);
            }
        }

        private b() {
        }

        b(c cVar, a aVar) {
            this();
        }

        @Override
        public Thread newThread(Runnable runnable) {
            Thread newThread = c.this.e().newThread(runnable);
            a0 f9 = c.this.f();
            f9.a(newThread, "FirebaseDatabaseWorker");
            f9.b(newThread, true);
            f9.c(newThread, new a());
            return newThread;
        }
    }

    public c() {
        a aVar = new a(1, new b(this, null));
        this.f14176a = aVar;
        aVar.setKeepAliveTime(3L, TimeUnit.SECONDS);
    }

    public static String h(Throwable th) {
        if (th instanceof OutOfMemoryError) {
            return "Firebase Database encountered an OutOfMemoryError. You may need to reduce the amount of data you are syncing to the client (e.g. by using queries or syncing a deeper path). See https://firebase.google.com/docs/database/ios/structure-data#best_practices_for_data_structure and https://firebase.google.com/docs/database/android/retrieve-data#filtering_data";
        }
        if (th instanceof NoClassDefFoundError) {
            return "A symbol that the Firebase Database SDK depends on failed to load. This usually indicates that your project includes an incompatible version of another Firebase dependency. If updating your dependencies to the latest version does not resolve this issue, please file a report at https://github.com/firebase/firebase-android-sdk";
        }
        if (th instanceof p2.c) {
            return "";
        }
        return "Uncaught exception in Firebase Database runloop (" + com.google.firebase.database.c.g() + "). If you are not already on the latest version of the Firebase SDKs, try updating your dependencies. Should this problem persist, please file a report at https://github.com/firebase/firebase-android-sdk";
    }

    @Override
    public void a() {
        this.f14176a.setCorePoolSize(1);
    }

    @Override
    public ScheduledFuture b(Runnable runnable, long j9) {
        return this.f14176a.schedule(runnable, j9, TimeUnit.MILLISECONDS);
    }

    @Override
    public void c(Runnable runnable) {
        this.f14176a.execute(runnable);
    }

    public ScheduledExecutorService d() {
        return this.f14176a;
    }

    protected ThreadFactory e() {
        return Executors.defaultThreadFactory();
    }

    protected a0 f() {
        return a0.f12928a;
    }

    public abstract void g(Throwable th);
}