Android封装OkHttp网络请求

最新推荐文章于 2023-04-04 14:25:32 发布
最新推荐文章于 2023-04-04 14:25:32 发布
阅读量339 收藏
点赞数
分类专栏： Android 文章标签： android 网络 框架 OKHttp 网络请求
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maz5275125/article/details/78901364
版权

本篇涉及比较基础，因目前有很多种网络请求框架，在这简单的介绍一下我在项目中使用的okhttp请求


首先加入okhttp的引入  

implementation 'com.squareup.okhttp3:okhttp:3.7.0'


在加入gson的引入

implementation 'au.com.gridstone.rxstore:converter-gson:5.0.2'


好，接下来进入主题，首先创建一个 CcApiClient类 用户封装okhttp的类

private static final String TAG = "CcApiClient";

private static final String APIVersion = "1.0.0";

final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

private final Context mContext;

private String mBaseUri;

private String mDevice;

private String mRequestId = "0";

private final OkHttpClient client;

private static final String[] API_URLS = {""};//多种服务器

private static final HashMap<String, List<Call>> calls = new HashMap<>();


这里面主要对读写超时做了设定，还有当网络遇到错误的时候我们可以进行构建其他节点获取数据，这个功能比较适应于开发国外的产品，当一个地方网络不好时，换一个服务器节点重新获取数据

private CcApiClient(final Context context) {
    this.mContext = context;
    this.setRouterIndex(-1);

    this.client = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(5, TimeUnit.SECONDS)
            .readTimeout(15, TimeUnit.SECONDS)
            .addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request request = chain.request();
                    try {
                        return chain.proceed(request);
                    } catch (Exception e) {
                        if (!NetUtil.isConnected(mContext)) {
                            //没有网络时, 抛出网络错误。
                            Logger.e(TAG, "error noconnect");
                            throw e;
                        } else {
                            if (Constent.DEBUG_VERSION) {
                                throw e;
                            } else {
                                //构建其他节点请求
                                //return chain.proceed(buildOtherNodeRequest(request));
                                return chain.proceed(request);
                            }
                        }
                    }
                }
            })
            .build();
}


这块主要是作用于在程序写上一个功能，可以手动的更换服务器路径，如果程序只有一个服务器，那就直接写死就好

public void setRouterIndex(int index) {
        String debugUrl = UIUtils.getSputils().getString("API_BASE_URL_DEBUG", "");
        if (!TextUtils.isEmpty(debugUrl)) {
            this.mBaseUri = debugUrl;
            return;
        }

        if (Constent.DEBUG_VERSION) {//如果是debug环境 改用debug服务器
            this.mBaseUri = "";//开发服务器
            return;
        }

        if (index > -1) {
            this.mBaseUri = API_URLS[index];
            UIUtils.getSputils().putString("API_BASE_URL", this.mBaseUri);
            Logger.d(TAG, "************** Select URL Router: " + index + " **************");
        } else {
            String baseUri = UIUtils.getSputils().getString("API_BASE_URL", "");
            if (TextUtils.isEmpty(baseUri)) {
                this.mBaseUri = API_URLS[0];
            } else {
                this.mBaseUri = baseUri;
            }
        }
    }

里面用到的方法，比如取消任务

public String getBaseUri() {
    return this.mBaseUri;
}

public void resetBaseUrl(String url) {
    this.mBaseUri = url;
}

public void setUserDevice(String device) {
    this.mDevice = device + "&api=" + APIVersion;
}

public void setRequestId(String requestId) {
    this.mRequestId = requestId;
}

public void cancelRequest(String requestId) {
    if (calls.containsKey(requestId)) {
        List<Call> request_calls = calls.get(requestId);
        for (int i = 0; i < request_calls.size(); i++) {
            request_calls.get(i).cancel();
        }

        request_calls.clear();

        calls.remove(requestId);
    }
}

先写上一个网络请求

/**
 * 获取用户信息
 */
public void getUserInfo(OnCcListener listener) {
    CcListener mListener = new CcListener(listener, "getUserInfo");

    Request("/v1.0/user/getUser", null, mListener, false);
}

Request方法 主要用于检查 Context上下文和回调是否有值

