sdf

2020-08-03 09:11:54 +08:00
parent 537441d239
commit 06952bab00
737 changed files with 52091 additions and 0 deletions
--- a/app/src/main/java/http/BasicParamsInterceptor.java
+++ b/app/src/main/java/http/BasicParamsInterceptor.java
@@ -0,0 +1,202 @@
+package http;
+
+import android.text.TextUtils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import okhttp3.FormBody;
+import okhttp3.Headers;
+import okhttp3.HttpUrl;
+import okhttp3.Interceptor;
+import okhttp3.MediaType;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okio.Buffer;
+
+/**
+ *
+ * OkHttp 公共参数拦截器
+ * from: https://github.com/jkyeo/okhttp-basicparamsinterceptor.git
+ * Created by zhouwei on 16/11/10.
+ */
+
+public class BasicParamsInterceptor implements Interceptor {
+
+    Map<String, String> queryParamsMap = new HashMap<>();
+    Map<String, String> paramsMap = new HashMap<>();
+    Map<String, String> headerParamsMap = new HashMap<>();
+    List<String> headerLinesList = new ArrayList<>();
+
+    private BasicParamsInterceptor() {
+
+    }
+
+    @Override
+    public Response intercept(Chain chain) throws IOException {
+
+        Request request = chain.request();
+        Request.Builder requestBuilder = request.newBuilder();
+
+        // process header params inject
+        Headers.Builder headerBuilder = request.headers().newBuilder();
+        if (headerParamsMap.size() > 0) {
+            Iterator iterator = headerParamsMap.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry entry = (Map.Entry) iterator.next();
+                headerBuilder.add((String) entry.getKey(), (String) entry.getValue());
+            }
+        }
+
+        if (headerLinesList.size() > 0) {
+            for (String line: headerLinesList) {
+                headerBuilder.add(line);
+            }
+            requestBuilder.headers(headerBuilder.build());
+        }
+        // process header params end
+
+
+        // process queryParams inject whatever it's GET or POST
+        if (queryParamsMap.size() > 0) {
+            request = injectParamsIntoUrl(request.url().newBuilder(), requestBuilder, queryParamsMap);
+        }
+
+        // process post body inject
+        if (queryParamsMap.size() > 0) {
+            if (canInjectIntoBody(request)) {
+                FormBody.Builder formBodyBuilder = new FormBody.Builder();
+                for(Map.Entry<String, String> entry : paramsMap.entrySet()) {
+                    formBodyBuilder.add((String) entry.getKey(), (String) entry.getValue());
+                }
+
+                RequestBody formBody = formBodyBuilder.build();
+                String postBodyString = bodyToString(request.body());
+                postBodyString += ((postBodyString.length() > 0) ? "&" : "") +  bodyToString(formBody);
+                requestBuilder.post(RequestBody.create(MediaType.parse("application/x-www-form-urlencoded;charset=UTF-8"), postBodyString));
+            }
+        }
+
+        request = requestBuilder.build();
+        return chain.proceed(request);
+    }
+    private boolean canInjectIntoBody(Request request) {
+        if (request == null) {
+            return false;
+        }
+        if (!TextUtils.equals(request.method(), "POST")) {
+            return false;
+        }
+        RequestBody body = request.body();
+        if (body == null) {
+            return false;
+        }
+        MediaType mediaType = body.contentType();
+        if (mediaType == null) {
+            return false;
+        }
+        if (!TextUtils.equals(mediaType.subtype(), "x-www-form-urlencoded")) {
+            return false;
+        }
+        return true;
+    }
+
+    // func to inject params into url
+    private Request injectParamsIntoUrl(HttpUrl.Builder httpUrlBuilder, Request.Builder requestBuilder, Map<String, String> paramsMap) {
+        if (paramsMap.size() > 0) {
+            Iterator iterator = paramsMap.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry entry = (Map.Entry) iterator.next();
+                httpUrlBuilder.addQueryParameter((String) entry.getKey(), (String) entry.getValue());
+            }
+            requestBuilder.url(httpUrlBuilder.build());
+            return requestBuilder.build();
+        }
+
+        return null;
+    }
+
+    private static String bodyToString(final RequestBody request){
+        try {
+            final RequestBody copy = request;
+            final Buffer buffer = new Buffer();
+            if(copy != null)
+                copy.writeTo(buffer);
+            else
+                return "";
+            return buffer.readUtf8();
+        }
+        catch (final IOException e) {
+            return "did not work";
+        }
+    }
+
+    public static class Builder {
+
+        BasicParamsInterceptor interceptor;
+
+        public Builder() {
+            interceptor = new BasicParamsInterceptor();
+        }
+
+        public Builder addParam(String key, String value) {
+            interceptor.paramsMap.put(key, value);
+            return this;
+        }
+
+        public Builder addParamsMap(Map<String, String> paramsMap) {
+            interceptor.paramsMap.putAll(paramsMap);
+            return this;
+        }
+
+        public Builder addHeaderParam(String key, String value) {
+            interceptor.headerParamsMap.put(key, value);
+            return this;
+        }
+
+        public Builder addHeaderParamsMap(Map<String, String> headerParamsMap) {
+            interceptor.headerParamsMap.putAll(headerParamsMap);
+            return this;
+        }
+
+        public Builder addHeaderLine(String headerLine) {
+            int index = headerLine.indexOf(":");
+            if (index == -1) {
+                throw new IllegalArgumentException("Unexpected header: " + headerLine);
+            }
+            interceptor.headerLinesList.add(headerLine);
+            return this;
+        }
+
+        public Builder addHeaderLinesList(List<String> headerLinesList) {
+            for (String headerLine: headerLinesList) {
+                int index = headerLine.indexOf(":");
+                if (index == -1) {
+                    throw new IllegalArgumentException("Unexpected header: " + headerLine);
+                }
+                interceptor.headerLinesList.add(headerLine);
+            }
+            return this;
+        }
+
+        public Builder addQueryParam(String key, String value) {
+            interceptor.queryParamsMap.put(key, value);
+            return this;
+        }
+
+        public Builder addQueryParamsMap(Map<String, String> queryParamsMap) {
+            interceptor.queryParamsMap.putAll(queryParamsMap);
+            return this;
+        }
+
+        public BasicParamsInterceptor build() {
+            return interceptor;
+        }
+
+    }
+}