package com.driver.igotrip.netUtls;
|
|
|
import static com.driver.igotrip.netUtls.NetKitKt.getToken;
|
|
import android.util.Log;
|
|
import androidx.annotation.NonNull;
|
import androidx.annotation.Nullable;
|
|
import com.driver.igotrip.BuildConfig;
|
import com.driver.igotrip.R;
|
import com.driver.igotrip.base.Const;
|
import com.driver.igotrip.base.MyApplication;
|
import com.driver.igotrip.utils.LogUtils;
|
import com.google.gson.Gson;
|
import com.google.gson.reflect.TypeToken;
|
|
import org.json.JSONObject;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.lang.reflect.Type;
|
import java.security.KeyStore;
|
import java.security.cert.CertificateException;
|
import java.security.cert.CertificateFactory;
|
import java.security.cert.X509Certificate;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.TimeUnit;
|
|
import javax.net.ssl.SSLContext;
|
import javax.net.ssl.SSLSocketFactory;
|
import javax.net.ssl.TrustManager;
|
import javax.net.ssl.TrustManagerFactory;
|
import javax.net.ssl.X509TrustManager;
|
|
import cn.sinata.xldutils.utils.SPUtils;
|
import io.reactivex.Observable;
|
import io.reactivex.Observer;
|
import io.reactivex.android.schedulers.AndroidSchedulers;
|
import io.reactivex.schedulers.Schedulers;
|
import okhttp3.MediaType;
|
import okhttp3.MultipartBody;
|
import okhttp3.OkHttpClient;
|
import okhttp3.RequestBody;
|
import okhttp3.ResponseBody;
|
import okio.Buffer;
|
import retrofit2.Retrofit;
|
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
|
import retrofit2.converter.gson.GsonConverterFactory;
|
|
|
/**
|
* 网络请求管理类
|
* Created by Administrator on 2018/1/25.
|
*/
|
|
public class HttpManager {
|
//只信任指定证书的服务 安全级别高
|
private final ApiServics service = initBaseData(true, false).create(ApiServics.class);
|
//信任所有证书的服务 安全级别低
|
private final ApiServics allTrustService = initBaseData(false, true).create(ApiServics.class);
|
private Gson gson;
|
private final Map<String, String> headerParams = new HashMap<>();
|
|
private static final class HttpManagerHolder {
|
private static final HttpManager httpManager = new HttpManager();
|
}
|
|
public static synchronized HttpManager getInstance() {
|
return HttpManagerHolder.httpManager;
|
}
|
|
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";
|
}
|
}
|
|
@Nullable
|
private SSLSocketFactory getSSLSocketFactory(X509TrustManager trustManager) {
|
try {
|
SSLContext tls = SSLContext.getInstance("TLS");
|
tls.init(null, new TrustManager[]{trustManager}, null);
|
return tls.getSocketFactory();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
/**
|
* 创建特定证书信任管理器
|
*/
|
@Nullable
|
private X509TrustManager createTrustManager(int certificateResId) {
|
try {
|
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
|
try (
|
// 读取证书文件
|
InputStream inputStream = MyApplication.Companion.getAppContext().getResources().openRawResource(certificateResId)
|
) {
|
X509Certificate certificate = (X509Certificate) certificateFactory.generateCertificate(inputStream);
|
|
// 创建包含该证书的KeyStore
|
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
|
keyStore.load(null, null);
|
keyStore.setCertificateEntry("server", certificate);
|
|
// 创建TrustManager
|
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
|
trustManagerFactory.init(keyStore);
|
return (X509TrustManager) trustManagerFactory.getTrustManagers()[0];
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
/**
|
* 创建所有证书信任管理器
|
*/
|
@NonNull
|
private X509TrustManager createAllTrustManager() {
|
return new X509TrustManager() {
|
@Override
|
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
|
|
}
|
|
@Override
|
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
|
|
}
|
|
@Override
|
public X509Certificate[] getAcceptedIssuers() {
|
return new X509Certificate[0];
|
}
|
};
|
}
|
|
/**
|
* 初始化数据
|
*
|
*/
|
private Retrofit initBaseData(boolean isUseCert, boolean isTrustAll) {
|
// 监听请求条件
|
OkHttpClient.Builder builder = new OkHttpClient.Builder();
|
builder.connectTimeout(3, TimeUnit.MINUTES);
|
builder.readTimeout(3, TimeUnit.MINUTES);
|
builder.writeTimeout(3, TimeUnit.MINUTES);
|
if (isUseCert) {
|
X509TrustManager trustManager = createTrustManager(R.raw.star_gopost_ci);
|
if (trustManager != null) {
|
SSLSocketFactory sslSocketFactory = getSSLSocketFactory(trustManager);
|
if (sslSocketFactory != null) {
|
builder.sslSocketFactory(sslSocketFactory, trustManager);
|
}
|
}
|
} else {
|
if (isTrustAll) {
|
X509TrustManager trustManager = createAllTrustManager();
|
SSLSocketFactory sslSocketFactory = getSSLSocketFactory(trustManager);
|
if (sslSocketFactory != null) {
|
builder.sslSocketFactory(sslSocketFactory, trustManager);
|
}
|
}
|
}
|
// builder.addInterceptor(new Interceptor() {
|
// @Override
|
// public Response intercept(Chain chain) throws IOException {
|
// Request request = chain.request();
|
// Request.Builder requestBuilder = request.newBuilder();
|
// request = requestBuilder.post(RequestBody.create(MediaType.parse("application/x-www-form-urlencoded;charset=GBK"),
|
// URLDecoder.decode(bodyToString(request.body()), "UTF-8")))
|
// .build();
|
// return chain.proceed(request);
|
// }
|
// });
|
|
if (BuildConfig.DEBUG) {
|
builder.addInterceptor(new LoggingInterceptor());
|
}
|
|
Retrofit.Builder builder1 = new Retrofit.Builder()
|
.client(builder.build()) // 配置监听请求
|
.addConverterFactory(GsonConverterFactory.create()) // 请求结果转换（当前为GSON）
|
.addCallAdapterFactory(RxJava2CallAdapterFactory.create()); // 请求接受工具（当前为RxJava2）
|
// builder1.baseUrl(BASE_URL + action.substring(0, action.lastIndexOf("/") + 1));
|
builder1.baseUrl(BuildConfig.BASE_URL);
|
|
return builder1.build();
|
}
|
|
/**
|
* Get请求
|
*
|
* @param action 请求接口的尾址
|
* @param params 请求参数
|
* @param observer observer
|
*/
|
// public <T extends BaseBean> void get(final String action,
|
public void get(final String action, Map<String, String> params, Observer<ResponseBody> observer) {
|
if (params == null) {
|
params = new HashMap<>();
|
}
|
int type = getTypeByLanguage();
|
params.put(Const.language, type + ""); // 1 中文 2 英文 3 法文
|
if (gson == null) {
|
gson = new Gson();
|
}
|
|
Log.i("zzz", "request====" + new JSONObject(params));
|
headerParams.put("Authorization", "Bearer " + getToken());
|
// getService.getResult(action.substring(action.lastIndexOf("/") + 1), headerParams, params)
|
service.getResult(action, headerParams, params)
|
.subscribeOn(Schedulers.io())
|
.observeOn(AndroidSchedulers.mainThread())
|
.subscribe(observer);
|
}
|
|
|
public static int getTypeByLanguage() {
|
String lang = SPUtils.getString(Const.language, Const.Language.DEFAULT_LANGUAGE);
|
int type = 0;
|
if (lang == null || lang.isEmpty() || lang.equals(Const.Language.FRENCH)) {
|
type = 3;
|
} else if (lang.equals(Const.Language.CHINESE) || lang.equals("zh")) {
|
type = 1;
|
} else if (lang.equals(Const.Language.ENGLISH)) {
|
type = 2;
|
}
|
return type;
|
}
|
|
/**
|
* Post请求
|
*
|
* @param action 请求接口的尾址
|
* @param params 请求参数
|
*/
|
// public <T extends BaseBean> void post(final String action, Map<String, Object> params,
|
public void post(final String action, Map<String, Object> params,
|
Observer<ResponseBody> observer) {
|
post(false, action, params, observer);
|
}
|
|
/**
|
* Post请求
|
*
|
* @param isUseAllTrustService 是否使用信任所有证书服务
|
* @param action 请求接口的尾址
|
* @param params 请求参数
|
*/
|
// public <T extends BaseBean> void post(final String action, Map<String, Object> params,
|
public void post(boolean isUseAllTrustService, final String action, Map<String, Object> params,
|
Observer<ResponseBody> observer) {
|
post(isUseAllTrustService, action, params)
|
.subscribeOn(Schedulers.io())
|
.observeOn(AndroidSchedulers.mainThread())
|
.subscribe(observer);
|
}
|
|
/**
|
* Post请求
|
*
|
* @param action 请求接口的尾址
|
* @param params 请求参数
|
*/
|
public Observable<ResponseBody> post(final String action, Map<String, Object> params) {
|
return post(false, action, params);
|
}
|
|
/**
|
* Post请求
|
*
|
* @param action 请求接口的尾址
|
* @param params 请求参数
|
*/
|
public Observable<ResponseBody> post(boolean isUseAllTrustService, final String action, Map<String, Object> params) {
|
if (params == null) {
|
params = new HashMap<>();
|
}
|
int type = getTypeByLanguage();
|
params.put(Const.language, type); // 1 中文 2 英文 3 法文
|
LogUtils.d("post", params.toString());
|
headerParams.put("Authorization", "Bearer " + getToken());
|
return (isUseAllTrustService ? allTrustService : service).postResult(action, headerParams, params);
|
}
|
|
/**
|
* 将map数据转换为 普通的 json RequestBody
|
*
|
* @param map 以前的请求参数
|
* @return
|
*/
|
public static RequestBody convertMapToBody(Map<?, ?> map) {
|
return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), new JSONObject(map).toString());
|
}
|
|
|
/**
|
* Post请求
|
*
|
* @param action 请求接口的尾址
|
* @param fileName 文件名
|
*/
|
public void post(final String action, File fileName, Observer<ResponseBody> observer) {
|
post(action, fileName)
|
.subscribeOn(Schedulers.io())
|
.observeOn(AndroidSchedulers.mainThread())
|
.subscribe(observer);
|
}
|
|
/**
|
* Post请求
|
*
|
* @param action 请求接口的尾址
|
* @param file 文件
|
*/
|
public Observable<ResponseBody> post(final String action, File file) {
|
|
// https://github.com/iPaulPro/aFileChooser/blob/master/aFileChooser/src/com/ipaulpro/afilechooser/utils/FileUtils.java
|
// use the FileUtils to get the actual file by uri
|
|
// create RequestBody instance from file
|
RequestBody requestFile = RequestBody.create(MediaType.parse("multipart/form-data"), file);
|
|
// MultipartBody.Part is used to send also the actual file name
|
MultipartBody.Part body = MultipartBody.Part.createFormData("file", file.getName(), requestFile);
|
return service.upload(action, body);
|
}
|
|
|
/**
|
* 将json数据转换为map集合
|
*
|
* @param gsonStr
|
* @return
|
*/
|
public Map<String, Object> gsonToMap(String gsonStr) {
|
Gson gson = new Gson();
|
Type type = new TypeToken<Map<String, Object>>() {
|
}.getType();
|
Map<String, Object> map = gson.fromJson(gsonStr, type);
|
return map;
|
}
|
|
|
/**
|
* 将map集合转为json
|
*
|
* @param map
|
* @return
|
*/
|
public String mapToJson(Map<String, Object> map) {
|
String tab_str = "";
|
String json = tab_str + "{";
|
int i = 0;
|
for (String key : map.keySet()) {
|
if (i >= map.size())
|
break;
|
String content = "";
|
try {
|
List<Map<String, Object>> list = (List<Map<String, Object>>) map.get(key);
|
content += "[";
|
int j = 0;
|
for (Map<String, Object> map2 : list) {
|
if (j == list.size())
|
break;
|
content += mapToJson(map2) + (j++ == list.size() - 1 ? "" : ",");
|
}
|
content += tab_str + "]"/* + (i == (map.size() - 1) ? "" : ",")*/;
|
} catch (Exception e) {
|
content = "\"" + map.get(key).toString() + "\"";
|
}
|
json += tab_str + "\"" + key + "\":" + content + (i++ == map.size() - 1 ? "" : ",");
|
}
|
json += tab_str + "}";
|
return json;
|
}
|
|
}
|
