Kaspi.kz v5.85.1 - C5289byM.java 源代码

package o;

import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import o.C5289byM;
import o.approximateContravariantCapturedTypes;
import o.setStatement;

public final class C5289byM implements InterfaceC5288byL {
    private EnumC5285byI RemoteActionCompatParcelizer;
    private final ConnectivityManager setBackground;
    private isRecursion<EnumC5285byI> setError;
    private final Command setFieldValue;
    private volatile AbstractTypeConstructorLambda0 setLabel;
    private final List<InetSocketAddress> setOptions;

    public C5289byM(@org.jetbrains.annotations.NotNull android.content.Context context) {
        List<InetSocketAddress> write;
        kotlin.jvm.internal.Intrinsics.checkNotNullParameter(context, "");
        Object systemService = context.getSystemService("connectivity");
        kotlin.jvm.internal.Intrinsics.setLabel(systemService, "");
        this.setBackground = (ConnectivityManager) systemService;
        EnumC5285byI enumC5285byI = EnumC5285byI.setBackground;
        this.setError = C2056accessgetEmptycp.setOptions(enumC5285byI);
        this.RemoteActionCompatParcelizer = enumC5285byI;
        write = accessorDescriptorUtilsKtlambda1.write(new InetSocketAddress("8.8.8.8", 53), new InetSocketAddress("185.79.212.7", 53), new InetSocketAddress("194.0.21.5", 53), new InetSocketAddress("204.61.216.143", 53), new InetSocketAddress("91.228.39.8", 53));
        this.setOptions = write;
        this.setFieldValue = getHelp.setFieldValue(this);
        RemoteActionCompatParcelizer();
    }

    @Override
    public TypeAttributes<EnumC5285byI> setFieldValue() {
        return getProjectionKind.setOptions((isRecursion) this.setError);
    }

    @Override
    public EnumC5285byI setOptions() {
        return this.RemoteActionCompatParcelizer;
    }

    @Override
    public boolean setBackground() {
        return write();
    }

    @Override
    public void setError() {
        AbstractTypeConstructorLambda0 options;
        AbstractTypeConstructorLambda0 abstractTypeConstructorLambda0 = this.setLabel;
        if (abstractTypeConstructorLambda0 == null || !abstractTypeConstructorLambda0.setOptions()) {
            options = isFallThrough.setOptions(AbstractTypeChecker.setLabel(isSubtypeOfForSingleClassifierTypelambda21lambda20.setOptions()), null, null, new setError(null), 3, null);
            this.setLabel = options;
        } else {
            setStatement.setLabel.setFieldValue(this.setFieldValue, "Network connectivity job is not completed yet", null, 2, null);
        }
    }

    static final class setError extends accessorSubstitutingScopelambda0 implements kotlin.jvm.functions.Function2<AbstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super kotlin.Unit>, Object> {
        int setError;

        setError(GivenFunctionsMemberScopeLambda0<? super setError> givenFunctionsMemberScopeLambda0) {
            super(2, givenFunctionsMemberScopeLambda0);
        }

        @Override
        public final GivenFunctionsMemberScopeLambda0<kotlin.Unit> create(Object obj, GivenFunctionsMemberScopeLambda0<?> givenFunctionsMemberScopeLambda0) {
            return C5289byM.this.new setError(givenFunctionsMemberScopeLambda0);
        }

        @Override
        public final Object invoke(AbstractStubTypeCompanion abstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super kotlin.Unit> givenFunctionsMemberScopeLambda0) {
            return ((setError) create(abstractStubTypeCompanion, givenFunctionsMemberScopeLambda0)).invokeSuspend(kotlin.Unit.INSTANCE);
        }

        @Override
        public final Object invokeSuspend(Object obj) {
            Object background;
            background = flatMapClassifierNamesOrNull.setBackground();
            int i = this.setError;
            if (i == 0) {
                CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setFieldValue(obj);
                setStatement.setLabel.setFieldValue(C5289byM.this.setFieldValue, "Starting network connectivity check", null, 2, null);
                C5289byM c5289byM = C5289byM.this;
                this.setError = 1;
                obj = c5289byM.setFieldValue(this);
                if (obj == background) {
                    return background;
                }
            } else {
                if (i != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setFieldValue(obj);
            }
            if (((Boolean) obj).booleanValue()) {
                C5289byM.this.setElement();
            } else {
                C5289byM.this.read();
            }
            return kotlin.Unit.INSTANCE;
        }
    }

