Android 如何在将所需响应重播给用户之前拦截需要用户操作的响应

我有一个非常独特的问题要解决。我正在开发一款应用程序，该应用程序使用了Android中的传统okhttp客户端，并使用了自主开发的网络层，我们希望改用改型和OKHttp3

我们的问题是，我们的服务可能会对用户请求返回一个响应，该响应包含一个或多个用户必须执行的操作，然后服务器才会允许原始请求执行，从而返回所需的响应

有点像这样。用户尝试登录，但他们是新用户，而服务通过一系列信息收集操作进行响应。如果用户取消登录，他们不会登录，但如果用户执行了一系列操作，则会重放原始登录请求并登录

我正在仔细研究OkHttp3提供的拦截器接口，以此作为实现这一点的手段。现在我知道我可以截取任何响应并修改它或做其他事情，但接口方法最终必须返回response类型的值。但是，我需要能够在用户A:取消服务所需的操作或B:成功完成这些操作之前“保持/防止”返回

这就是我目前所拥有的

private static class ServerActionInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        Response response = chain.proceed(chain.request());
        Gson gson = new Gson();
        ServicesResponse serviceResponse = null;
        if (response.body() != null) {
            serviceResponse = gson.fromJson(response.body().string(), ServicesResponse.class);
        }
        if (serviceResponse != null) {
            if (serviceResponse.getServerActions() != null && serviceResponse.getServerActions().size() > 0) {
                //handle server actions

                handleServerActions(serviceResponse);//this must complete before we can return chain.proceed IF there are actions the user must take.
            }
        }
        return chain.proceed(chain.request());
    }
    //this method may end up returning a value
    private void handleServerActions(ServicesResponse serviceResponse) {
        //process server actions 
    }
}

这并不是很多，大多数都会发生在handleServerActions中，老实说，这对应用程序来说非常特殊。但问题的核心是，如果用户请求没有serverActions，或者有serverActions，并且用户已经完成了这些操作，那么真正的响应准备好交付给客户机，那么我应该采用什么方法来实现返回

---

谢谢。

由于有评论，我想我会分享我的解决方案

它涉及一个实现

回调的自定义抽象类

这只是一个通用示例，实际实现将取决于项目的业务规则

public abstract class CustomCallback<T extends CustomResponse> implements Callback<T> {
        private CustomExcetption encounteredException;
        private Class<T> clazz;

        public CustomCallback(Class<T> clazz) {
            this.clazz = clazz;
        }

        @Override
        public void onResponse(@NonNull Call<T> call, @NonNull Response<T> response) {

            if (response.body() != null) {
                T body = response.body();
                i
                if (body != null && body.hasCustomActions() != null && body.hasCustomActions().size() > 0) {
                    handleCustomAction(body);
                } else {
                    onSuccessfulResponse(body);
                }

            } else if (response.errorBody() != null) {
                  onFailureResponse(exception);
            }
        }

        @Override
        public void onFailure(@NonNull Call<T> call, @NonNull Throwable throwable) {
            onNetworkFailure(call, exception);
        }

        public abstract void onSuccessfulResponse(@Nullable T response);

        public abstract void onFailureResponse(CustomException exception);

        public abstract void onNetworkFailure(Call<T> call, CustomException exception);

        public void handleCustomAction(@NonNull final T body, final String path) {
          //handle custom actions.
          if(customActionsHandledSuccessfully) {
              onSuccessfulResponse(body);
          } else {
              //create your exception somehow
              CustomException createdException = new CustomException();
              onFailureResponse(createdException);
          }
        }
    }  

你解决了这个问题吗？我也被困在一个类似的地方。是的，我被困在了。我决定创建一个抽象类来实现改型的
回调
。我创建了抽象方法，
onResponse
和
onFailure
在检查了改装收到的响应后调用这些方法。此外，我还必须实现一个拦截器，将http响应代码改写为200，因为我们对这个特定位置使用了一个自定义的400+代码，并且改型认为200以外的任何东西都是错误的。我用我的自定义回调类代替了通常使用的
回调
。@chinmish感谢您的评论/问题。我发布了更详细的解决方案作为答案。我觉得上面的评论可能不是充分的解释。
service.someApi().enqueue(new CustomCallback<SomeResponse>(SomeResponse.class) {
            @Override
            public void onSuccessfulResponse(@Nullable SomeResponse response) {
            }

            @Override
            public void onFailureResponse(CustomException exception) {
            }

            @Override
            public void onNetworkFailure(Call<SomeResponse> call, CustomException exception) {
            }
   });