private void Request(String path, String params, final CcListener listener, boolean isPost) {
    if (!NetUtil.isConnected(mContext)) {
        if (listener != null && listener.mListener != null)
            listener.mListener.onResponse(new CcApiResult(1, "Network connect failed"));
        return;
    }
    RequestURL(mBaseUri + path, params, listener, isPost);
}

下面是RequestURL方法 主要针对get/post请求做出了一点相应的改变

private void RequestURL(String url, String params, final CcListener listener, boolean isPost) {
        Logger.d(TAG, "Request url:" + url);
        Logger.d(TAG, "Request params:" + params);

        Request.Builder builder;

        if (isPost) {
            if (TextUtils.isEmpty(params)) {
                params = "";
            }

            RequestBody body = RequestBody.create(JSON, params);

            builder = new Request.Builder().url(url).post(body);
        } else {
            builder = new Request.Builder().url(url);
        }

        if (UIUtils.getSputils().getBoolean(Constent.LOADING_BROCAST_TAG, false)) {
            builder.addHeader(Constent.TOKEN, UIUtils.getSputils().getString(Constent.TOKEN, ""));
            Logger.d(TAG, "token " + UIUtils.getSputils().getString(Constent.TOKEN, ""));
        } else {
            builder.addHeader(Constent.TOKEN, "");
            Logger.d(TAG, "token " + "");
        }
        builder.addHeader("Content-Type", "application/json;charset=UTF-8'");

        if (null != mDevice) {
            String device = mDevice + "&wifi=" + (NetUtil.isConnectedWifi(mContext) ? "1" : "0");
//            builder.addHeader("X-Cc-Device", device);
            Logger.d(TAG, "X-Cc-Device " + device);
        }

        Call call = client.newCall(builder.build());

        call.enqueue(listener);

        if (!calls.containsKey(mRequestId)) {
            calls.put(mRequestId, new ArrayList<Call>());
        }
        calls.get(mRequestId).add(call);
    }

然后就是最重要的CcListener方法，针对成功/失败做出相应的处理

private class CcListener implements Callback {
    public final String mTag;
    public final OnCcListener mListener;
    public boolean shouldCheckRouter = false;
    public boolean handled = false;

    public CcListener(OnCcListener listener, String tag) {
        mTag = tag;
        mListener = listener;
    }