    static final class setOptions extends accessorSubstitutingScopelambda0 implements kotlin.jvm.functions.Function2<AbstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super Boolean>, Object> {
        Object setBackground;
        int setFieldValue;
        Object setLabel;
        Object setOptions;
        private Object write;

        setOptions(GivenFunctionsMemberScopeLambda0<? super setOptions> givenFunctionsMemberScopeLambda0) {
            super(2, givenFunctionsMemberScopeLambda0);
        }

        @Override
        public final GivenFunctionsMemberScopeLambda0<kotlin.Unit> create(Object obj, GivenFunctionsMemberScopeLambda0<?> givenFunctionsMemberScopeLambda0) {
            setOptions setoptions = C5289byM.this.new setOptions(givenFunctionsMemberScopeLambda0);
            setoptions.write = obj;
            return setoptions;
        }

        @Override
        public final Object invoke(AbstractStubTypeCompanion abstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super Boolean> givenFunctionsMemberScopeLambda0) {
            return ((setOptions) create(abstractStubTypeCompanion, givenFunctionsMemberScopeLambda0)).invokeSuspend(kotlin.Unit.INSTANCE);
        }

        @Override
        public final Object invokeSuspend(Object obj) {
            Object background;
            Socket socket;
            C5289byM c5289byM;
            Object error;
            AbstractStubTypeCompanion abstractStubTypeCompanion;
            Iterator it;
            C5289byM c5289byM2;
            Object error2;
            Throwable fieldValue;
            boolean z;
            getTypeParameterForArgumentInBaseIfItEqualToTarget error3;
            background = flatMapClassifierNamesOrNull.setBackground();
            ?? r1 = this.setFieldValue;
            boolean z2 = false;
            try {
                if (r1 == 0) {
                    CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setFieldValue(obj);
                    abstractStubTypeCompanion = (AbstractStubTypeCompanion) this.write;
                    List list = C5289byM.this.setOptions;
                    c5289byM = C5289byM.this;
                    if (!(list instanceof Collection) || !list.isEmpty()) {
                        it = list.iterator();
                        if (it.hasNext()) {
                        }
                    }
                    return MemberScopeDefaultImpls.setFieldValue(z2);
                }
                if (r1 != 1) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                r1 = (Socket) this.setOptions;
                Iterator it2 = (Iterator) this.setBackground;
                c5289byM2 = (C5289byM) this.setLabel;
                AbstractStubTypeCompanion abstractStubTypeCompanion2 = (AbstractStubTypeCompanion) this.write;
                try {
                    CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setFieldValue(obj);
                    r1 = r1;
                } catch (Exception e) {
                    e = e;
                    c5289byM2.setFieldValue.setError("Error occurred during connectivity check", e);
                    try {
                        approximateContravariantCapturedTypes.setBackground setbackground = approximateContravariantCapturedTypes.setError;
                        if (!r1.isClosed()) {
                            r1.close();
                        }
                        error2 = approximateContravariantCapturedTypes.setError(kotlin.Unit.INSTANCE);
                    } catch (Throwable th) {
                        approximateContravariantCapturedTypes.setBackground setbackground2 = approximateContravariantCapturedTypes.setError;
                        error2 = approximateContravariantCapturedTypes.setError(CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setLabel(th));
                    }
                    fieldValue = approximateContravariantCapturedTypes.setFieldValue(error2);
                    if (fieldValue != null) {
                        setStatement.setLabel.setOptions(c5289byM2.setFieldValue, fieldValue, null, 2, null);
                    }
                    z = false;
                    abstractStubTypeCompanion = abstractStubTypeCompanion2;
                    if (!z) {
                    }
                }
                boolean booleanValue = ((Boolean) obj).booleanValue();
                approximateContravariantCapturedTypes.setBackground setbackground3 = approximateContravariantCapturedTypes.setError;
                if (!r1.isClosed()) {
                    r1.close();
                }
                Object error4 = approximateContravariantCapturedTypes.setError(kotlin.Unit.INSTANCE);
                Throwable fieldValue2 = approximateContravariantCapturedTypes.setFieldValue(error4);
                if (fieldValue2 != null) {
                    setStatement.setLabel.setOptions(c5289byM2.setFieldValue, fieldValue2, null, 2, null);
                }
                z = booleanValue;
                abstractStubTypeCompanion = abstractStubTypeCompanion2;
                if (!z) {
                    z2 = true;
                    return MemberScopeDefaultImpls.setFieldValue(z2);
                }
                it = it2;
                c5289byM = c5289byM2;
                if (it.hasNext()) {
                    InetSocketAddress inetSocketAddress = (InetSocketAddress) it.next();
                    socket = new Socket();
                    try {
                    } catch (Exception e2) {
                        abstractStubTypeCompanion2 = abstractStubTypeCompanion;
                        e = e2;
                        c5289byM2 = c5289byM;
                        it2 = it;
                        r1 = socket;
                        c5289byM2.setFieldValue.setError("Error occurred during connectivity check", e);
                        approximateContravariantCapturedTypes.setBackground setbackground4 = approximateContravariantCapturedTypes.setError;
                        if (!r1.isClosed()) {
                        }
                        error2 = approximateContravariantCapturedTypes.setError(kotlin.Unit.INSTANCE);
                        fieldValue = approximateContravariantCapturedTypes.setFieldValue(error2);
                        if (fieldValue != null) {
                        }
                        z = false;
                        abstractStubTypeCompanion = abstractStubTypeCompanion2;
                        if (!z) {
                        }
                    } catch (Throwable th2) {
                        th = th2;
                        try {
                            approximateContravariantCapturedTypes.setBackground setbackground5 = approximateContravariantCapturedTypes.setError;
                            if (!socket.isClosed()) {
                                socket.close();
                            }
                            error = approximateContravariantCapturedTypes.setError(kotlin.Unit.INSTANCE);
                        } catch (Throwable th3) {
                            approximateContravariantCapturedTypes.setBackground setbackground6 = approximateContravariantCapturedTypes.setError;
                            error = approximateContravariantCapturedTypes.setError(CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setLabel(th3));
                        }
                        Throwable fieldValue3 = approximateContravariantCapturedTypes.setFieldValue(error);
                        if (fieldValue3 == null) {
                            throw th;
                        }
                        setStatement.setLabel.setOptions(c5289byM.setFieldValue, fieldValue3, null, 2, null);
                        throw th;
                    }
                    setStatement.setLabel.setFieldValue(c5289byM.setFieldValue, "Checking network connectivity via host -> " + inetSocketAddress, null, 2, null);
                    error3 = isFallThrough.setError(abstractStubTypeCompanion, null, null, new setLabel(socket, inetSocketAddress, c5289byM, null), 3, null);
                    this.write = abstractStubTypeCompanion;
                    this.setLabel = c5289byM;
                    this.setBackground = it;
                    this.setOptions = socket;
                    this.setFieldValue = 1;
                    Object fieldValue4 = error3.setFieldValue(this);
                    if (fieldValue4 == background) {
                        return background;
                    }
                    abstractStubTypeCompanion2 = abstractStubTypeCompanion;
                    obj = fieldValue4;
                    c5289byM2 = c5289byM;
                    it2 = it;
                    r1 = socket;
                    boolean booleanValue2 = ((Boolean) obj).booleanValue();
                    approximateContravariantCapturedTypes.setBackground setbackground32 = approximateContravariantCapturedTypes.setError;
                    if (!r1.isClosed()) {
                    }
                    Object error42 = approximateContravariantCapturedTypes.setError(kotlin.Unit.INSTANCE);
                    Throwable fieldValue22 = approximateContravariantCapturedTypes.setFieldValue(error42);
                    if (fieldValue22 != null) {
                    }
                    z = booleanValue2;
                    abstractStubTypeCompanion = abstractStubTypeCompanion2;
                    if (!z) {
                    }
                }
                return MemberScopeDefaultImpls.setFieldValue(z2);
            } catch (Throwable th4) {
                th = th4;
                socket = r1;
                c5289byM = c5289byM2;
            }
        }

