星辰VPN v1.2.3 - b.java 源代码

package im.crisp.client.internal.j;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkRequest;
import android.os.Build;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import im.crisp.client.Crisp;
import im.crisp.client.internal.e.d;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Response;

public final class b {
    private static final String a = "https://crisp.chat/";
    private static String b;
    private static String c;
    private static final ArrayList<InterfaceC0033b> d = new ArrayList<>();
    private static ConnectivityManager.NetworkCallback e;

    public class a extends ConnectivityManager.NetworkCallback {
        @Override
        public void onAvailable(@NonNull Network network) {
            b.d();
        }

        @Override
        public void onLost(@NonNull Network network) {
            b.e();
        }
    }

    public interface InterfaceC0033b {
        void a();

        void b();
    }

    public static Response a(Interceptor.Chain chain) throws IOException {
        if (g()) {
            return chain.proceed(chain.request());
        }
        throw new IOException("No network connectivity");
    }

    public static boolean a(@Nullable Context context) {
        if (context == null) {
            context = Crisp.a();
        }
        boolean z = false;
        if (context == null) {
            return false;
        }
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        } catch (SecurityException unused) {
        }
        return Build.VERSION.SDK_INT < 29 ? z : z;
    }

    public static synchronized boolean a(InterfaceC0033b interfaceC0033b) {
        boolean z;
        synchronized (b.class) {
            ArrayList<InterfaceC0033b> arrayList = d;
            if (arrayList.contains(interfaceC0033b)) {
                z = false;
            } else {
                arrayList.add(interfaceC0033b);
                z = true;
            }
        }
        return z;
    }

    public static void b(@NonNull Context context) {
        if (e == null) {
            e = new a();
            ((ConnectivityManager) context.getSystemService("connectivity")).registerNetworkCallback(new NetworkRequest.Builder().build(), e);
        }
    }

    public static synchronized boolean b(InterfaceC0033b interfaceC0033b) {
        boolean z;
        synchronized (b.class) {
            ArrayList<InterfaceC0033b> arrayList = d;
            if (arrayList.contains(interfaceC0033b)) {
                arrayList.remove(interfaceC0033b);
                z = true;
            } else {
                z = false;
            }
        }
        return z;
    }

    public static OkHttpClient c() {
        c cVar = new Interceptor() {
            @Override
            public final Response intercept(Interceptor.Chain chain) {
                Response a2;
                a2 = b.a(chain);
                return a2;
            }
        };
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.addNetworkInterceptor(cVar);
        return builder.build();
    }

    public static void c(@NonNull Context context) {
        if (e != null) {
            ((ConnectivityManager) context.getSystemService("connectivity")).unregisterNetworkCallback(e);
            e = null;
        }
    }

    public static synchronized void d() {
        synchronized (b.class) {
            Iterator<InterfaceC0033b> it = d.iterator();
            while (it.hasNext()) {
                it.next().a();
            }
        }
    }

    public static synchronized void e() {
        synchronized (b.class) {
            Iterator<InterfaceC0033b> it = d.iterator();
            while (it.hasNext()) {
                it.next().b();
            }
        }
    }

    public static String f() throws d {
        String b2 = Crisp.b();
        if (c == null || !b2.equals(b)) {
            try {
                URL url = new URL(a + b2);
                String[] split = new URI(url.getProtocol(), url.getHost(), url.getPath(), null).toURL().getPath().split("/");
                c = split[split.length + (-1)];
                b = b2;
            } catch (MalformedURLException | URISyntaxException e2) {
                throw new d(d.d, e2);
            }
        }
        return c;
    }

    public static boolean g() {
        return a((Context) null);
    }
}