    @Override
    public void onFailure(Call call, IOException e) {
        if (call.isCanceled()) return;

        if (handled) return;

        //记录网络请求失败的原因
        if (NetUtil.isConnected(mContext)) {
            Request request = call.request();
            String url = request.url().toString().split("[?]")[0];
            //请求超时不记录错误日志
            if (!(e instanceof SocketTimeoutException) && !(e instanceof UnknownHostException)) {
                Logger.e(TAG, "Exception " + url + "=" + e);
            }
        }

        final int statusCode = 1;

        final String errMessage = "Network connect failed";
        AndroidUtilities.runOnUIThread(new Runnable() {
            @Override
            public void run() {
                if (mListener != null)
                    mListener.onResponse(new CcApiResult(statusCode, errMessage));
            }
        });
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (call.isCanceled()) return;

        Request request = call.request();
        String url = request.url().toString();

        if (response == null || !response.isSuccessful()) {
            int statusCode = 1;
            String errMessage = "Network connect failed";
            if (null != response) {
                statusCode = response.code();
                if (statusCode >= 500) {
                    statusCode = 500;
                } else if (statusCode == 401 || statusCode == 403) {
                    //不变
                } else {
                    statusCode = 1;
                }
                errMessage = response.message();

                if (statusCode > 1) {
                    Logger.e(TAG, new IOException("Unexpected code " + response));
                }
            }

            if (handled) {
                Logger.d(TAG, url + ": too slow");
                return;
            }
            handled = true;

            if (shouldCheckRouter) {
                for (int i = 0; i < API_URLS.length; i++) {
                    if (url.startsWith(API_URLS[i])) {
                        setRouterIndex(i);
                        break;
                    }
                }
            }
            Logger.d(TAG, "Error Response Status code:" + String.valueOf(statusCode) + ", Error message:" + errMessage);
            final int finalStatusCode = statusCode;
            final String finalErrMessage = errMessage;
            AndroidUtilities.runOnUIThread(new Runnable() {
                @Override
                public void run() {
                    if (mListener != null)
                        mListener.onResponse(new CcApiResult(finalStatusCode, finalErrMessage));
                }
            });
        } else {
            ResponseBody responseBody = response.body();

            String arg0;

            try {
                arg0 = responseBody.string();
            } catch (SocketTimeoutException e) {
                Logger.d(TAG, "read-timeout:" + url);
                final int statusCode = 1;

                final String errMessage = "Network connect failed";

                AndroidUtilities.runOnUIThread(new Runnable() {
                    @Override
                    public void run() {
                        if (mListener != null)
                            mListener.onResponse(new CcApiResult(statusCode, errMessage));
                    }
                });
                return;
            } catch (Exception ex) {
                Logger.d(TAG, "Exception:" + url);
                final int statusCode = 1;
                final String errMessage = "Network connect failed";
                AndroidUtilities.runOnUIThread(new Runnable() {
                    @Override
                    public void run() {
                        if (mListener != null)
                            mListener.onResponse(new CcApiResult(statusCode, errMessage));
                    }
                });
                return;
            }
            if (handled) {
                Logger.d(TAG, url + ": too slow");
                return;
            }

            handled = true;

            if (shouldCheckRouter) {
                for (int i = 0; i < API_URLS.length; i++) {
                    if (url.startsWith(API_URLS[i])) {
                        setRouterIndex(i);
                        break;
                    }
                }
            }

            Logger.d(TAG, url + ": " + arg0);

            final CcApiResult mRes = new CcApiResult();

            //数据被篡改
            if (!arg0.startsWith("{")) {
                AndroidUtilities.runOnUIThread(new Runnable() {
                    @Override
                    public void run() {
                        if (mListener != null)
                            mListener.onResponse(new CcApiResult(1, "Network connect failed"));
                    }
                });
                return;
            }

            if (mTag.equals("doUserBind") || mTag.equals("getUserInfo") || mTag.equals("doFouceMatch") || mTag.equals("doUodatePassWord")
                    || mTag.equals("doThreeLogin") || mTag.equals("doLogin") || mTag.equals("doFouceMatchBall") || mTag.equals("doRegistTrial")) {
                mRes.fromUserInfoResult(arg0);
            } else if (mTag.equals("doCategoryList")) {
                mRes.fromCategoryListResult(arg0);
            } else if (mTag.equals("doMyPayBallList") || mTag.equals("doMyPayBallUnCheck") || mTag.equals("doRecentType")) {
                mRes.fromMyBallHistoryResult(arg0);
            } else if (mTag.equals("doRecentType2")) {
                mRes.fromRecentType2Result(arg0);
            } else if (mTag.equals("doBankList")) {
                mRes.fromBankListResult(arg0);
            } else if (mTag.equals("doAccountList")) {
                mRes.fromAccountListResult(arg0);
            } else if (mTag.equals("doArticleList")) {
                mRes.fromArticleListResult(arg0);
            } else if (mTag.equals("doExpertGuessList")) {
                mRes.fromExpertGuessListResult(arg0);
            } else if (mTag.equals("doShareInfo")) {
                mRes.fromShareInfoResult(arg0);
            } else if (mTag.equals("doArticleDetails")) {
                mRes.fromArticleDetailsResult(arg0);
            } else if (mTag.equals("doCommentDetailsList")) {
                mRes.fromCommentDetailsListResult(arg0);
            } else if (mTag.equals("doRecommHot")) {
                mRes.fromRecommHotListResult(arg0);
            } else if (mTag.equals("doNotices")) {
                mRes.fromNoticesResult(arg0);
            } else if (mTag.equals("doVersionIsUpdate")) {
                mRes.fromVersionIsUpdateResult(arg0);
            } else if (mTag.equals("doMatchData")) {
                mRes.fromMatchDataResult(arg0);
            } else if (mTag.equals("foArticleListById")) {
                mRes.fromArticleListByIdResult(arg0);
            } else if (mTag.equals("doMatchVoice")) {
                mRes.fromMatchVoiceResult(arg0);
            } else if (mTag.equals("doMyInfoTypeList")) {
                mRes.fromMyInfoTypeListResult(arg0);
            } else if (mTag.equals("doReportList")) {
                mRes.fromRepostListResult(arg0);
            } else if (mTag.equals("doGiftHistory") || mTag.equals("doAwardExchangeList")) {
                mRes.fromGiftHistoryResult(arg0);
            } else if (mTag.equals("doAgentInfo")) {
                mRes.fromAgentInfoResult(arg0);
            } else if (mTag.equals("doAgentCodeList")) {
                mRes.fromAgentCodeListResult(arg0);
            } else if (mTag.equals("doAgentCode")) {
                mRes.fromAgentCodeResult(arg0);
            } else if (mTag.equals("doAgentCheckList")) {
                mRes.fromAgentCheckListResult(arg0);
            } else if (mTag.equals("doAgentRemark")) {
                mRes.fromAgentRemarkResult(arg0);
            } else if (mTag.equals("doThirdImage")) {
                mRes.fromThirdImage(arg0);
            } else if (mTag.equals("doGetInviteCode")) {
                mRes.fromInviteCodeResult(arg0);
            } else if (mTag.equals("doExpertMoney")) {
                mRes.fromExpertMoneyResult(arg0);
            } else if (mTag.equals("doExpertDetails")) {
                mRes.fromExpertDetailsResult(arg0);
            } else if (mTag.equals("doRecommentMatchDetails")) {
                mRes.fromRecommentMatchDetailsResult(arg0);
            } else if (mTag.equals("doExpertInfoByName")) {
                mRes.fromExpertInfoByNameResult(arg0);
            } else if (mTag.equals("doUserAddress")) {
                mRes.fromUserAddressResult(arg0);
            } else if (mTag.equals("doMyMsgList")) {
                mRes.fromMyMsgListResult(arg0);
            } else if (mTag.equals("doGetDemoUser")) {
                mRes.fromDemoUserResult(arg0);
            } else if (mTag.equals("doUserWithdrawalsDetails")) {
                mRes.fromUserWithdrawalsDetailsResult(arg0);
            } else if (mTag.equals("doMatchResult") || mTag.equals("doPayByIdList") || mTag.equals("doMatchBasketBallResult")) {
                mRes.fromMatchResult(arg0);
            } else if (mTag.equals("doMatchGuessList") || mTag.equals("doMatchBallGuessList") || mTag.equals("doMatchGuessLeague") || mTag.equals("doMatchBallGuessLeague")) {
                mRes.fromMatchGuessListResult(arg0);
            } else if (mTag.equals("doChargeList")) {
                mRes.fromChargeListResult(arg0);
            } else if (mTag.equals("doAllArticleList")) {
                mRes.fromAllArticleListResult(arg0);
            } else if (mTag.equals("doUploadUserInfo")) {
                mRes.fromUploadUserInfo(arg0);
            } else if (mTag.equals("doUserSign")) {
                mRes.fromUserSignResult(arg0);
            } else if (mTag.equals("doWithDrawalsHistory")) {
                mRes.fromWithDrawalsHistoryResult(arg0);
            } else if (mTag.equals("doDisportList")) {
                mRes.fromDisportListResult(arg0);
            } else if (mTag.equals("doSysMessageList")) {
                mRes.fromSysMessageListResult(arg0);
            } else if (mTag.equals("doMainDataList")) {
                mRes.fromMainDataListResult(arg0);
            } else if (mTag.equals("doScoreByIdList")) {
                mRes.fromScoreByIdListResult(arg0);
            } else if (mTag.equals("doMatchFilterList") || mTag.equals("doMatchBallFilterList") || mTag.equals("doMatchFilter") || mTag.equals("doMatchBasketBallFilterList")) {
                mRes.fromMatchFilterListResult(arg0);
            } else if (mTag.equals("doActivityList")) {
                mRes.fromActivityListResult(arg0);
            } else if (mTag.equals("doGetAccount")) {
                mRes.fromAccountResult(arg0);
            } else if (mTag.equals("doMatchFx")) {
                mRes.fromMatchFxResult(arg0);
            } else if (mTag.equals("doMatchInfoMessage") || mTag.equals("doMatchInfoUpTimeMessage") || mTag.equals("doMatchInfoDownTimeMessage")) {
                mRes.fromMatchInfoMessageResult(arg0);
            } else if (mTag.equals("doPayTypeList")) {
                mRes.fromPayTypeListResult(arg0);
            } else if (mTag.equals("doMatchCount")) {
                mRes.fromMatchCountResult(arg0);
            } else if (mTag.equals("doMatchDetailsEvent")) {
                mRes.fromMatchDetailsEventResult(arg0);
            } else if (mTag.equals("doMatchDetailsPlay")) {
                mRes.fromMatchDetailsPlayResult(arg0);
            } else if (mTag.equals("doRecommMatchList")) {
                mRes.fromRecommMatchListResult(arg0);
            } else if (mTag.equals("doScrollBallList") || mTag.equals("doMatchBallTypeList") || mTag.equals("doMatchBallTypeList2")) {
                mRes.fromScrollBallListResult(arg0);
            } else if (mTag.equals("doEarlyFootBallList") || mTag.equals("doMatchBallEarlyList")) {
                mRes.fromEarlyListResult(arg0);
            } else if (mTag.equals("doMyOrderList")) {
                mRes.fromMyOrderListResult(arg0);
            } else if (mTag.equals("doMyYlList")) {
                mRes.fromMyYlListResult(arg0);
            } else if (mTag.equals("doMyFollowArticle")) {
                mRes.fromMyFollowArticleResult(arg0);
            } else if (mTag.equals("doMyArticleList") || mTag.equals("doFouceArticleList")) {
                mRes.fromMyArticleListResult(arg0);
            } else if (mTag.equals("doAchieveList")) {
                mRes.fromAchieveListResult(arg0);
            } else if (mTag.equals("doTaskList")) {
                mRes.fromTaskListResult(arg0);
            } else if (mTag.equals("doDayTask")) {
                mRes.fromDayTaskResult(arg0);
            } else if (mTag.equals("doChargeHistoryList")) {
                mRes.fromChargeHistoryListResult(arg0);
            } else if (mTag.equals("doGuideData")) {
                mRes.fromGuideDataResult(arg0);
            } else if (mTag.equals("doFansList") || mTag.equals("doExpertHotList")) {
                mRes.fromFansListResult(arg0);
            } else if (mTag.equals("doMyFansList")) {
                mRes.fromMyFansListResult(arg0);
            } else if (mTag.equals("doMatchGuessCg") || mTag.equals("doMatchGuessByIds")) {
                mRes.fromMatchGuessCgResult(arg0);
            } else if (mTag.equals("doWcollectList")) {
                mRes.fromWcollectListResult(arg0);
            } else if (mTag.equals("doRecommPage")) {
                mRes.fromRecommPageResult(arg0);
            } else if (mTag.equals("doHotDataPage")) {
                mRes.fromHotDataPageResult(arg0);
            } else if (mTag.equals("doRecommentExpert")) {
                mRes.fromRecommExpertResult(arg0);
            } else if (mTag.equals("doFiveDataList")) {
                mRes.fromFiveDataListResult(arg0);
            } else if (mTag.equals("doDiamondExchange") || mTag.equals("doAwardExchangeProps2")) {
                mRes.fromDiamondExchangeResult(arg0);
            } else if (mTag.equals("doDiamondExchange2") || mTag.equals("doAwardExchangeProps")) {
                mRes.fromDiamondExchangeResult2(arg0);
            } else if (mTag.equals("doAwardTypeList")) {
                mRes.fromAwardTypeListResult(arg0);
            } else if (mTag.equals("doAwardTypeList2")) {
                mRes.fromAwardTypeList2Result(arg0);
            } else if (mTag.equals("doAwardMessageTypeList")) {
                mRes.fromAwardMessageTypeListResult(arg0);
            } else if (mTag.equals("doAwardTurn")) {
                mRes.fromAwardTurnResult(arg0);
            } else if (mTag.equals("doChampionList")) {
                mRes.fromChampionsResult(arg0);
            } else if (mTag.equals("doMatchBasketLastResult")) {
                mRes.fromMatchBasketLastResult(arg0);
            } else {
                mRes.fromDefaultResult(arg0);
            }

            if (mRes.getErrno() < 0 && TextUtils.isEmpty(mRes.getMessage())) {
                mRes.setMessage("抱歉, 我们的服务出现了一点故障, 工程师正在紧张修复中, 请稍候再试");
            }

            AndroidUtilities.runOnUIThread(new Runnable() {
                @Override
                public void run() {
                    if (mListener != null)
                        mListener.onResponse(mRes);
                }
            });
        }
    }
}

