Bye

app/src/main/java/com/github/catvod/utils/AES.java

@@ -0,0 +1,114 @@
+package com.github.catvod.utils;
+
+import android.util.Base64;
+
+import com.github.catvod.crawler.SpiderDebug;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.security.spec.AlgorithmParameterSpec;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.DESKeySpec;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class AES {
+
+    public static String CBC(String src, String KEY, String IV) {
+        try {
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
+            SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), "AES");
+            AlgorithmParameterSpec paramSpec = new IvParameterSpec(IV.getBytes());
+            cipher.init(Cipher.DECRYPT_MODE, keySpec, paramSpec);
+            return new String(cipher.doFinal(Base64.decode(src.getBytes(), 0)));
+        } catch (Exception exception) {
+            SpiderDebug.log(exception);
+        }
+        return null;
+    }
+
+
+    public static Cipher GetCipher(int opmode, String key) {
+        try {
+            DESKeySpec dks = new DESKeySpec(key.getBytes());
+            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
+            Key secretkey = keyFactory.generateSecret(dks);
+            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS7Padding");
+            cipher.init(opmode, secretkey);
+            return cipher;
+        } catch (Exception exception) {
+            SpiderDebug.log(exception);
+            return null;
+        }
+    }
+
+
+
+    public static String decode(String data, String key) throws Exception {
+        if (data == null || data.isEmpty()){
+            return null;
+        }
+        try {
+            byte[] b = hex2byte(data);
+            Cipher cipher = GetCipher(Cipher.DECRYPT_MODE, key);
+            if (cipher != null){
+                return new String(cipher.doFinal(b), "UTF-8");
+            } else {
+                return null;
+            }
+        } catch (Exception exception) {
+            SpiderDebug.log(exception);
+            return data;
+        }
+    }
+
+    public static byte[] hex2byte(String hex) throws IllegalArgumentException {
+        if (hex.length() % 2 != 0){
+            throw new IllegalArgumentException("invalid hex string");
+        }
+        char[] arr = hex.toCharArray();
+        byte[] b = new byte[hex.length() / 2];
+        for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
+            String swap ="" + arr[i++] + arr[i];
+            int byteint = Integer.parseInt(swap, 16) & 0xFF;
+            b[j] = new Integer(byteint).byteValue();
+        }
+        return b;
+    }
+
+    public static String encrypt(String data, String key) {
+        try {
+            byte[] data2 = data.getBytes("UTF-8");
+            SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "AES");
+            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
+            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
+            byte[] result = cipher.doFinal(data2);
+            return bytesToHexStr(result);
+        } catch (Exception exception) {
+            SpiderDebug.log(exception);
+        }
+        return null;
+    }
+
+    /**
+     * byte数组转16进制字符串
+     *
+     * @param  bytes byte数组
+     * @return hex字符串
+     */
+    public static String bytesToHexStr(byte[] bytes) {
+        StringBuilder hexStr = new StringBuilder();
+        for (byte b : bytes) {
+            String hex = Integer.toHexString(b & 0xFF);
+            if (hex.length() == 1) {
+                hex = '0' + hex;
+            }
+            hexStr.append(hex);
+        }
+        return hexStr.toString();
+    }
+
+}

app/src/main/java/com/github/catvod/utils/CBC.java

@@ -0,0 +1,21 @@
+package com.github.catvod.utils;
+
+import com.github.catvod.crawler.SpiderDebug;
+import javax.crypto.Cipher;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class CBC {
+    public static byte[] CBC(byte[] data, byte[] key, byte[] iv) {
+        try {
+            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
+            SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
+            cipher.init(2, secretKeySpec, ivParameterSpec);
+            return cipher.doFinal(data);
+        } catch (Exception e) {
+            SpiderDebug.log(e);
+            return null;
+        }
+    }
+}

app/src/main/java/com/github/catvod/utils/Misc.java

