Reusing Retrofit Methode

Question

Ich habe eine Methode, die einen Anruf auf meinen Server Retrofit mit macht:

public class MainActivity extends AppCompatActivity { 

    // ... activity methods here, removed for simplicity ... 

    // Used to subscribe to a user given their userId 
    public void subscribeToUser(int userId) { 
     final ApiInterface apiService = ApiClient.createService(ApiInterface.class); 

     Call<BasicResponse> call = apiService.subscribe(userId); 
     call.enqueue(new Callback<BasicResponse>() { 
      @Override 
      public void onResponse(Call<BasicResponse> call, Response<BasicResponse> response) { 
       if (response.isSuccessful()) { 
        Toast.makeText(MainActivity.this, "Success", Toast.LENGTH_LONG).show(); 
       } else { 
        Toast.makeText(MainActivity.this, "Failed", Toast.LENGTH_LONG).show(); 
       } 
      } 

      @Override 
      public void onFailure(Call<BasicResponse> call, Throwable t) { 
       Log.e(TAG, t.toString()); 
      } 
     }); 
    } 

} 

ich jetzt das gleiche Verfahren (subscribeToUser()) in einer anderen Tätigkeit verwenden müssen, aber es macht keinen Sinn, zu Kopieren Sie die Methode und fügen Sie sie in die andere Aktivität ein. Dann hätte ich einfach zweimal den gleichen Code.

So kann ich legte das Verfahren an einem Ort und haben es lassen sich die Aktivitäten wissen, ob der Anruf erfolgreich war oder nicht? Wie soll ich das organisieren?

Hier ist meine ApiClient.java Klasse:

public class ApiClient { 

    public static final String API_BASE_URL = "http://www.website.com/api/"; 

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder(); 

    private static Retrofit.Builder builder = 
      new Retrofit.Builder() 
        .baseUrl(API_BASE_URL) 
        .addConverterFactory(GsonConverterFactory.create()); 

    public static <S> S createService(Class<S> serviceClass) { 
     Retrofit retrofit = builder.client(httpClient.build()).build(); 

     return retrofit.create(serviceClass); 
    } 

    public static <S> S createService(Class<S> serviceClass, final String authToken) { 
     if (authToken != null) { 
      httpClient.addInterceptor(new Interceptor() { 
       @Override 
       public Response intercept(Interceptor.Chain chain) throws IOException { 
        Request original = chain.request(); 

        // Request customization: add request headers 
        Request.Builder requestBuilder = original.newBuilder() 
          .header("Authorization", "Bearer " + authToken) 
          .method(original.method(), original.body()); 

        Request request = requestBuilder.build(); 
        return chain.proceed(request); 
       } 
      }); 
     } 

     OkHttpClient client = httpClient.build(); 
     Retrofit retrofit = builder.client(client).build(); 

     return retrofit.create(serviceClass); 
    } 
} 

Und hier ist meine ApiInterface.java Klasse:

public interface ApiInterface { 
    @FormUrlEncoded 
    @POST("subscribe") 
    Call<BasicResponse> subscribe(@Field("userId") Integer userId); 
} 

Dank.

Answer 1

Meiner Meinung nach, createService(ApiInterface.class) sollte nicht mehrfach aufgerufen werden. Es ist nicht notwendig und verlangsamt Ihre Anwendung. Sie können versuchen, mit Userservice Singletonmuster zu erstellen, wie unten:

public class UserService { 

private UserService userService; 
final ApiInterface apiService; 
//Contructor private to prevent init object from outside directly. 
private UserService() { 
    apiService = ApiClient.createService(ApiInterface.class); 
} 
//use this method when you need to use UserService 
public static UserService getInstance() { 
    if(userService == null) { 
     userService = new UserService(); 
    } 
} 

// Used to subscribe to a user given their userId 
public void subscribeToUser(int userId, ServiceCallBack serviceCallBack) { 
    final ApiInterface apiService = ApiClient.createService(ApiInterface.class); 

    Call<BasicResponse> call = apiService.subscribe(userId); 
    call.enqueue(new Callback<BasicResponse>() { 
     @Override 
     public void onResponse(Call<BasicResponse> call, Response<BasicResponse> response) { 
      if (response.isSuccessful()) { 
       Toast.makeText(MainActivity.this, "Success", Toast.LENGTH_LONG).show(); 
       serviceCallBack.successful(response); 
      } else { 
       Toast.makeText(MainActivity.this, "Failed", Toast.LENGTH_LONG).show(); 
      } 
     } 

     @Override 
     public void onFailure(Call<BasicResponse> call, Throwable t) { 
      Log.e(TAG, t.toString()); 
      serviceCallBack.fail(t); 
     } 
    }); 
} 
//this is callback interface, help you know whether success from outside. 
interface ServiceCallBack { 
    void successful(Response response); 
    void fail(Throwable t); 
} 
} 

Wie zu verwenden:

UserService.getInstance(1, new ServiceCallBack(){ 

     @Override 
     public void successful(Response response) { 
      //process successful 
     } 

     @Override 
     public void fail(Throwable t) { 
      //process fail 
     } 
    }); 

Jetzt können Sie alle Methoden zur Benutzer api Userservice Klasse setzen beziehen wiederzuverwenden.