public final boolean Check_Vpn1() {
        try {
            //NetworkInterface.getNetworkInterfaces() 获取当前设备的所有网络接口。返回值是一个 Enumeration<NetworkInterface> 对象，表示网络接口的枚举集合。
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            if (networkInterfaces == null) {
                return false;
            }
            Iterator it = Collections.list(networkInterfaces).iterator();
            while (it.hasNext()) {
                NetworkInterface networkInterface = (NetworkInterface) it.next();
                if (networkInterface.isUp() && !networkInterface.getInterfaceAddresses().isEmpty()) {
                    Log.d("zj595", "isVpn NetworkInterface Name: " + networkInterface.getName());
                    if (Intrinsics.areEqual(networkInterface.getName(), "tun0") || Intrinsics.areEqual(networkInterface.getName(), "ppp0") || Intrinsics.areEqual(networkInterface.getName(), "p2p0") || Intrinsics.areEqual(networkInterface.getName(), "ccmni0")) {
                        return true;
                    }
                }
            }
            return false;
        } catch (Throwable th) {
            th.printStackTrace();
            return false;
        }
    }

 public final boolean Check_Vpn2() {
        boolean z;
        String networkCapabilities;
        try {
            //调用 getApplicationContext() 获取应用的上下文，然后通过 getSystemService("connectivity") 获取系统的连接服务（ConnectivityManager）
            Object systemService = getApplicationContext().getSystemService("connectivity");
            Intrinsics.checkNotNull(systemService, "null cannot be cast to non-null type android.net.ConnectivityManager");
            //ConnectivityManager 是 Android 用于管理网络连接的服务类。
            ConnectivityManager connectivityManager = (ConnectivityManager) systemService;
            //获取当前活跃网络的 NetworkCapabilities，它表示网络的能力和状态，比如是否支持 VPN、Wi-Fi 等。
            NetworkCapabilities networkCapabilities2 = connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
            Log.i("zj595", "networkCapabilities -> " + networkCapabilities2);
            boolean z2 = networkCapabilities2 != null && networkCapabilities2.hasTransport(4);
            // 检查网络能力是否包含 "WIFI|VPN" 
            //检查当前网络是否支持 VPN（编号为 4 表示 VPN）。如果 networkCapabilities2 不为 null 且支持 VPN（hasTransport(4) 返回 true），则 z2 为 true，否则为 false。
            if (networkCapabilities2 != null && (networkCapabilities = networkCapabilities2.toString()) != null) {
                if (StringsKt.contains$default((CharSequence) networkCapabilities, (CharSequence) "WIFI|VPN", false, 2, (Object) null)) {
                    z = true;
                    return !z || z2;
                }
            }
            z = false;
            if (z) {
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

public void NetTest(){
    //1.构建客户端对象OkhttpClient
    OkHttpClient httpClient = new OkHttpClient();
    //2.构建请求Request
    String url = "https://www.baidu.com";
    Request request = new Request.Builder()
        .url(url)
        .get()
        .build();
    //3.生成call对象
    // 每一个Call只能执行一次。
    // 如果想要取消正在执行的请求，可以使用call.cancel()，通常在离开页面时都要取消执行的请求的。
    Call call = httpClient.newCall(request);
    //4. Call发起请求
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Response response = call.execute();
                Log.i("qfzwy","okHttpGet run: response:"+ response.body().string());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }).start();
}

OkHttpClient httpClient = new OkHttpClient();

MediaType contentType = MediaType.parse("text/x-markdown; charset=utf-8");
String content = "hello!";
RequestBody body = RequestBody.create(contentType, content);

Request getRequest = new Request.Builder()
    .url("https://api.github.com/markdown/raw")
    .post(body)
    .build();

Call call = httpClient.newCall(getRequest);

call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        Log.i(TAG, "okHttpPost enqueue: \n onResponse:"+ response.toString() +"\n body:" +response.body().string());
    }
});

// RequestBody:jsonBody，json字符串
String json = "jsonString";
RequestBody jsonBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);

