Дооснащение: перенаправление на LoginActivity, если код ответа 401

Ответ 1

Рассмотреть вопрос о введении пользовательской реализации retrofit2.Callback интерфейса, например BaseCallback:

public abstract class BaseCallback<T> implements Callback<T> {

    private final Context context;

    public BaseCallback(Context context) {
        this.context = context;
    }

    @Override
    public void onResponse(Call<T> call, Response<T> response) {
        if (response.code() == 401) {
            // launch login activity using 'this.context'
        } else {
            onSuccess(response.body());
        }
    }

    @Override
    public void onFailure(Call<T> call, Throwable t) {

    }

    abstract void onSuccess(T response);

}

Теперь с сайта вызывающего абонента вы должны изменить new Callback<Token> с new BaseCallback<Token>:

call.enqueue(new BaseCallback<Token>(context) {
    @Override
    void onSuccess(Token response) {
        // do something with token
    }
});

Хотя этот подход не соответствует вашему следующему утверждению:

поэтому мне не нужно повторять один и тот же код заново для каждого вызова api

тем не менее, я не могу придумать лучшего подхода.

Ответ 2

Лично я хотел бы предложить использовать шаблон шины событий здесь. Вы можете использовать реализацию greenrobot или все, что захотите, поскольку это скорее подход архитектуры, а не конкретная реализация.

1. Создать модель события

   public class UnauthorizedEvent {
   
       private static final UnauthorizedEvent INSTANCE = new UnauthorizedEvent();
   
       public static UnauthorizedEvent instance() {
           return INSTANCE;
       }
   
       private UnauthorizedEvent() {
       }
   }
   

2. Внедрение пользовательского Interceptor который прерывает событие о несанкционированных реквизитах

   class UnauthorizedInterceptor implements Interceptor {
   
       @Override
       public Response intercept(@NonNull Chain chain) throws IOException {
           Response response = chain.proceed(chain.request());
           if (response.code() == 401) {
               EventBus.getDefault().post(UnauthorizedEvent.instance());
           }
           return response;
       }
   }
   

3. Создайте класс BaseActivity который обрабатывает UnauthorizedEvent

   public class BaseActivity extends Activity {
   
       @Override
       public void onStart() {
           super.onStart();
           EventBus.getDefault().register(this);
       }
   
       @Override
       public void onStop() {
           super.onStop();
           EventBus.getDefault().unregister(this);
       }
   
       @Subscribe
       public final void onUnauthorizedEvent(UnauthorizedEvent e) {
           handleUnauthorizedEvent();
       }
   
       protected void handleUnauthorizedEvent() {
           Intent intent = new Intent(this, LoginActivity.class);
           startActivity(intent);
       }
   }
   

4. Запретить запуск LoginActivity из LoginActivity

   public class LoginActivty extends BaseActivity {
   
       @Override
       protected void handleUnauthorizedEvent() {
           //Don't handle unauthorized event
       }
   }
   

   Другой подход заключается в том, чтобы не распространять BaseActivity здесь.

5. Зарегистрируйте свой перехватчик

   OkHttpClient client = new OkHttpClient.Builder()
           .addInterceptor(new UnauthorizedInterceptor())
           .build();
   

Плюсы:

• Свободная связь между компонентами
• Easaly расширяет логику, переопределяя handleUnauthorizedEvent
• Нет необходимости переписывать код для использования новых типов обратных вызовов
• Сократите человеческий фактор при совершении ошибок (используя Callback вместо BaseCallback)

Минусы:

• Шаблон EventBus упрощает отладку
• Еще одна зависимость или собственная реализация, которая привносит новый код в проект

Также учтите, что этот пример не охватывает проблемы многопоточности. Он решает вашу проблему обработки несанкционированных запросов. Таким образом, если два запроса получают 401, то возможно, что LoginActivity 2 экземпляра LoginActivity.

Ответ 3

Самый простой способ - включить контекст активности в экземпляр Interceptor. Если вы используете некоторые инструменты DI, такие как Dagger2 или Toothpick, это будет очень просто. Я рекомендую использовать зубочистку)

https://github.com/stephanenicolas/toothpick

Самый код рядом с ним будет в котлине, потому что это мой шаблонный код. Те, кто думает, что вам нужно решить вашу проблему, я напишу на Java.

Решение будет таким:

@Qualifier
annotation class BackendUrl


class ActivityModule(activity: BaseActivity): Module() {

    init {
        bind(Activity::class.java).toInstance(activity)
    }

}

class NetworkModule: Module() {

