左晓为主开发手持机充值管理机
zuoxiao
2024-08-21 6a5879320dfac43155d024814a0a4d794a612696
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package com.dayu.qiheonlinelibrary.net;
 
import android.content.Context;
import android.content.Intent;
import android.text.TextUtils;
 
 
import com.dayu.baselibrary.business.BusinessProvider;
import com.dayu.qiheonlinelibrary.bean.BaseResult;
import com.dayu.qiheonlinelibrary.net.subscribers.BaseProgressSubscriber;
import com.dayu.qiheonlinelibrary.net.subscribers.ProgressSubscriber;
import com.dayu.qiheonlinelibrary.net.subscribers.SubscriberListener;
import com.dayu.qiheonlinelibrary.utils.MyJsonParser;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Objects;
 
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.schedulers.Schedulers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
 
 
/**
 * Copyright (C), 2023,
 * Author: zuot
 * Date: 2023-04-12 9:11
 * Description:
 */
public class ApiManager {
 
    static ApiManager apiManager;
    //文件上传失败重复次数
    int uplodFilerepeatSize = 3;
 
    ApiService apiService;
 
    public static void init() {
        if (apiManager == null) {
            apiManager = new ApiManager();
        }
    }
 
    public ApiManager() {
        apiService = RetrofitClient.getInstance().getApiService();
    }
 
    public static ApiManager getInstance() {
        return apiManager;
    }
 
 
    public <T> void requestPostLoading(final Context context, final String path, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        request(context, false, path, false, tClass, params, listener);
    }
 
    public <T> void requestPostHideLoading(final Context context, final String path, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        request(context, true, path, false, tClass, params, listener);
    }
 
    public <T> void requestPost(final Context context, final String path, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        request(context, false, path, false, tClass, params, listener);
    }
 
    /**
     * 发送请求
     *
     * @param context
     * @param hideLoading 是否显示加载框  false:显示  true:隐藏
     * @param path        请求路径,在UrlConfig中定义
     * @param isGet       是否是Get请求 true:get 请求
     * @param tClass      对应的数据类型
     * @param params      Post请求时,对应的参数
     * @param listener    回调请求
     * @param <T>
     */
    public <T> void request(final Context context, final boolean hideLoading, final String path, final boolean isGet, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        Observable observable;
        BaseProgressSubscriber<?> mySubscriber;
 
 
        if (isGet) {
            if (params == null) {
                observable = apiService.requestGet(path);
            } else {
 
                observable = apiService.requestGet(path, params);
            }
        } else {
            if (params != null) {
                observable = apiService.requestPost(path, params);
            } else {
                observable = apiService.requestPost(path);
            }
        }
 
        mySubscriber = new ProgressSubscriber(context, hideLoading, listener);
        observable.subscribeOn(Schedulers.io()).
                map(new Function<Object, BaseResponse<T>>() {
                    @Override
                    public BaseResponse<T> apply(Object o) {
                        if (o instanceof BaseResponse) {
                            BaseResponse tem = (BaseResponse) o;
                            BaseResponse<T> response = new BaseResponse<>();
                            //未登录或登录超时,请重新登录
                            if (tem.getCode() == 100401) {
                                if (BusinessProvider.getBusinessProvider() != null) {
                                    BusinessProvider.getBusinessProvider().startLoginNavigotor.navigateToLogin(context);
                                }
 
                            }
 
                            response.setCode(tem.getCode());
                            response.setMsg(tem.getMsg());
                            if (tClass != null) {
                                if (TextUtils.isEmpty(tem.getData().toString()) && BaseResult.class.isAssignableFrom(tClass)) {
                                    response.setData(null);
                                    return response;
                                }
                                if (tem.getData() instanceof Map) {
                                    try {
//                                    response.setData(MyJsonParser.getBeanFromMap((Map<String, Object>) tem.getData(), tClass));
                                        String jsonData = MyJsonParser.getJsontoMap((Map) tem.getData());
                                        response.setData(MyJsonParser.getBeanFromJson(jsonData, tClass));
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                } else if (tem.getData() instanceof List) {
                                    try {
                                        response.setData((T) MyJsonParser.getListByJson(MyJsonParser.getJsonbyList((List) tem.getData()), tClass));
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                } else if (tem.getData() instanceof Integer) {
                                    response.setData((T) tem.getData());
                                } else if (tem.getData() instanceof Boolean) {
                                    response.setData((T) tem.getData());
                                }
                                if (tClass.getName() instanceof String && tem.getData() instanceof String) {
                                    try {
                                        response.setData((T) tem.getData());
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                }
                                return response;
                            }
                        }
 
                        return null;
                    }
                })
                .unsubscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(mySubscriber);
 
    }
 
 
}