//RequestBody:fileBody, 上传文件
File file = new File(Environment.getExternalStorageDirectory(), "1.png");
RequestBody fileBody = RequestBody.create(MediaType.parse("image/png"), file);

RequestBody formBody = new FormBody.Builder()
        .add("username", "hfy")
        .add("password", "qaz")
        .build();

//RequestBody:fileBody,上传文件
File file = drawableToFile(this, R.mipmap.bigpic, new File("00.jpg"));
RequestBody fileBody = RequestBody.create(MediaType.parse("image/jpg"), file);


//RequestBody:multipartBody, 多类型 （用户名、密码、头像）
MultipartBody multipartBody = new MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("username", "hufeiyang")
    .addFormDataPart("phone", "123456")
    .addFormDataPart("touxiang", "00.png", fileBody)
    .build();


Request getRequest = new Request.Builder()
    .url("http://yun918.cn/study/public/file_upload.php")
    .post(multipartBody)
    .build();

public void NetTest(){
    OkHttpClient httpClient = new OkHttpClient();
    //1.使用CertificatePinner.Builder构建一个证书固定器,添加服务器证书的指纹
    CertificatePinner certificatePinner = new CertificatePinner.Builder()
        .add("www.52pojie.cn","sha256/WnsD5UGdP5/a65xO1rpH8ru2EjyxkmPEaiNtKixhJLU=")
        .build();
    //2.构建新的客户端对象Client
    OkHttpClient client = httpClient.newBuilder()
        .certificatePinner(certificatePinner)
        .build();

    //3.构建请求Request
    String url = "https://www.52pojie.cn/?q=SSLPinningCode";
    Request request = new Request.Builder()
        .url(url)
        .get()
        .build();
    //4.生成call对象
    // 每一个Call只能执行一次。
    // 如果想要取消正在执行的请求，可以使用call.cancel()，通常在离开页面时都要取消执行的请求的。
    Call call = client.newCall(request);
    //4. Call发起请求
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Response response = call.execute();
                Log.i("qfzwy", "指纹检测通过");
            } catch (IOException e) {
                Log.d("qfzwy", "指纹检测不通过");
                throw new RuntimeException(e);
            }
        }
    }).start();
}

private void check_SSL_PINNING_CA(){
    X509TrustManager trustManager = new X509TrustManager() {

        // 检查客户端证书（在双向认证时使用）
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String s) throws CertificateException {

        }

        @Override
        public void checkServerTrusted(X509Certificate[] chain, String s) throws CertificateException {
            //获取服务器返回的证书
            X509Certificate cf = chain[0];
            //提取服务器证书的公钥。将公钥转换为 Base64 编码，以便与本地证书进行比对。
            String serverPubkey = Base64.encodeToString(cf.getPublicKey().getEncoded(), Base64.DEFAULT);
            Log.e("qfzwy", "服务器返回的证书：" + serverPubkey);
            //获取本地证书
            InputStream clientInput = getResources().openRawResource(R.raw.wuai);
            //创建 X.509 证书工厂
            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            //将本地证书转换为 X509Certificate 对象
            X509Certificate clientCertificate = (X509Certificate) certificateFactory.generateCertificate(clientInput);
            //提取本地证书的公钥。将公钥转换为 Base64 编码，以便与服务器证书进行比对。
            String clientPubkey = Base64.encodeToString(clientCertificate.getPublicKey().getEncoded(), Base64.DEFAULT);
            Log.e("qfzwy", "客户端的证书：" + clientPubkey);
            //检查服务器证书的有效期，若证书过期则抛出 CertificateException。
            cf.checkValidity();

            boolean expected = clientPubkey.equals(serverPubkey);
            if (expected) {
                Log.e("qfzwy", "证书校验通过");
            } else {
                Log.e("qfzwy", "证书校验不通过");
                throw new CertificateException("证书校验不通过");
            }

        }
        //返回信任的 CA 证书列表（这里返回空数组，表示不信任任何 CA，只信任指定的服务器证书）。
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    };

    SSLSocketFactory factory = null;
    try{
        //获取 SSLContext 实例（用于管理 SSL 连接）。
        SSLContext sslContext = SSLContext.getInstance("SSL");
        /*
            初始化 SSLContext 实例。
            第一个参数：密钥管理器（null 表示默认）。
            第二个参数：信任管理器数组（此处传入 trustManager，即我们的自定义证书校验逻辑）。
            第三个参数：随机数生成器（SecureRandom()）。
            */
        sslContext.init(null, new TrustManager[]{trustManager}, new SecureRandom());
        //获取 SSLSocketFactory，用于 HTTPS 请求。
        factory = sslContext.getSocketFactory();
    } catch (Exception e) {
        e.printStackTrace();
    }

    final SSLSocketFactory finalFactory = factory;
    new Thread(new Runnable() {
        @Override
        public void run() {
            OkHttpClient client = new OkHttpClient.Builder()
                .sslSocketFactory(finalFactory, trustManager)  //指定 SSLSocketFactory 和 trustManager，确保使用自定义证书校验。
                .build();
            Request request = new Request.Builder()
                .url("https://www.52pojie.cn/forum.php")
                .get()
                .build();
            Call call = client.newCall(request);
            try {
                Response response = call.execute();
                Log.e("请求发送成功", "状态码：" + response.code());
            } catch (IOException e) {
                Log.e("请求发送失败", "网络异常" + e);
            }
        }
    }).start();
}