    init {
        bind(String::class.java).withName(BackendUrl::class.java).toInstance(Constants.URL)
        bind(Gson::class.java).toInstance(GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ss").create())
        bind(CacheHolder::class.java).toProvider(CacheProvider::class.java).singletonInScope()
        bind(OkHttpClient::class.java).toProvider(OkHttpProvider::class.java).instancesInScope()
        bind(BackendApi::class.java).toProvider(BackendApiProvider::class.java).instancesInScope()
        bind(RedirectInterceptor::class.java).to(RedirectInterceptor::class.java)
    }

}

Чем вам нужно создать поставщиков для инъекционной зависимости

class BackendApiProvider @Inject constructor(
        private val okHttpClient: OkHttpClient,
        private val gson: Gson,
        @BackendUrl private val serverPath: String
) : Provider<BackendApi> {

    override fun get() =
            Retrofit.Builder()
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .client(okHttpClient)
                    .baseUrl(serverPath)
                    .build()
                    .create(BackendApi::class.java)
}

И ваш перехватчик переадресации:

public class RedirectInterceptor implements Interceptor {

    private final Context context;

    @Inject
    public RedirectInterceptor(Activity context) {
        this.context = context;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request newRequest = chain.request().newBuilder()
                .build();

        Response response =  chain.proceed(newRequest);
        Log.d("MyApp", "Code : "+response.code());
        if (response.code() == 401){
            Intent intent = new Intent(context, LoginActivity.class);
            context.startActivity(intent);
            ((Activity) context).finish();
            return response;
        }

        return chain.proceed(newRequest);
    }
}

О да. Для заголовка авторизации лучше создать новый экземпляр другого перехватчика

class HeaderInterceptor(private val token: String?) : Interceptor {

    @Throws(IOException::class)
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        val newRequest =  request.newBuilder()

        Log.d(TAG, "token: $token")

        if (token != null && token.isNotBlank()) {
            newRequest.addHeader("Authorization", "Bearer $token")
        }

        return chain.proceed(newRequest.build())
    }

    companion object {
        private val TAG = HeaderInterceptor::class.java.toString()
    }

} 

И ваш OkhttpProvder

class OkHttpProvider @Inject constructor(cacheHolder: CacheHolder, prefs: IPreferences, redirectInterceptor: RedirectInterceptor) : Provider<OkHttpClient> {

    private val client: OkHttpClient

    init {

        val builder = OkHttpClient.Builder()
        builder
                .addNetworkInterceptor(redirectInterceptor)
                .addNetworkInterceptor(HeaderInterceptor(prefs.getAuthToken()))
                .readTimeout(30, TimeUnit.SECONDS)
                .cache(cacheHolder.okHttpCache)

        client = builder.build()
    }

    override fun get() = client
}

Это все! Теперь вам просто нужно разместить модули в правильных областях.

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.init_view)      

        Toothpick.openScopes("activity scope").apply {
            installModules(ActivityModule([email protected]))
            Toothpick.inject([email protected], this)
        }

        Toothpick.openScopes("activity scope", "network scope").apply {
            installModules(NetworkModule())
        }

        // your activity code
    }

Ответ 4

Обобщенное решение: вы можете решить его, обобщая обработку ошибок. Вы можете использовать пользовательскую функцию CallAdapterFactory для создания Retrofit. См. Ниже классы:

RxErrorHandlingCallAdapterFactory:

public class RxErrorHandlingCallAdapterFactory extends CallAdapter.Factory {
    private static Context mContext = null;
    private final RxJava2CallAdapterFactory original;

    private RxErrorHandlingCallAdapterFactory() {
        original = RxJava2CallAdapterFactory.create();
    }

    public static CallAdapter.Factory create(Context context) {
        mContext = context;
        return new RxErrorHandlingCallAdapterFactory();
    }

    @Override
    public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        return new RxCallAdapterWrapper(retrofit, original.get(returnType, annotations, retrofit));
    }

    private static class RxCallAdapterWrapper<R> implements CallAdapter<R, Object> {
        private final Retrofit retrofit;
        private final CallAdapter<R,
                Object> wrapped;

        public RxCallAdapterWrapper(Retrofit retrofit, CallAdapter<R, Object> wrapped) {
            this.retrofit = retrofit;
            this.wrapped = wrapped;
        }

        @Override
        public Type responseType() {
            return wrapped.responseType();
        }

        @Override
        public Object adapt(Call<R> call) {
            Object result = wrapped.adapt(call);
            if (result instanceof Single) {
                return ((Single) result).onErrorResumeNext(new Function<Throwable, SingleSource>() {
                    @Override
                    public SingleSource apply(@NonNull Throwable throwable) throws Exception {
                        return Single.error(asRetrofitException(throwable));
                    }
                });
            }
            if (result instanceof Observable) {
                return ((Observable) result).onErrorResumeNext(new Function<Throwable, ObservableSource>() {
                    @Override
                    public ObservableSource apply(@NonNull Throwable throwable) throws Exception {
                        return Observable.error(asRetrofitException(throwable));
                    }
                });
            }
            if (result instanceof Completable) {
                return ((Completable) result).onErrorResumeNext(new Function<Throwable, CompletableSource>() {
                    @Override
                    public CompletableSource apply(@NonNull Throwable throwable) throws Exception {
                        return Completable.error(asRetrofitException(throwable));
                    }
                });
            }
            return result;
        }

        private RetrofitException asRetrofitException(Throwable throwable) {
            // We had non-200 http error
            Log.v("log", "eror");
            throwable.printStackTrace();
            if (throwable instanceof HttpException) {
                HttpException httpException = (HttpException) throwable;
                final Response response = httpException.response();


                //if ((mContext instanceof Activity)) {

                String s = "Something went wrong."; //mContext.getString(R.string.something_went_wrong);
                try {
                    s = new JSONObject(response.errorBody().string()).getString("message");
                    if (response.code() == 401) { // 401 Unauthorized
                        Intent intent = new Intent(mContext, LoginActivity.class);
                        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
                        mContext.startActivity(intent);
                    }
                } catch (JSONException | IOException e) {
                    e.printStackTrace();
                }

                return RetrofitException.unexpectedError(s, response, retrofit);

                //showErrorDialog(mContext, response);
                //}

//                return RetrofitException.httpError(response.errorBody().toString(), response, retrofit);
            }
            // A network error happened
            if (throwable instanceof IOException) {
                return RetrofitException.networkError((IOException) throwable);
            }
            // We don't know what happened. We need to simply convert to an unknown error
            return RetrofitException.unexpectedError(throwable);
        }
    }
}

