1.下载地图瓦片判断是否有网。 2.没有上传成功的巡检坐标有网时重新上传。 3.添加网络判断的工具类

zuoxiao

2024-12-04 4230457ee9edca6af738ec3f832ed0f49d0d99c3

 app/src/main/java/com/dayu/pipirrapp/net/ApiManager.java

@@ -1,29 +1,28 @@
package com.dayu.pipirrapp.net;

import android.content.Context;
import android.util.Log;


import com.dayu.pipirrapp.bean.WeatherResponse;
import com.dayu.pipirrapp.MyApplication;
import com.dayu.pipirrapp.bean.net.CodeResult;
import com.dayu.pipirrapp.bean.net.UplodFileState;
import com.dayu.pipirrapp.bean.net.WeatherResponse;
import com.dayu.pipirrapp.net.subscribers.BaseProgressSubscriber;
import com.dayu.pipirrapp.net.subscribers.CodeListener;
import com.dayu.pipirrapp.net.subscribers.ProgressSubscriber;
import com.dayu.pipirrapp.net.subscribers.SubscriberListener;
import com.dayu.pipirrapp.net.upload.UploadFileListener;
import com.dayu.pipirrapp.utils.MapJpgUtils;
import com.dayu.pipirrapp.utils.MyJsonParser;
import com.dayu.pipirrapp.utils.NetUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
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.disposables.CompositeDisposable;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.schedulers.Schedulers;
import okhttp3.MediaType;
@@ -43,11 +42,14 @@
 */
public class ApiManager {

    static String TAG = "ApiManager";

    static ApiManager apiManager;
    //文件上传失败重复次数
    int uplodFilerepeatSize = 3;

    ApiService apiService;
    private CompositeDisposable compositeDisposable = new CompositeDisposable(); // 管理订阅事件

