Retrofit

ServiceGenerator

public class ServiceGenerator {

    private static ServiceGenerator instance = null;
    private final String BASE_URL = AppParams.getInstance().API_URL;
    private Context context = null;
    private Retrofit.Builder builder = new Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .addConverterFactory(GsonConverterFactory.create());
    private OkHttpClient.Builder httpClientBuilder = null;
    public ServiceGenerator(Context context) {
        this.context = context;
        this.httpClientBuilder = createHttpClientBuilder();
    }

    public static ServiceGenerator getInstance() {
        if (instance == null) {
            throw new RuntimeException("No ServiceGenerator instance");
        }
        return instance;
    }

    public static void createInstance(Context context) {
        instance = new ServiceGenerator(context);
    }

    public <S> S createService(Class<S> serviceClass) {
        builder.client(httpClientBuilder.build());
        Retrofit retrofit = builder.build();
        return retrofit.create(serviceClass);
    }

    private OkHttpClient.Builder createHttpClientBuilder() {
        try {
            // Create a trust manager that does not validate certificate chains
            final TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                        }

                        @Override
                        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                        }

                        @Override
                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                            return new X509Certificate[0];
                        }
                    }
            };

            // Install the all-trusting trust manager
            final SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
            // Create an ssl socket factory with our all-trusting manager
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            builder.sslSocketFactory(sslSocketFactory, (X509TrustManager) trustAllCerts[0]);
            builder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });

            // add header
            builder.addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    String sessionID = DSUser.getSessionId(context);
                    if (sessionID != null) {
                        Request original = chain.request();
                        Request request = original.newBuilder()
                                .header("XTOKEN", DSUser.getSessionId(context))
                                .method(original.method(), original.body())
                                .build();
                        return chain.proceed(request);
                    } else {
                        return chain.proceed(chain.request());
                    }
                }
            });

            // add logging
            if (BuildConfig.DEBUG) {
                HttpLoggingInterceptor.Logger logger = message -> { Log.i("API_V3", message); };

                HttpLoggingInterceptor logging = new HttpLoggingInterceptor(logger);
                logging.setLevel(HttpLoggingInterceptor.Level.BODY);

                builder.addInterceptor(logging);
            }

            return builder;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

UserManager

public class UserManager {
    static UserService service = ServiceGenerator.getInstance().createService(UserService.class);

    static public Observable<Void> SignUp(String email, String password, String name, String birth, String gender) {
        /* */
        return createUnwrappedObservable(service.signUp(body), result -> Observable.just(null));
    }
}