@@ -0,0 +1,155 @@
+package com.github.catvod.utils;
+
+import android.net.Uri;
+
+import com.github.catvod.crawler.SpiderDebug;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.regex.Pattern;
+
+public class Misc {
+    public static boolean isVip(String url) {
+        // 适配2.0.6的调用应用内解析列表的支持, 需要配合直连分析一起使用，参考cjt影视和极品直连
+        try {
+            boolean isVip = false;
+            String host = Uri.parse(url).getHost();
+            String[] vipWebsites = new String[]{"iqiyi.com", "v.qq.com", "youku.com", "le.com", "tudou.com", "mgtv.com", "sohu.com", "acfun.cn", "bilibili.com", "baofeng.com", "pptv.com"};
+            for (int b = 0; b < vipWebsites.length; b++) {
+                if (host.contains(vipWebsites[b])) {
+                    if ("iqiyi.com".equals(vipWebsites[b])) {
+                        //爱奇艺需要特殊处理
+                        if (url.contains("iqiyi.com/a_") || url.contains("iqiyi.com/w_") || url.contains("iqiyi.com/v_")) {
+                            isVip = true;
+                            break;
+                        }
+                    } else {
+                        isVip = true;
+                        break;
+                    }
+                }
+            }
+            return isVip;
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
+    private static final Pattern snifferMatch = Pattern.compile("http((?!http).){26,}?\\.(m3u8|mp4)\\?.*|http((?!http).){26,}\\.(m3u8|mp4)|http((?!http).){26,}?/m3u8\\?pt=m3u8.*|http((?!http).)*?default\\.ixigua\\.com/.*|http((?!http).)*?cdn-tos[^\\?]*|http((?!http).)*?/obj/tos[^\\?]*|http.*?/player/m3u8play\\.php\\?url=.*|http.*?/player/.*?[pP]lay\\.php\\?url=.*|http.*?/playlist/m3u8/\\?vid=.*|http.*?\\.php\\?type=m3u8&.*|http.*?/download.aspx\\?.*|http.*?/api/up_api.php\\?.*|https.*?\\.66yk\\.cn.*|http((?!http).)*?netease\\.com/file/.*");
+
+    public static boolean isVideoFormat(String url) {
+        if (snifferMatch.matcher(url).find()) {
+            if (url.contains("cdn-tos") && url.contains(".js")) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public static String fixUrl(String base, String src) {
+        try {
+            if (src.startsWith("//")) {
+                Uri parse = Uri.parse(base);
+                src = parse.getScheme() + ":" + src;
+            } else if (!src.contains("://")) {
+                Uri parse = Uri.parse(base);
+                src = parse.getScheme() + "://" + parse.getHost() + src;
+            }
+        } catch (Exception e) {
+            SpiderDebug.log(e);
+        }
+        return src;
+    }
+
+    public static boolean isBlackVodUrl(String input, String url) {
+        if (url.contains("973973.xyz") || url.contains(".fit:"))
+            return true;
+        return false;
+    }
+
+    public static final String UaWinChrome = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.54 Safari/537.36";
+
+    public static JSONObject fixJsonVodHeader(JSONObject headers, String input, String url) throws JSONException {
+        if (headers == null)
+            headers = new JSONObject();
+        if (input.contains("www.mgtv.com")) {
+            headers.put("Referer", " ");
+            headers.put("User-Agent", " Mozilla/5.0");
+        } else if (url.contains("titan.mgtv")) {
+            headers.put("Referer", " ");
+            headers.put("User-Agent", " Mozilla/5.0");
+        } else if (input.contains("bilibili")) {
+            headers.put("Referer", " https://www.bilibili.com/");
+            headers.put("User-Agent", " " + Misc.UaWinChrome);
+        }
+        return headers;
+    }
+
+    public static JSONObject jsonParse(String input, String json) throws JSONException {
+        JSONObject jsonPlayData = new JSONObject(json);
+        String url;
+        if (jsonPlayData.has("data")) {
+            url = jsonPlayData.getJSONObject("data").getString("url");
+        } else {
+            url = jsonPlayData.getString("url");
+        }
+        if (url.startsWith("//")) {
+            url = "https:" + url;
+        }
+        if (!url.startsWith("http")) {
+            return null;
+        }
+        if (url.equals(input)) {
+            if (isVip(url) || !isVideoFormat(url)) {
+                return null;
+            }
+        }
+        if (Misc.isBlackVodUrl(input, url)) {
+            return null;
+        }
+        JSONObject headers = new JSONObject();
+        String ua = jsonPlayData.optString("user-agent", "");
+        if (ua.trim().length() > 0) {
+            headers.put("User-Agent", " " + ua);
+        }
+        String referer = jsonPlayData.optString("referer", "");
+        if (referer.trim().length() > 0) {
+            headers.put("Referer", " " + referer);
+        }
+
+        headers = Misc.fixJsonVodHeader(headers, input, url);
+        JSONObject taskResult = new JSONObject();
+        taskResult.put("header", headers);
+        taskResult.put("url", url);
+        return taskResult;
+    }
+
+
+    public static Charset CharsetUTF8 = Charset.forName("UTF-8");
+    public static Charset CharsetIOS8859 = Charset.forName("iso-8859-1");
+
+    public static String MD5(String src, Charset charset) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            byte[] bytes = md.digest(src.getBytes(charset));
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < bytes.length; i++) {
+                int v = bytes[i] & 0xFF;
+                String hv = Integer.toHexString(v);
+                if (hv.length() < 2) {
+                    sb.append(0);
+                }
+                sb.append(hv);
+            }
+            return sb.toString().toLowerCase();
+        } catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+}

app/src/main/java/com/github/catvod/utils/SSLSocketFactoryCompat.java

@@ -0,0 +1,167 @@
+package com.github.catvod.utils;
+
+import android.os.Build;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.GeneralSecurityException;
+import java.security.cert.CertificateException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+public class SSLSocketFactoryCompat extends SSLSocketFactory {
+    private SSLSocketFactory defaultFactory;
+    // Android 5.0+ (API level21) provides reasonable default settings
+    // but it still allows SSLv3
+    // https://developer.android.com/about/versions/android-5.0-changes.html#ssl
+    static String protocols[] = null, cipherSuites[] = null;
+
+    static {
+        try {
+            SSLSocket socket = (SSLSocket) SSLSocketFactory.getDefault().createSocket();
+            if (socket != null) {
+                /* set reasonable protocol versions */
+                // - enable all supported protocols (enables TLSv1.1 and TLSv1.2 on Android <5.0)
+                // - remove all SSL versions (especially SSLv3) because they're insecure now
+                List<String> protocols = new LinkedList<>();
+                for (String protocol : socket.getSupportedProtocols())
+                    if (!protocol.toUpperCase().contains("SSL"))
+                        protocols.add(protocol);
+                SSLSocketFactoryCompat.protocols = protocols.toArray(new String[protocols.size()]);
+                /* set up reasonable cipher suites */
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+                    // choose known secure cipher suites
+                    List<String> allowedCiphers = Arrays.asList(
+                            // TLS 1.2
+                            "TLS_RSA_WITH_AES_256_GCM_SHA384",
+                            "TLS_RSA_WITH_AES_128_GCM_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+                            "TLS_ECHDE_RSA_WITH_AES_128_GCM_SHA256",
+                            // maximum interoperability
+                            "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_RSA_WITH_AES_128_CBC_SHA",
+                            // additionally
+                            "TLS_RSA_WITH_AES_256_CBC_SHA",
+                            "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+                            "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
+                    List<String> availableCiphers = Arrays.asList(socket.getSupportedCipherSuites());
+                    // take all allowed ciphers that are available and put them into preferredCiphers
+                    HashSet<String> preferredCiphers = new HashSet<>(allowedCiphers);
+                    preferredCiphers.retainAll(availableCiphers);
+                    /* For maximum security, preferredCiphers should *replace* enabled ciphers (thus disabling
+                     * ciphers which are enabled by default, but have become unsecure), but I guess for
+                     * the security level of DAVdroid and maximum compatibility, disabling of insecure
+                     * ciphers should be a server-side task */
+                    // add preferred ciphers to enabled ciphers
+                    HashSet<String> enabledCiphers = preferredCiphers;
+                    enabledCiphers.addAll(new HashSet<>(Arrays.asList(socket.getEnabledCipherSuites())));
+                    SSLSocketFactoryCompat.cipherSuites = enabledCiphers.toArray(new String[enabledCiphers.size()]);
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public SSLSocketFactoryCompat(X509TrustManager tm) {
+        try {
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(null, (tm != null) ? new X509TrustManager[]{tm} : null, null);
+            defaultFactory = sslContext.getSocketFactory();
+        } catch (GeneralSecurityException e) {
+            throw new AssertionError(); // The system has no TLS. Just give up.
+        }
+    }
+
+    private void upgradeTLS(SSLSocket ssl) {
+        // Android 5.0+ (API level21) provides reasonable default settings
+        // but it still allows SSLv3
+        // https://developer.android.com/about/versions/android-5.0-changes.html#ssl
+        if (protocols != null) {
+            ssl.setEnabledProtocols(protocols);
+        }
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP && cipherSuites != null) {
+            ssl.setEnabledCipherSuites(cipherSuites);
+        }
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return cipherSuites;
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return cipherSuites;
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        Socket ssl = defaultFactory.createSocket(s, host, port, autoClose);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
+        Socket ssl = defaultFactory.createSocket(host, port);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
+        Socket ssl = defaultFactory.createSocket(host, port, localHost, localPort);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        Socket ssl = defaultFactory.createSocket(host, port);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
+        Socket ssl = defaultFactory.createSocket(address, port, localAddress, localPort);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    //定义一个信任所有证书的TrustManager
+    public static final X509TrustManager trustAllCert = new X509TrustManager() {
+        @Override
+        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+        }
+
+        @Override
+        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+        }
+
+        @Override
+        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+            return new java.security.cert.X509Certificate[]{};
+        }
+    };
+}

app/src/main/java/com/github/catvod/utils/SpiderOKClient.java

@@ -0,0 +1,36 @@
+package com.github.catvod.utils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.OkHttpClient;
+
+public class SpiderOKClient {
+    private static OkHttpClient noRedirectClient = null;
+
+    public static OkHttpClient noRedirectClient() {
+        if (noRedirectClient == null) {
+            OkHttpClient.Builder builder = new OkHttpClient.Builder()
+                    .readTimeout(15, TimeUnit.SECONDS)
+                    .writeTimeout(15, TimeUnit.SECONDS)
+                    .connectTimeout(15, TimeUnit.SECONDS)
+                    .followRedirects(false)
+                    .followSslRedirects(false)
+                    .retryOnConnectionFailure(true)
+                    .sslSocketFactory(new SSLSocketFactoryCompat(SSLSocketFactoryCompat.trustAllCert), SSLSocketFactoryCompat.trustAllCert);
+            noRedirectClient = builder.build();
+        }
+        return noRedirectClient;
+    }
+
+    public static String getRedirectLocation(Map<String, List<String>> headers) {
+        if (headers == null)
+            return null;
+        if (headers.containsKey("location"))
+            return headers.get("location").get(0);
+        if (headers.containsKey("Location"))
+            return headers.get("Location").get(0);
+        return null;
+    }
+}

app/src/main/java/com/github/catvod/utils/gZip.java

@@ -0,0 +1,22 @@
+package com.github.catvod.utils;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.zip.GZIPInputStream;
+
+
+public class gZip {
+    public static String KS(byte[] bArr) throws IOException {
+        GZIPInputStream gZIPInputStream = new GZIPInputStream(new ByteArrayInputStream(bArr));
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        byte[] bArr2 = new byte[1024];
+        while (true) {
+            int read = gZIPInputStream.read(bArr2);
+            if (read == -1) {
+                return byteArrayOutputStream.toString("UTF-8");
+            }
+            byteArrayOutputStream.write(bArr2, 0, read);
+        }
+    }
+}

app/src/main/java/com/github/catvod/utils/okhttp/OKCallBack.java

@@ -0,0 +1,60 @@
+package com.github.catvod.utils.okhttp;
+
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.Response;
+
+
+public abstract class OKCallBack<T> {
+
+    private T result = null;
+
+    public T getResult() {
+        return result;
+    }
+
+    protected void setResult(T val) {
+        result = val;
+    }
+
+    protected void onError(final Call call, final Exception e) {
+        onFailure(call, e);
+    }
+
+    protected void onSuccess(Call call, Response response) {
+        T obj = onParseResponse(call, response);
+        setResult(obj);
+        onResponse(obj);
+    }
+
+    protected abstract T onParseResponse(Call call, Response response);
+
+    protected abstract void onFailure(Call call, Exception e);
+
+    protected abstract void onResponse(T response);
+
+    public static abstract class OKCallBackDefault extends OKCallBack<Response> {
+        @Override
+        public Response onParseResponse(Call call, Response response) {
+            return response;
+        }
+    }
+
+    public static abstract class OKCallBackString extends OKCallBack<String> {
+        @Override
+        public void onError(Call call, Exception e) {
+            setResult("");
+            super.onError(call, e);
+        }
+
+        @Override
+        public String onParseResponse(Call call, Response response) {
+            try {
+                return response.body().string();
+            } catch (IOException e) {
+                return "";
+            }
+        }
+    }
+}

app/src/main/java/com/github/catvod/utils/okhttp/OKRequest.java

@@ -0,0 +1,132 @@
+package com.github.catvod.utils.okhttp;
+
+import android.text.TextUtils;
+
+import java.io.IOException;
+import java.util.Map;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.FormBody;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+class OKRequest {
+    private final String mMethodType;
+    private String mUrl;
+    private Object mTag = null;
+    private final Map<String, String> mParamsMap;
+    private final String mJsonStr;
+    private final Map<String, String> mHeaderMap;
+    private final OKCallBack mCallBack;
+    private okhttp3.Request mOkHttpRequest;
+    private okhttp3.Request.Builder mRequestBuilder;
+
+
+    OKRequest(String methodType, String url, Map<String, String> paramsMap, Map<String, String> headerMap, OKCallBack callBack) {
+        this(methodType, url, null, paramsMap, headerMap, callBack);
+    }
+
+    OKRequest(String methodType, String url, String jsonStr, Map<String, String> headerMap, OKCallBack callBack) {
+        this(methodType, url, jsonStr, null, headerMap, callBack);
+    }
+
+    private OKRequest(String methodType, String url, String jsonStr, Map<String, String> paramsMap, Map<String, String> headerMap, OKCallBack callBack) {
+        mMethodType = methodType;
+        mUrl = url;
+        mJsonStr = jsonStr;
+        mParamsMap = paramsMap;
+        mHeaderMap = headerMap;
+        mCallBack = callBack;
+        getInstance();
+    }
+
+    public void setTag(Object tag) {
+        mTag = tag;
+    }
+
+    private void getInstance() {
+        mRequestBuilder = new okhttp3.Request.Builder();
+        switch (mMethodType) {
+            case OkHttpUtil.METHOD_GET:
+                setGetParams();
+                break;
+            case OkHttpUtil.METHOD_POST:
+                mRequestBuilder.post(getRequestBody());
+                break;
+        }
+        mRequestBuilder.url(mUrl);
+        if (mTag != null)
+            mRequestBuilder.tag(mTag);
+        if (mHeaderMap != null) {
+            setHeader();
+        }
+        mOkHttpRequest = mRequestBuilder.build();
+    }
+
+    private RequestBody getRequestBody() {
+        if (!TextUtils.isEmpty(mJsonStr)) {
+            MediaType JSON = MediaType.parse("application/json; charset=utf-8");
+            return RequestBody.create(JSON, mJsonStr);
+        }
+        FormBody.Builder formBody = new FormBody.Builder();
+        if (mParamsMap != null) {
+            for (String key : mParamsMap.keySet()) {
+                formBody.add(key, mParamsMap.get(key));
+            }
+        }
+        return formBody.build();
+    }
+
+    private void setGetParams() {
+        if (mParamsMap != null) {
+            mUrl = mUrl + "?";
+            for (String key : mParamsMap.keySet()) {
+                mUrl = mUrl + key + "=" + mParamsMap.get(key) + "&";
+            }
+            mUrl = mUrl.substring(0, mUrl.length() - 1);
+        }
+    }
+
+    private void setHeader() {
+        if (mHeaderMap != null) {
+            for (String key : mHeaderMap.keySet()) {
+                mRequestBuilder.addHeader(key, mHeaderMap.get(key));
+            }
+        }
+    }
+
+    void execute(OkHttpClient client) {
+        Call call = client.newCall(mOkHttpRequest);
+        try {
+            Response response = call.execute();
+            if (mCallBack != null) {
+                mCallBack.onSuccess(call, response);
+            }
+        } catch (IOException e) {
+            if (mCallBack != null) {
+                mCallBack.onError(call, e);
+            }
+        }
+    }
+
+    void call(OkHttpClient client) {
+        client.newCall(mOkHttpRequest).enqueue(new Callback() {
+            @Override
+            public void onFailure(final Call call, final IOException e) {
+                if (mCallBack != null) {
+                    mCallBack.onError(call, e);
+                }
+            }
+
+            @Override
+            public void onResponse(final Call call, final Response response) throws IOException {
+                if (mCallBack != null) {
+                    mCallBack.onSuccess(call, response);
+                }
+            }
+        });
+    }
+}

app/src/main/java/com/github/catvod/utils/okhttp/OkHttpUtil.java

@@ -0,0 +1,200 @@
+package com.github.catvod.utils.okhttp;
+
+import com.github.catvod.crawler.SpiderDebug;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Response;
+
+public class OkHttpUtil {
+
+    public static final String METHOD_GET = "GET";
+    public static final String METHOD_POST = "POST";
+
+    private static final int DEFAULT_TIMEOUT = 15;
+
+    private static final Object lockO = new Object();
+
+    private static OkHttpClient defaultClient = null;
+
+    /**
+     * 不自动重定向
+     */
+    private static OkHttpClient noRedirectClient = null;
+
+    public static OkHttpClient defaultClient() {
+        synchronized (lockO) {
+            if (defaultClient == null) {
+                OkHttpClient.Builder builder = new OkHttpClient.Builder()
+                        .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .retryOnConnectionFailure(true)
+                        .sslSocketFactory(new SSLSocketFactoryCompat(SSLSocketFactoryCompat.trustAllCert), SSLSocketFactoryCompat.trustAllCert);
+                defaultClient = builder.build();
+            }
+            return defaultClient;
+        }
+    }
+
+    public static OkHttpClient noRedirectClient() {
+        synchronized (lockO) {
+            if (noRedirectClient == null) {
+                OkHttpClient.Builder builder = new OkHttpClient.Builder()
+                        .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
+                        .followRedirects(false)
+                        .followSslRedirects(false)
+                        .retryOnConnectionFailure(true)
+                        .sslSocketFactory(new SSLSocketFactoryCompat(SSLSocketFactoryCompat.trustAllCert), SSLSocketFactoryCompat.trustAllCert);
+                noRedirectClient = builder.build();
+            }
+            return noRedirectClient;
+        }
+    }
+
+    public static String string(OkHttpClient client, String url, String tag, Map<String, String> paramsMap, Map<String, String> headerMap, Map<String, List<String>> respHeaderMap) {
+        OKCallBack<String> stringCallback = new OKCallBack<String>() {
+            @Override
+            public String onParseResponse(Call call, Response response) {
+                try {
+                    if (respHeaderMap != null) {
+                        respHeaderMap.clear();
+                        respHeaderMap.putAll(response.headers().toMultimap());
+                    }
+                    return response.body().string();
+                } catch (IOException e) {
+                    return "";
+                }
+            }
+
+            @Override
+            public void onFailure(Call call, Exception e) {
+                setResult("");
+                SpiderDebug.log(e);
+            }
+
+            @Override
+            public void onResponse(String response) {
+            }
+        };
+        OKRequest req = new OKRequest(METHOD_GET, url, paramsMap, headerMap, stringCallback);
+        req.setTag(tag);
+        req.execute(client);
+        return stringCallback.getResult();
+    }
+
+    public static String stringNoRedirect(String url, Map<String, String> headerMap, Map<String, List<String>> respHeaderMap) {
+        return string(noRedirectClient(), url, null, null, headerMap, respHeaderMap);
+    }
+
+    public static String string(String url, Map<String, String> headerMap, Map<String, List<String>> respHeaderMap) {
+        return string(defaultClient(), url, null, null, headerMap, respHeaderMap);
+    }
+
+    public static String string(String url, Map<String, String> headerMap) {
+        return string(defaultClient(), url, null, null, headerMap, null);
+    }
+
+    public static String string(String url, String tag, Map<String, String> headerMap) {
+        return string(defaultClient(), url, tag, null, headerMap, null);
+    }
+
+    public static void get(OkHttpClient client, String url, OKCallBack callBack) {
+        get(client, url, null, null, callBack);
+    }
+
+    public static void get(OkHttpClient client, String url, Map<String, String> paramsMap, OKCallBack callBack) {
+        get(client, url, paramsMap, null, callBack);
+    }
+
+    public static void get(OkHttpClient client, String url, Map<String, String> paramsMap, Map<String, String> headerMap, OKCallBack callBack) {
+        new OKRequest(METHOD_GET, url, paramsMap, headerMap, callBack).execute(client);
+    }
+
+    public static void post(OkHttpClient client, String url, OKCallBack callBack) {
+        post(client, url, null, callBack);
+    }
+
+    public static void post(OkHttpClient client, String url, Map<String, String> paramsMap, OKCallBack callBack) {
+        post(client, url, paramsMap, null, callBack);
+    }
+
+    public static void post(OkHttpClient client, String url, Map<String, String> paramsMap, Map<String, String> headerMap, OKCallBack callBack) {
+        new OKRequest(METHOD_POST, url, paramsMap, headerMap, callBack).execute(client);
+    }
+
+    public static void post(OkHttpClient client, String url, String tag, Map<String, String> paramsMap, Map<String, String> headerMap, OKCallBack callBack) {
+        OKRequest req = new OKRequest(METHOD_POST, url, paramsMap, headerMap, callBack);
+        req.setTag(tag);
+        req.execute(client);
+    }
+
+    public static void postJson(OkHttpClient client, String url, String jsonStr, OKCallBack callBack) {
+        postJson(client, url, jsonStr, null, callBack);
+    }
+
+    public static void postJson(OkHttpClient client, String url, String jsonStr, Map<String, String> headerMap, OKCallBack callBack) {
+        new OKRequest(METHOD_POST, url, jsonStr, headerMap, callBack).execute(client);
+    }
+
+    /**
+     * 根据Tag取消请求
+     */
+    public static void cancel(OkHttpClient client, Object tag) {
+        if (client == null || tag == null) return;
+        for (Call call : client.dispatcher().queuedCalls()) {
+            if (tag.equals(call.request().tag())) {
+                call.cancel();
+            }
+        }
+        for (Call call : client.dispatcher().runningCalls()) {
+            if (tag.equals(call.request().tag())) {
+                call.cancel();
+            }
+        }
+    }
+
+    public static void cancel(Object tag) {
+        cancel(defaultClient(), tag);
+    }
+    
+    public static void cancelAll() {
+        cancelAll(defaultClient());
+    }
+
+    /**
+     * 取消所有请求请求
+     */
+    public static void cancelAll(OkHttpClient client) {
+        if (client == null) return;
+        for (Call call : client.dispatcher().queuedCalls()) {
+            call.cancel();
+        }
+        for (Call call : client.dispatcher().runningCalls()) {
+            call.cancel();
+        }
+    }
+
+    /**
+     * 获取重定向地址
+     *
+     * @param headers
+     * @return
+     */
+    public static String getRedirectLocation(Map<String, List<String>> headers) {
+        if (headers == null)
+            return null;
+        if (headers.containsKey("location"))
+            return headers.get("location").get(0);
+        if (headers.containsKey("Location"))
+            return headers.get("Location").get(0);
+        return null;
+    }
+}

app/src/main/java/com/github/catvod/utils/okhttp/SSLSocketFactoryCompat.java

@@ -0,0 +1,167 @@
+package com.github.catvod.utils.okhttp;
+
+import android.os.Build;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.cert.CertificateException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+public class SSLSocketFactoryCompat extends SSLSocketFactory {
+    private final SSLSocketFactory defaultFactory;
+    // Android 5.0+ (API level21) provides reasonable default settings
+    // but it still allows SSLv3
+    // https://developer.android.com/about/versions/android-5.0-changes.html#ssl
+    static String[] protocols = null;
+    static String[] cipherSuites = null;
+
+    static {
+        try {
+            SSLSocket socket = (SSLSocket) SSLSocketFactory.getDefault().createSocket();
+            if (socket != null) {
+                /* set reasonable protocol versions */
+                // - enable all supported protocols (enables TLSv1.1 and TLSv1.2 on Android <5.0)
+                // - remove all SSL versions (especially SSLv3) because they're insecure now
+                List<String> protocols = new LinkedList<>();
+                for (String protocol : socket.getSupportedProtocols())
+                    if (!protocol.toUpperCase().contains("SSL"))
+                        protocols.add(protocol);
+                SSLSocketFactoryCompat.protocols = protocols.toArray(new String[protocols.size()]);
+                /* set up reasonable cipher suites */
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+                    // choose known secure cipher suites
+                    List<String> allowedCiphers = Arrays.asList(
+                            // TLS 1.2
+                            "TLS_RSA_WITH_AES_256_GCM_SHA384",
+                            "TLS_RSA_WITH_AES_128_GCM_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+                            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
+                            "TLS_ECHDE_RSA_WITH_AES_128_GCM_SHA256",
+                            // maximum interoperability
+                            "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_RSA_WITH_AES_128_CBC_SHA",
+                            // additionally
+                            "TLS_RSA_WITH_AES_256_CBC_SHA",
+                            "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+                            "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
+                            "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA");
+                    List<String> availableCiphers = Arrays.asList(socket.getSupportedCipherSuites());
+                    // take all allowed ciphers that are available and put them into preferredCiphers
+                    HashSet<String> preferredCiphers = new HashSet<>(allowedCiphers);
+                    preferredCiphers.retainAll(availableCiphers);
+                    /* For maximum security, preferredCiphers should *replace* enabled ciphers (thus disabling
+                     * ciphers which are enabled by default, but have become unsecure), but I guess for
+                     * the security level of DAVdroid and maximum compatibility, disabling of insecure
+                     * ciphers should be a server-side task */
+                    // add preferred ciphers to enabled ciphers
+                    HashSet<String> enabledCiphers = preferredCiphers;
+                    enabledCiphers.addAll(new HashSet<>(Arrays.asList(socket.getEnabledCipherSuites())));
+                    SSLSocketFactoryCompat.cipherSuites = enabledCiphers.toArray(new String[enabledCiphers.size()]);
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public SSLSocketFactoryCompat(X509TrustManager tm) {
+        try {
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(null, (tm != null) ? new X509TrustManager[]{tm} : null, null);
+            defaultFactory = sslContext.getSocketFactory();
+        } catch (GeneralSecurityException e) {
+            throw new AssertionError(); // The system has no TLS. Just give up.
+        }
+    }
+
+    private void upgradeTLS(SSLSocket ssl) {
+        // Android 5.0+ (API level21) provides reasonable default settings
+        // but it still allows SSLv3
+        // https://developer.android.com/about/versions/android-5.0-changes.html#ssl
+        if (protocols != null) {
+            ssl.setEnabledProtocols(protocols);
+        }
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP && cipherSuites != null) {
+            ssl.setEnabledCipherSuites(cipherSuites);
+        }
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return cipherSuites;
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return cipherSuites;
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        Socket ssl = defaultFactory.createSocket(s, host, port, autoClose);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException {
+        Socket ssl = defaultFactory.createSocket(host, port);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException {
+        Socket ssl = defaultFactory.createSocket(host, port, localHost, localPort);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        Socket ssl = defaultFactory.createSocket(host, port);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
+        Socket ssl = defaultFactory.createSocket(address, port, localAddress, localPort);
+        if (ssl instanceof SSLSocket)
+            upgradeTLS((SSLSocket) ssl);
+        return ssl;
+    }
+
+    //定义一个信任所有证书的TrustManager
+    public static final X509TrustManager trustAllCert = new X509TrustManager() {
+        @Override
+        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+        }
+
+        @Override
+        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+        }
+
+        @Override
+        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+            return new java.security.cert.X509Certificate[]{};
+        }
+    };
+}