        static final class setLabel extends accessorSubstitutingScopelambda0 implements kotlin.jvm.functions.Function2<AbstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super Boolean>, Object> {
            final C5289byM setBackground;
            final InetSocketAddress setError;
            final Socket setFieldValue;
            int setOptions;

            setLabel(Socket socket, InetSocketAddress inetSocketAddress, C5289byM c5289byM, GivenFunctionsMemberScopeLambda0<? super setLabel> givenFunctionsMemberScopeLambda0) {
                super(2, givenFunctionsMemberScopeLambda0);
                this.setFieldValue = socket;
                this.setError = inetSocketAddress;
                this.setBackground = c5289byM;
            }

            @Override
            public final GivenFunctionsMemberScopeLambda0<kotlin.Unit> create(Object obj, GivenFunctionsMemberScopeLambda0<?> givenFunctionsMemberScopeLambda0) {
                return new setLabel(this.setFieldValue, this.setError, this.setBackground, givenFunctionsMemberScopeLambda0);
            }

            @Override
            public final Object invoke(AbstractStubTypeCompanion abstractStubTypeCompanion, GivenFunctionsMemberScopeLambda0<? super Boolean> givenFunctionsMemberScopeLambda0) {
                return ((setLabel) create(abstractStubTypeCompanion, givenFunctionsMemberScopeLambda0)).invokeSuspend(kotlin.Unit.INSTANCE);
            }