public OkHttpClient createClient() throws Exception {
    InputStream clientCert = getResources().openRawResource(R.raw.client);  // 使用 PKCS#12 证书
    // 加载根证书（用于信任管理）
    InputStream trustStore = getResources().openRawResource(R.raw.ca);      // 使用根 CA 证书

    // 加载客户端证书到 KeyStore
    KeyStore keyStore = KeyStore.getInstance("PKCS12");
    keyStore.load(clientCert, "123456".toCharArray());

    // 初始化 KeyManagerFactory，提供客户端证书
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
    keyManagerFactory.init(keyStore, "123456".toCharArray());

    // 加载信任证书到 KeyStore
    KeyStore trustKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
    trustKeyStore.load(null, null);  // 创建一个空的 KeyStore

    // 加载 CA 根证书
    CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
    Certificate caCert = certificateFactory.generateCertificate(trustStore);
    trustKeyStore.setCertificateEntry("ca", caCert);

    // 初始化 TrustManagerFactory，提供根证书
    TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
    trustManagerFactory.init(trustKeyStore);  // 传入包含 CA 根证书的 KeyStore

    // 获取 TrustManager
    TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

    // 创建 SSLContext
    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(keyManagerFactory.getKeyManagers(), trustManagers, null);

    // 创建 OkHttpClient 使用自定义的 SSLContext
    OkHttpClient client = new OkHttpClient.Builder()
        .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustManagers[0])
        .build();

    return client;

}

new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            makeRequest();  // 执行网络请求
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}).start();

OkHttpClient client = new OkHttpClient.Builder()
    .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustManagers[0])
    .hostnameVerifier((hostname, session) -> true)  // 忽略主机名验证
    .build();

public interface HostnameVerifier {
    boolean verify(String var1, SSLSession var2);
}

public class CustomHostnameVerifier implements HostnameVerifier {
    @Override
    public boolean verify(String hostname, SSLSession session) {
        // 允许的合法主机名列表
        String allowedHostname = "example.com";  // 这里改成你的目标域名

        if (hostname.equalsIgnoreCase(allowedHostname)) {
            System.out.println("[*] Hostname verified: " + hostname);
            return true;  // 只有匹配的 hostname 通过验证
        }

        System.out.println("[!] Hostname verification failed: " + hostname);
        return false;  // 其他域名全部拒绝
    }
}

package com.example.test;

import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import androidx.activity.EdgeToEdge;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;