    /**
     * 初始化通信框架
@@ -60,6 +62,7 @@

    public ApiManager() {
        apiService = RetrofitClient.getInstance().getApiService();

    }

    public static ApiManager getInstance() {
@@ -77,6 +80,14 @@

    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);
    }

    public <T> void requestGet(final Context context, final String path, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        request(context, false, path, true, tClass, params, listener);
    }

    public <T> void requestGetHideLoading(final Context context, final String path, final Class<T> tClass, final Map<String, Object> params, final SubscriberListener listener) {
        request(context, true, path, true, tClass, params, listener);
    }

    /**
@@ -98,10 +109,9 @@

        if (isGet) {
            if (params == null) {
                observable = apiService.requestGet(path);
                observable = apiService.requestGet(path, MyApplication.myApplication.token);
            } else {

                observable = apiService.requestGet(path, params);
                observable = apiService.requestGet(path, params, MyApplication.myApplication.token);
            }
        } else {
            observable = apiService.requestPost(path, params);
@@ -118,33 +128,16 @@
                            response.setCode(tem.getCode());
                            response.setMsg(tem.getMsg());

                            if (tClass != null && tem.getContent() instanceof Map) {
                                try {
//                                    response.setData(MyJsonParser.getBeanFromMap((Map<String, Object>) tem.getData(), tClass));
                                    String jsonData = MyJsonParser.getJsontoMap((Map) tem.getContent());
                                    response.setContent(MyJsonParser.getBeanFromJson(jsonData, tClass));
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            } else if (tClass != null && tem.getContent() instanceof List) {
                                try {
                                    response.setContent((T) MyJsonParser.getListByJson(MyJsonParser.getJsonbyList((List) tem.getContent()), tClass));
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            } else if (tClass != null && tem.getContent() instanceof Integer) {
                                response.setContent((T) tem.getContent());
                            }
                            if (tClass != null && tClass.getName() instanceof String && tem.getContent() instanceof String) {
                                try {
                            if (tClass != null) {
                                if (tem.getContent() instanceof Map) {
                                    response.setContent(parseMapContent(tem.getContent(), tClass));
                                } else if (tem.getContent() instanceof List) {
                                    response.setContent(parseListContent(tem.getContent(), tClass));
                                } else if (tem.getContent() instanceof Integer || tem.getContent() instanceof String) {
                                    response.setContent((T) tem.getContent());
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                            return response;


                        }

                        return null;
@@ -157,14 +150,36 @@
    }


    // 解析 Map 类型的数据
    private <T> T parseMapContent(Object content, Class<T> tClass) {
        try {
            String jsonData = MyJsonParser.getJsontoMap((Map<String, Object>) content);
            return MyJsonParser.getBeanFromJson(jsonData, tClass);
        } catch (Exception e) {
            Log.e(TAG, "Error parsing map content", e);
            return null;
        }
    }

    // 解析 List 类型的数据
    private <T> T parseListContent(Object content, Class<T> tClass) {
        try {
            String jsonData = MyJsonParser.getJsonbyList((List<?>) content);
            return (T) MyJsonParser.getListByJson(jsonData, tClass);
        } catch (Exception e) {
            Log.e(TAG, "Error parsing list content", e);
            return null;
        }
    }

    /**
     *  获取天气
     * @param data 经纬度（格式是 纬度:经度，英文冒号分隔）
     * 获取天气
     *
     * @param data     经纬度（格式是 纬度:经度，英文冒号分隔）
     * @param callback
     * @param <T>
     */
    public <T> void requestWeather(String data,Callback<WeatherResponse> callback) {
    public <T> void requestWeather(String data, Callback<WeatherResponse> callback) {
        Map<String, Object> params = new HashMap<>();
        params.put("key", "S6Tq4pvOakMuWRrg0");
        params.put("location", data);
@@ -176,4 +191,121 @@
    }


    /**
     * 获取验证码
     *
     * @param params
     * @param listener
     * @param <T>
     */
    public <T> void getCode(Map<String, Object> params, CodeListener listener) {
        if (NetUtils.isNetworkAvailable(MyApplication.myApplication)) {
            Observable observable;
            observable = apiService.getCode(params);
            observable.subscribeOn(Schedulers.io())
                    .unsubscribeOn(Schedulers.newThread())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(responseBody -> {
                        listener.onNext((CodeResult) responseBody);
                    }, throwable -> {
                        listener.error((Throwable) throwable);
                    });
        } else {
            listener.onNext(null);
        }

    }


    /**
     * 下载地图瓦片
     *
     * @param urlPath
     */
    public void donwLoadTile(Context context, String urlPath) {
        if (NetUtils.isNetworkAvailable(context)) {
            Observable<ResponseBody> observable;
            observable = apiService.downloadTile(urlPath);
            observable
                    .subscribeOn(Schedulers.io())  // 网络请求在 I/O 线程中进行
                    .observeOn(Schedulers.io())    // 回调处理也在 I/O 线程
                    .subscribe(
                            responseBody -> {

                                boolean success = false;
                                if (!MapJpgUtils.getInsatance().isHasFiles(urlPath)) {
                                    success = MapJpgUtils.getInsatance().saveTileToCache(urlPath, responseBody);
                                }
                                if (success) {
                                    Log.d(TAG, "Download success for tile: " + urlPath);
                                } else {
                                    Log.e(TAG, "Failed to save tile to disk: " + urlPath);
                                }
                            },
                            throwable -> Log.e(TAG, "Download failed for tile: " + urlPath)
                    );
        } else {
            Log.e(TAG, "没有网络不下载: " + urlPath);
        }
    }

    // 停止线程池，释放资源
    public void clearDisposables() {
        if (!compositeDisposable.isDisposed()) {
            compositeDisposable.dispose();
        }
    }


    /**
     * 上传文件
     *
     * @param context
     * @param file
     * @param listener
     */
    public void uploadFile(final Context context, final UplodFileState file, final UploadFileListener listener) {

        // 创建 RequestBody，用于封装构建RequestBody
        RequestBody requestFile =
                RequestBody.create(MediaType.parse("multipart/form-data"), file.getFile());
        // MultipartBody.Part  和后端约定好Key，这里的partName是用image
        MultipartBody.Part body = MultipartBody.Part.createFormData("file", file.getFile().getName(), requestFile);
        // 添加描述
        String descriptionString = "hello, 这是文件描述";
        RequestBody description = RequestBody.create(MediaType.parse("multipart/form-data"), descriptionString);
        apiService.uploadFile(description, body).enqueue(new Callback<BaseResponse>() {
            @Override
            public void onResponse(Call<BaseResponse> call, Response<BaseResponse> response) {
                if (response.body() != null) {
                    if (response.body().isSuccess()) {
                        file.setState(1);
                        file.setUrl(response.body().getMsg());
                        listener.onBack(file);
                    } else {
                        if (file.getNumber() <= uplodFilerepeatSize) {
                            file.setNumber(file.getNumber() + 1);
                            file.setState(2);
                            uploadFile(context, file, listener);
                        } else {
                            listener.onBack(file);
                        }
                    }
                }
            }

            @Override
            public void onFailure(Call<BaseResponse> call, Throwable t) {
                if (file.getNumber() <= uplodFilerepeatSize) {
                    file.setNumber(file.getNumber() + 1);
                    file.setState(2);
                    uploadFile(context, file, listener);
                } else {
                    listener.onBack(file);
                }
            }
        });
    }


}