            @Override
            public final Object invokeSuspend(Object obj) {
                boolean z;
                flatMapClassifierNamesOrNull.setBackground();
                if (this.setOptions != 0) {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                CapturedTypeConstructorKtwrapWithCapturingSubstitution2.setFieldValue(obj);
                try {
                    this.setFieldValue.connect(this.setError, 5000);
                    Command command = this.setBackground.setFieldValue;
                    final InetSocketAddress inetSocketAddress = this.setError;
                    command.setError(new kotlin.jvm.functions.Function0() {
                        @Override
                        public final Object invoke() {
                            String background;
                            background = C5289byM.setOptions.setLabel.setBackground(inetSocketAddress);
                            return background;
                        }
                    });
                    z = true;
                } catch (Exception e) {
                    this.setBackground.setFieldValue.setError("Error occurred during connectivity check", e);
                    z = false;
                }
                return MemberScopeDefaultImpls.setFieldValue(z);
            }

            public static final String setBackground(InetSocketAddress inetSocketAddress) {
                return "Connection with " + inetSocketAddress + " successfully established";
            }
        }
    }

    public final Object setFieldValue(GivenFunctionsMemberScopeLambda0<? super Boolean> givenFunctionsMemberScopeLambda0) {
        return AbstractTypeChecker.setLabel(new setOptions(null), givenFunctionsMemberScopeLambda0);
    }

    private final void RemoteActionCompatParcelizer() {
        if (write()) {
            setElement();
        } else {
            read();
        }
        setLabel setlabel = new setLabel();
        NetworkRequest.Builder addTransportType = new NetworkRequest.Builder().addCapability(12).addTransportType(1).addTransportType(0);
        addTransportType.addCapability(16);
        addTransportType.build();
        this.setBackground.registerDefaultNetworkCallback(setlabel);
        this.setFieldValue.setError(new kotlin.jvm.functions.Function0() {
            @Override
            public final Object invoke() {
                String IconCompatParcelizer;
                IconCompatParcelizer = C5289byM.IconCompatParcelizer();
                return IconCompatParcelizer;
            }
        });
    }

    public static final class setLabel extends ConnectivityManager.NetworkCallback {
        setLabel() {
        }

        @Override
        public void onAvailable(Network network) {
            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(network, "");
            super.onAvailable(network);
            C5289byM.this.setElement();
        }

        @Override
        public void onLost(Network network) {
            kotlin.jvm.internal.Intrinsics.checkNotNullParameter(network, "");
            super.onLost(network);
            C5289byM.this.read();
        }
    }

    public static final String IconCompatParcelizer() {
        return "NetworkMonitoring is started";
    }

    private final boolean write() {
        NetworkCapabilities networkCapabilities;
        try {
            Network activeNetwork = this.setBackground.getActiveNetwork();
            if (activeNetwork == null || (networkCapabilities = this.setBackground.getNetworkCapabilities(activeNetwork)) == null || !networkCapabilities.hasCapability(12)) {
                return false;
            }
            if (!networkCapabilities.hasCapability(16) && !networkCapabilities.hasTransport(1)) {
                if (!networkCapabilities.hasTransport(0)) {
                    return false;
                }
            }
            return true;
        } catch (Exception e) {
            setStatement.setLabel.setOptions(this.setFieldValue, e, null, 2, null);
            NetworkInfo activeNetworkInfo = this.setBackground.getActiveNetworkInfo();
            return activeNetworkInfo != null && activeNetworkInfo.isConnected();
        }
    }

    public final void setElement() {
        setStatement.setLabel.setFieldValue(this.setFieldValue, "Network is available", null, 2, null);
        this.RemoteActionCompatParcelizer = EnumC5285byI.setBackground;
        this.setError.setBackground(setOptions());
    }

    public final void read() {
        setStatement.setLabel.setFieldValue(this.setFieldValue, "Network is unavailable", null, 2, null);
        this.RemoteActionCompatParcelizer = EnumC5285byI.setOptions;
        this.setError.setBackground(setOptions());
    }
}