import java.io.IOException;
import java.io.InputStream;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import okhttp3.Call;
import okhttp3.CertificatePinner;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                check_SSL_PINNING_CA();
                NetTest();
            }
        });
    }

    public void NetTest(){
        OkHttpClient httpClient = new OkHttpClient();
        //1.使用CertificatePinner.Builder构建一个证书固定器,添加服务器证书的指纹
        CertificatePinner certificatePinner = new CertificatePinner.Builder()
                .add("www.52pojie.cn","sha256/WnsD5UGdP5/a65xO1rpH8ru2EjyxkmPEaiNtKixhJLU=")
                .build();
        //2.构建新的客户端对象Client
        OkHttpClient client = httpClient.newBuilder()
                .certificatePinner(certificatePinner)
                .build();

        //3.构建请求Request
        String url = "https://www.52pojie.cn/?q=SSLPinningCode";
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        //4.生成call对象
        // 每一个Call只能执行一次。
        // 如果想要取消正在执行的请求，可以使用call.cancel()，通常在离开页面时都要取消执行的请求的。
        Call call = client.newCall(request);
        //4. Call发起请求
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Response response = call.execute();
                    Log.i("qfzwy", "指纹检测通过");
                } catch (IOException e) {
                    Log.d("qfzwy", "指纹检测不通过");
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
    private void check_SSL_PINNING_CA(){
        X509TrustManager trustManager = new X509TrustManager() {

            // 检查客户端证书（在双向认证时使用）
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String s) throws CertificateException {

            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String s) throws CertificateException {
                //获取服务器返回的证书
                X509Certificate cf = chain[0];
                //提取服务器证书的公钥。将公钥转换为 Base64 编码，以便与本地证书进行比对。
                String serverPubkey = Base64.encodeToString(cf.getPublicKey().getEncoded(), Base64.DEFAULT);
                Log.e("qfzwy", "服务器返回的证书：" + serverPubkey);
                //获取本地证书
                InputStream clientInput = getResources().openRawResource(R.raw.wuai);
                //创建 X.509 证书工厂
                CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                //将本地证书转换为 X509Certificate 对象
                X509Certificate clientCertificate = (X509Certificate) certificateFactory.generateCertificate(clientInput);
                //提取本地证书的公钥。将公钥转换为 Base64 编码，以便与服务器证书进行比对。
                String clientPubkey = Base64.encodeToString(clientCertificate.getPublicKey().getEncoded(), Base64.DEFAULT);
                Log.e("qfzwy", "客户端的证书：" + clientPubkey);
                //检查服务器证书的有效期，若证书过期则抛出 CertificateException。
                cf.checkValidity();

                boolean expected = clientPubkey.equals(serverPubkey);
                if (expected) {
                    Log.e("qfzwy", "证书校验通过");
                } else {
                    Log.e("qfzwy", "证书校验不通过");
                    throw new CertificateException("证书校验不通过");
                }

            }
            //返回信任的 CA 证书列表（这里返回空数组，表示不信任任何 CA，只信任指定的服务器证书）。
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };

        SSLSocketFactory factory = null;
        try{
            //获取 SSLContext 实例（用于管理 SSL 连接）。
            SSLContext sslContext = SSLContext.getInstance("SSL");
        /*
            初始化 SSLContext 实例。
            第一个参数：密钥管理器（null 表示默认）。
            第二个参数：信任管理器数组（此处传入 trustManager，即我们的自定义证书校验逻辑）。
            第三个参数：随机数生成器（SecureRandom()）。
            */
            sslContext.init(null, new TrustManager[]{trustManager}, new SecureRandom());
            //获取 SSLSocketFactory，用于 HTTPS 请求。
            factory = sslContext.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }

        final SSLSocketFactory finalFactory = factory;
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkHttpClient client = new OkHttpClient.Builder()
                        .sslSocketFactory(finalFactory, trustManager)  //指定 SSLSocketFactory 和 trustManager，确保使用自定义证书校验。
                        .build();
                Request request = new Request.Builder()
                        .url("https://www.52pojie.cn/forum.php")
                        .get()
                        .build();
                Call call = client.newCall(request);
                try {
                    Response response = call.execute();
                    Log.e("请求发送成功", "状态码：" + response.code());
                } catch (IOException e) {
                    Log.e("请求发送失败", "网络异常" + e);
                }
            }
        }).start();
    }
}