RetrofitException:

public class RetrofitException extends RuntimeException {
    private final String url;
    private final Response response;
    private final Kind kind;
    private final Retrofit retrofit;

    RetrofitException(String message, String url, Response response, Kind kind, Throwable exception, Retrofit retrofit) {
        super(message, exception);
        this.url = url;
        this.response = response;
        this.kind = kind;
        this.retrofit = retrofit;
    }

    public static RetrofitException httpError(String url, Response response, Retrofit retrofit) {
        String message = response.code() + " " + response.message();
        return new RetrofitException(message, url, response, Kind.HTTP, null, retrofit);
    }

    public static RetrofitException networkError(IOException exception) {
        return new RetrofitException(exception.getMessage(), null, null, Kind.NETWORK, exception, null);
    }

    public static RetrofitException unexpectedError(Throwable exception) {
        return new RetrofitException(exception.getMessage(), null, null, Kind.UNEXPECTED, exception, null);
    }

    public static RetrofitException unexpectedError(String s, Response response, Retrofit retrofit) {
        return new RetrofitException(s, null, null, Kind.UNEXPECTED, null, null);
    }

    /**
     * The request URL which produced the error.
     */
    public String getUrl() {
        return url;
    }

    /**
     * Response object containing status code, headers, body, etc.
     */
    public Response getResponse() {
        return response;
    }

    /**
     * The event kind which triggered this error.
     */
    public Kind getKind() {
        return kind;
    }

    /**
     * The Retrofit this request was executed on
     */
    public Retrofit getRetrofit() {
        return retrofit;
    }

    /**
     * HTTP response body converted to specified {@code type}. {@code null} if there is no
     * response.
     *
     * @throws IOException if unable to convert the body to the specified {@code type}.
     */
    public <T> T getErrorBodyAs(Class<T> type) throws IOException {
        if (response == null || response.errorBody() == null) {
            return null;
        }
        Converter<ResponseBody, T> converter = retrofit.responseBodyConverter(type, new Annotation[0]);
        return converter.convert(response.errorBody());
    }

    /**
     * Identifies the event kind which triggered a {@link RetrofitException}.
     */
    public enum Kind {
        /**
         * An {@link IOException} occurred while communicating to the server.
         */
        NETWORK,
        /**
         * A non-200 HTTP status code was received from the server.
         */
        HTTP,
        /**
         * An internal error occurred while attempting to execute a request. It is best practice to
         * re-throw this exception so your application crashes.
         */
        UNEXPECTED
    }
}

Перестроить строитель:

Retrofit retrofit = new Retrofit.Builder()
            .addCallAdapterFactory(RxErrorHandlingCallAdapterFactory.create(context))
                .addConverterFactory(GsonConverterFactory.create())
                .baseUrl(API_URL)
                .client(client)
                .build();

Вы можете обрабатывать 401 в RxErrorHandlingCallAdapterFactory и другие ошибки через Throwable.

Ответ 5

Используйте метод autheticator() OkHttpClient.Builder.

Это будет автоматически повторять попытку для неавторизованного запроса, когда ответ будет 401.

OkHttpClient client = new OkHttpClient.Builder().authenticator(new Authenticator() {
    @Override
    public Request authenticate(Route route, Response response) throws IOException {
    // Handle 401 error code 
    if (response.code() == 401) {

            Intent intent = new Intent(MainActivity.this.getApplicationContext(), LoginActivity.class);
            startActivity(intent);
            finish();
            return null;
        }

        return null;
        }
}