最后一个就是CcResult针对返回数据做的处理，因为errno和meesgae还有status是每个接口都会返回的，所以抽取出来做公共

public class CcApiResult {
    private static final int ERRNO_OK = 0;

    private int errno;

    private String message;

    private boolean status;

    private Object data;

    public CcApiResult() {
        this.errno = -1;
    }

    public CcApiResult(int errno) {
        this.setErrno(errno);
    }

    public CcApiResult(int errno, String message) {
        this.setErrno(errno);
        this.setMessage(message);
    }

    public CcApiResult(int errno, String message, Object data) {
        this.setErrno(errno);
        this.setMessage(message);
        this.setData(data);
    }

    private void setErrno(int errno) {
        this.errno = errno;
    }

    public int getErrno() {
        return this.errno;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    public boolean getStatus() {
        return this.status;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getMessage() {
        return this.message;
    }

    private void setData(Object data) {
        this.data = data;
    }

    public Object getData() {
        return this.data;
    }

    public boolean isOk() {
        return getErrno() == ERRNO_OK && status;
    }

把gson封装起来

class BooleanTypeAdapter implements JsonSerializer<Boolean>, JsonDeserializer<Boolean> {

    public JsonElement serialize(Boolean value, Type typeOfT, JsonSerializationContext context) {
        return new JsonPrimitive(value ? 1 : 0);
    }

    public Boolean deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        int code = json.getAsInt();
        return code == 0 ? false : code == 1 ? true : null;
    }
}

private Gson getGson() {
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeAdapter(Boolean.class, new BooleanTypeAdapter());
    return builder.create();
}

解析返回数据

public CcApiResult fromCategoryListResult(String str) {
    Gson gson = getGson();
    List<AllCircleLBean> items = new ArrayList<>();
    try {
        JSONObject json = new JSONObject(str);
        this.setErrno(json.getInt("code"));
        this.setMessage(json.getString("msg"));
        this.setStatus(json.getBoolean("status"));
        if (json.has("data") && !json.isNull("data")) {
            JSONArray data = json.getJSONArray("data");
            items = gson.fromJson(data.toString(), new TypeToken<List<AllCircleLBean>>() {
            }.getType());
        }
    } catch (Exception e) {
        Logger.e("CcApiResult", e);
    }
    this.setData(items);
    return this;
}

使用：

private void getNetDataWork(final int off, int lim) {
    String mDate = DateUtils.getCurTime("yyyyMMdd");

    SSQSApplication.apiClient(0).getScrollBallList(true, 6, mDate, sType, leagueIDs, off, lim, new CcApiClient.OnCcListener() {
        @Override
        public void onResponse(CcApiResult result) {
            loadingDialog.dismiss();
            swipeToLoadLayout.setRefreshing(false);
            swipeToLoadLayout.setRefreshEnabled(true);

            if (result.isOk()) {
                CcApiResult.ResultScorePage page = (CcApiResult.ResultScorePage) result.getData();

                if (page != null && page.getItems() != null && page.getItems().size() >= 1) {
                    defaultView.setVisibility(View.GONE);

                    filterCell.beginRunnable(true);

                    originalData = page.getItems();

                    totalPage = page.getTotalCount();

                    filterCell.setTotalPage(totalPage);
                    filterCell.setCurrPage(off);

                    adapter.setList(getData(getFilterData(page.getItems())));
                } else {
                    adapter.clearData();

                    filterCell.destoryRunnable(true);

                    defaultView.setVisibility(View.VISIBLE);
                }

                isRefresh = false;
            } else {
                adapter.clearData();

                filterCell.destoryRunnable(true);

                defaultView.setVisibility(View.VISIBLE);

                ToastUtils.midToast(mContext, result.getMessage(), 1000);
            }
        }
    });
}


最后附加上构造CcApiClient时用到的方法在Application中构建

mApiClient = CcApiClient.instance(mContext);

mApiClient.setUserDevice(getUA());

获取用户手机信息

//获取用户手机信息
public static String getUA() {
    String deviceModel = "unknown";
    String langCode = "en";
    String appVersion = "unknown";
    String systemVersion = "Android " + Build.VERSION.SDK_INT;
    String imei = "0000";

    try {
        imei = DeviceIDUtil.getIMEI(mContext);
        langCode = LocaleController.getLocalLanguage();
        deviceModel = Build.MANUFACTURER;
        PackageInfo pInfo = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
        appVersion = String.valueOf(pInfo.versionCode);
        systemVersion = "Android " + Build.VERSION.SDK_INT;
    } catch (Exception e) {
        Logger.e("Application", e);
    }
    return "imei=" + imei + "&model=" + deviceModel + "&language=" + langCode + "&version=" + appVersion + "&os=" + systemVersion;
}


获取手机IMEI

public class DeviceIDUtil {
    private static String sIMEI = null;

    public static String getIMEI(Context context) {
        if (sIMEI != null) {
            return sIMEI;
        }

        String imei = UIUtils.getSputils().getString("IMEI", "");
        if (!TextUtils.isEmpty(imei)) {
            sIMEI = imei;
            return sIMEI;
        }
        try {
            imei = ((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE)).getDeviceId();
            if (!TextUtils.isEmpty(imei)) {
                sIMEI = imei;
            }
        } catch (Exception ignored) {

        }

        if (TextUtils.isEmpty(imei)) {
            try {
                sIMEI = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
            } catch (Exception ignored) {

            }
        }

        if (TextUtils.isEmpty(sIMEI)) {
            UUID uuid = UUID.randomUUID();
            sIMEI = uuid.toString().replaceAll("-", "");
        }

        UIUtils.getSputils().putString("IMEI", sIMEI);
        return sIMEI;

    }
}







巴黎没有欧莱雅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android okHttp网络请求封装
u013519290的博客
04-25 2125
okHttp使用
AndroidHttpLib:一个对OKHttp3再次封装的一个公司级的网络请求框架
05-16
AndroidHttpLib 一个对OKHttp3再次封装的一个公司级的网络请求框架 用法 没打jar包.此项目主要是为将要封装okhttp的开发者提供思路.当然此项目也可直接使用.本司已经将此库打包上传至maven,开发了两款成熟app. 目前已有的功能/亮点 get,post,patch,delete请求. 文件/多文件上传 文件下载,并均有进度回调. 简化的网络请求. 返回数据的实体类化. 完整的请求 主线程回调. 优化过的网络数据log. 支持请求类型(form/raw等)设置. 支持https. 支持添加自定义拦截器. 支持自定义数据转换(请求参数转换/请求到的数据转换). 面向接口开发,当你想使用其他网络请求框架代替okhttp,只需改动很少的代码便可实现替换. 稳定的对外api,底层库的替换,也不会影响到业务项目的开发.
Android - kotlin简易封装网络请求OkHttp
m0_59482482的博客
04-04 1409
一、okhttp库首先需要创建一个OkHttpClient的实例接下来如果想要发起一条HTTP请求，就需要创建一个Request对象：在最终的 build()方法之前连缀很多其他方法来丰富这个Request对象。比如可以通过url()方法来设 置目标的网络地址之后调用OkHttpClient的newCall()方法来创建一个Call对象，并调用它的execute()方法 来发送请求并获取服务器返回的数据Response对象就是服务器返回的数据了，我们可以使用如下写法来得到返回的具体内容。
Android项目中okhttp3的简易封装和使用
liujichangdeboke的博客
06-24 5307
简单封装的okhttp3请求框架
android okhttp封装步骤,Android OkHttp的简单使用和封装详解
weixin_39615643的博客
05-25 260
Android OkHttp的简单使用和封装详解1，昨天把okHttp仔细的看了一下，以前都是调用同事封装好了的网络框架，直接使用很容易，但自己封装却不是那么简单，还好，今天就来自我救赎一把，就和大家写写从最基础的OKHttp的简单get、post的使用，再到它的封装。2，OkHttp的简单使用首先我们创建一个工程，并在布局文件中添加三个控件，TextView(用于展示获取到json后的信息)、B...
Android-基于RxJava封装的OkHttp网络请求库
08-13
本文将详细解析如何基于RxJava封装OkHttp来构建一个强大的网络请求库，Lina-RxOkHttp。 首先，让我们理解下两个核心组件：RxJava和OkHttp。RxJava是一个用于处理异步数据流的库，它提供了观察者模式的实现，使得...
Android 基于协程OkHttp网络请求工具.zip
最新发布
04-24
可以创建一个`suspend`函数封装OkHttp的网络请求逻辑。 4. **代码实践** - 文件`AJT-code`可能包含了具体实现这一工具的源码，包括如何配置OkHttp，如何创建协程，以及如何处理网络请求的挂起函数。 - 可能的代码...
android 的OkHttp3网络的POST和GET请求
07-20
在Android开发中，网络通信是应用与服务器交互的重要方式，OkHttp3是一个高效且功能强大的网络请求库。本文将深入探讨如何使用OkHttp3进行GET和POST请求。 首先，我们来了解一下OkHttp3的基本概念。OkHttp是由...
Android-对OkHttp3请求库简单封装适配Json-Rpc调用协议
08-13
json-rpc是基于json的跨语言远程调用协议，比xml-rpc、webservice等基于文本的协议传输数据格小；相对hessian、java-rpc等二进制协议便于调试、实现、扩展，是非常优秀的一种远程调用协议。
Android-封装了okhttp的网络框架简化Android网络请求
08-13
封装了okhttp的网络框架，支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可以自定义返回对象，支持Https和自签名证书，支持cookie的持久化和自动管理
OkHttp的网络请求封装，包含六种方式以及详解。
10-11
OkHttp的简单网络请求封装，包含六种方式以及详解。博文介绍：https://github.com/QQ986945193/DavidOkHttpUtils
Android实战——okhttp的使用和封装
11-01
Android实战——okhttp的使用和封装
Android OkHttp完全解析及 一个改善的okHttp封装库（整理）
宝爷的专栏
04-27 1214
http://blog.csdn.net/lmj623565791/article/details/47911083； 本文出自:【张鸿洋的博客】一、概述最近在群里听到各种讨论okhttp的话题，可见okhttp的口碑相当好了。再加上Google貌似在6.0版本里面删除了HttpClient相关API，对于这个行为不做评价。为了更好的在应对网络访问，学习下okhttp还是蛮必要的，本篇博客首先介绍...
一个极简的Http请求client推荐，一行搞玩外部请求
热门推荐
LoveSummer
11-12 2万+
在Java的世界中，Http客户端之前一直是Apache家的HttpClient占据主导，但是由于此包较为庞大，API又比较难用，因此并不使用很多场景。而新兴的OkHttp、Jodd-http固然好用，但是面对一些场景时，学习成本还是有一些的。很多时候，我们想追求轻量级的Http客户端，并且追求简单易用。而OKHttp是一套处理 HTTP 网络请求的依赖库，由 Square 公司设计研发并开源，目前可以在 Java 和 Kotlin 中使用。对于 Android App。
android kotlin okhttp的封装
change_fate的博客
02-21 334
每次发请求需要写以下样板代码，封装起来，减少写代码。
Android中okhttp网络请求的封装
weixin_51022898的博客
07-12 1859
目前okhttp已经更新到了3.6版本，从3.0版本开始okhttp自带了一个线程，所以我们在使用时不需要开子线程。 在studios里使用okhttp之前，要添加依赖和权限。 依赖： compile ‘com.squareup.okhttp3:okhttp:3.6.0’ 权限： 一、okhttp最简单的写法 //请求服务器的地址 String url = “http://www.mtime.com/”; //创建okhttp端口 OkHttpClient okHttpClient = new OkHtt
Android简单基类封装（三）OKhttp网络请求——其实你也可以
王能的小屋
03-13 1万+
本文介绍如何抛弃那些高大上的、花里胡哨的、适配所有的完美http封装（壳子而已）。 学习地址：https://github.com/weimingjue/http 首先，OKhttp是现在所有安卓开发的网络请求框架（还在用Apache的我就不多说什么了，自行绕道），那些所谓的完美封装只是在OKhttp上加了几行代码而已。 其次，那些封装也是要考虑全局性，只是把OKhttp简化了一两行而已，真...
Android 一个改善的okHttp封装库
孤云博客
01-13 822
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) 转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/49734867； 本文出自:【张鸿洋的博客】 一、概述 之前写了篇Androi...
Android 对okhttp的封装
谢岩的博客
05-19 4212
不废话，需求：根据服务器API封装网络请求，怎么办？ 简单封装okhttp的get,post，put,delete请求： PersistentCookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(getApplicationCo...
Retrofit+RxJava+OkHttp：Android高效网络请求封装与实战指南
"本文将深入探讨"深入浅出RxJava+Retrofit+OkHttp网络请求"的主题，该篇内容旨在分享作者在学习和实践过程中对这三个强大的Android网络请求库的整合经验。Retrofit由Square公司提供，作为Android网络请求的高效框架...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值