public void GetByHttpURL(final String url) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                StringBuilder resultData= new StringBuilder();
                URL connUrl = new URL(url);
                HttpURLConnection urlConn = (HttpURLConnection) connUrl.openConnection();
                InputStreamReader in = new InputStreamReader(urlConn.getInputStream());
                BufferedReader buffer = new BufferedReader(in);
                String inputLine = null;
                while((inputLine=buffer.readLine())!=null){
                    resultData.append(inputLine).append("\n");
                }
                in.close();
                urlConn.disconnect();
                Log.d("qfzwy", "GetByHttpUrl:" + resultData);
            } catch (Exception e) {
                Log.d("qfzwy","GetByHttpUrl error:"+e.getMessage());
                e.printStackTrace();
            }
        }
    }).start();
}

public void GetByOkHttp(String url) {
    try {
        OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .get()
                .build();
        Call call = okHttpClient.newCall(request);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Response response = call.execute();
                    Log.d("qfzwy", "GetByOkHttp:" + response.body().string());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void GetByTcp() throws IOException, InterruptedException {
    Socket socket = new Socket("192.168.0.100",5000);
    socket.setSoTimeout(10000);
    //发送数据给服务端
    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("hello server".getBytes("UTF-8"));
    Thread.sleep(2000);
    socket.shutdownOutput();
    //读取数据
    BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String line = br.readLine();
    //打印读取到的数据
    Log.d("qfzwy", "GetByTcp:" + line);
    br.close();
    socket.close();
}

package com.example.test;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import androidx.appcompat.app.AppCompatActivity;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.Socket;
import java.net.URL;


import okhttp3.Call;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            GetByTcp();
                            Thread.sleep(3000);
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        });
    }

    //HttpURL
    public void GetByHttpURL(final String url) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    StringBuilder resultData= new StringBuilder();
                    URL connUrl = new URL(url);
                    HttpURLConnection urlConn = (HttpURLConnection) connUrl.openConnection();
                    InputStreamReader in = new InputStreamReader(urlConn.getInputStream());
                    BufferedReader buffer = new BufferedReader(in);
                    String inputLine = null;
                    while((inputLine=buffer.readLine())!=null){
                        resultData.append(inputLine).append("\n");
                    }
                    in.close();
                    urlConn.disconnect();
                    Log.d("qfzwy", "GetByHttpUrl:" + resultData);
                } catch (Exception e) {
                    Log.d("qfzwy","GetByHttpUrl error:"+e.getMessage());
                    e.printStackTrace();
                }
            }
        }).start();
    }

    //okhttp
    public void GetByOkHttp(String url) {
        try {
            OkHttpClient okHttpClient = new OkHttpClient();
            Request request = new Request.Builder()
                    .url(url)
                    .get()
                    .build();
            Call call = okHttpClient.newCall(request);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Response response = call.execute();
                        Log.d("qfzwy", "GetByOkHttp:" + response.body().string());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //tcp
    public void GetByTcp() throws IOException, InterruptedException {
        Socket socket = new Socket("192.168.0.110",5000);
        socket.setSoTimeout(10000);
        //发送数据给服务端
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello server".getBytes("UTF-8"));
        Thread.sleep(2000);
        socket.shutdownOutput();
        //读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = br.readLine();
        //打印读取到的数据
        Log.d("qfzwy", "GetByTcp:" + line);
        br.close();
        socket.close();
    }


}

 * @param fd the FileDescriptor
 * @param b the data to be written
 * @param off the start offset in the data
 * @param len the number of bytes that are written
private native void socketWrite0(FileDescriptor fd, byte[] b, int off,
                                 int len) throws IOException;

 * @param fd the FileDescriptor
 * @param b the buffer into which the data is read
 * @param off the start offset of the data
 * @param len the maximum number of bytes read
 * @param timeout the read timeout in ms
private native int socketRead0(FileDescriptor fd,
                               byte b[], int off, int len,
                               int timeout)

GetByHttpURL("https://missking.cc/");
GetByOkHttp("https://10.ip138.com");