retrofit.client.Client Java Examples

public DrupalService getService(String endpoint) {
    if (endpoint == null) return mService;

    if (mService == null) {
        this.endpoint = endpoint;
        Client client = new OkClient(getOkHttpClient());

        if (mRequestInterceptor == null) {
            mRequestInterceptor = new SimpleRequestInterceptor();
        }
        mRequestInterceptor.cookie = cookie;
        mRequestInterceptor.accessToken = accessToken;
        mRequestInterceptor.xcsrfToken = xcsrfToken;

        mService = new RestAdapter.Builder()
            .setEndpoint(endpoint)
            .setRequestInterceptor(mRequestInterceptor)
            .setErrorHandler(new ErrorHandler())
            .setClient(client)
            .setConverter(new retrofit.converter.JacksonConverter())
            .setLogLevel(RestAdapter.LogLevel.FULL)  // Do this for development too.
            .build().create(DrupalService.class);
    }

    return mService;
}
 

public DrupalOAuth2Manager(Context context, String endpoint, String clientId, String clientSecret) {
    setContext(context);
    setEndpoint(endpoint);
    setClientId(clientId);
    setClientSecret(clientSecret);

    Client client = new OkClient(getOkHttpClient());

    if (mRequestInterceptor == null) {
        mRequestInterceptor = new SimpleRequestInterceptor();
    }
    mRequestInterceptor.cookie = cookie;

    RestAdapter restAdapter = new RestAdapter.Builder()
        .setEndpoint(endpoint)
        .setRequestInterceptor(mRequestInterceptor)
        .setErrorHandler(new ErrorHandler())
        .setClient(client)
        .setConverter(new retrofit.converter.JacksonConverter())
        .build();

    mService = restAdapter.create(DrupalOAuth2.class);
}
 

@Bean
public GithubService githubService(
    Endpoint githubEndpoint, Client retrofitClient, RestAdapter.LogLevel retrofitLogLevel) {
  log.info("Github service loaded");

  GithubService githubClient =
      new RestAdapter.Builder()
          .setEndpoint(githubEndpoint)
          .setConverter(new JacksonConverter())
          .setClient(retrofitClient)
          .setLogLevel(RestAdapter.LogLevel.FULL)
          .setLog(new Slf4jRetrofitLogger(GithubService.class))
          .build()
          .create(GithubService.class);

  return githubClient;
}
 

@Override
Client.Provider defaultClient() {
    final Client client;
    if (hasOkHttpOnClasspath()) {
        client = OkClientInstantiator.instantiate();
    } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.GINGERBREAD) {
        client = new AndroidApacheClient();
    } else {
        client = new UrlConnectionClient();
    }
    return new Client.Provider() {
        @Override
        public Client get() {
            return client;
        }
    };
}
 

@Provides @Singleton
RestAdapter provideRestAdapter(Endpoint endpoint, Client client, ErrorHandler errorHandler) {
    return new RestAdapter.Builder() //
            .setClient(client) //
            .setEndpoint(endpoint) //
            .setErrorHandler(errorHandler)
            .build();
}
 

public Client.Provider build() {

        return new Client.Provider() {

            public Client get() {
                return new ApacheClient(httpClientBuilder.build());
            }
        };
    }
 

@Before
public void setUp() {
    mMockClient = mock(Client.class);

    RestAdapter restAdapter = new RestAdapter.Builder()
            .setClient(mMockClient)
            .setEndpoint(SpotifyApi.SPOTIFY_WEB_API_ENDPOINT)
            .build();

    mSpotifyService = restAdapter.create(SpotifyService.class);
    mGson = new GsonBuilder().create();
}
 

@Bean
PagerDutyService pagerDutyService(
    Endpoint pagerDutyEndpoint, Client retrofitClient, RestAdapter.LogLevel retrofitLogLevel) {
  log.info("Pager Duty service loaded");

  return new RestAdapter.Builder()
      .setEndpoint(pagerDutyEndpoint)
      .setConverter(new JacksonConverter())
      .setClient(retrofitClient)
      .setLogLevel(retrofitLogLevel)
      .setLog(new Slf4jRetrofitLogger(PagerDutyService.class))
      .build()
      .create(PagerDutyService.class);
}
 

@Bean
JiraService jiraService(
    JiraProperties jiraProperties, Client retrofitClient, RestAdapter.LogLevel retrofitLogLevel) {
  if (x509ConfiguredClient != null) {
    LOGGER.info("Using X509 Cert for Jira Client");
    retrofitClient = x509ConfiguredClient;
  }

  RestAdapter.Builder builder =
      new RestAdapter.Builder()
          .setEndpoint(newFixedEndpoint(jiraProperties.getBaseUrl()))
          .setConverter(new JacksonConverter())
          .setClient(retrofitClient)
          .setLogLevel(retrofitLogLevel)
          .setLog(new Slf4jRetrofitLogger(JiraService.class));

  if (x509ConfiguredClient == null) {
    String credentials =
        String.format("%s:%s", jiraProperties.getUsername(), jiraProperties.getPassword());
    final String basic =
        String.format("Basic %s", Base64.encodeBase64String(credentials.getBytes()));
    builder.setRequestInterceptor(
        request -> {
          request.addHeader("Authorization", basic);
          request.addHeader("Accept", "application/json");
        });
  }

  return builder.build().create(JiraService.class);
}
 

public Client getClient(Boolean insecure) {
  if (insecure) {
    return new OkClient(httpClientFactory.getInsecureClient());
  } else {
    return new OkClient();
  }
}
 

@Provides @Singleton
RestAdapter provideRestAdapter(Endpoint endpoint, Client client, ErrorHandler errorHandler) {
    return new RestAdapter.Builder() //
            .setClient(client) //
            .setEndpoint(endpoint) //
            .setErrorHandler(errorHandler)
            .build();
}
 

@Provides
@Singleton
RestAdapter provideRestAdapter(Endpoint endpoint, Client client) {
    return new RestAdapter.Builder()
            .setClient(client)
            .setLogLevel(RestAdapter.LogLevel.FULL)
            .setEndpoint(endpoint)
            .build();
}
 

public static <T> T create(String endpoint, Class<T> service, Client client){
    RestAdapter adapter = new RestAdapter.Builder()
            .setEndpoint(endpoint)
            .setLogLevel(RestAdapter.LogLevel.BASIC)
            .setClient(client)
            .build();

    return adapter.create(service);
}
 

@Override
Client.Provider defaultClient() {
    final Client client;
    if (hasOkHttpOnClasspath()) {
        client = OkClientInstantiator.instantiate();
    } else {
        client = new UrlConnectionClient();
    }
    return new Client.Provider() {
        @Override
        public Client get() {
            return client;
        }
    };
}
 

/**
 * The HTTP client used for requests.
 */
public Builder setClient(Client.Provider clientProvider) {
    if (clientProvider == null) {
        throw new NullPointerException("Client provider may not be null.");
    }
    this.clientProvider = clientProvider;
    return this;
}
 

private RestAdapter(Server server, Client.Provider clientProvider, Executor httpExecutor, Executor callbackExecutor, RequestInterceptor requestInterceptor, Converter converter, Profiler profiler, ErrorHandler errorHandler, Log log, LogLevel logLevel) {
    this.server = server;
    this.clientProvider = clientProvider;
    this.httpExecutor = httpExecutor;
    this.callbackExecutor = callbackExecutor;
    this.requestInterceptor = requestInterceptor;
    this.converter = converter;
    this.profiler = profiler;
    this.errorHandler = errorHandler;
    this.log = log;
    this.logLevel = logLevel;
}
 

public OAuthHandler(Client client, String tokenIssuingEndpoint, String username,
		String password, String clientId, String clientSecret) {
	super();
	this.client = client;
	this.tokenIssuingEndpoint = tokenIssuingEndpoint;
	this.username = username;
	this.password = password;
	this.clientId = clientId;
	this.clientSecret = clientSecret;
}
 

public MockRestAdapter(final String responseString, final HashMap<String, String> headers) {
    this.exceptionReference = new AtomicReference<>();
    this.requestReference = new AtomicReference<>();
    this.resultReference = new AtomicReference<>();
    this.mockRestAdapter = new UpholdRestAdapter();
    this.restAdapter = new RestAdapter.Builder().setEndpoint(BuildConfig.API_SERVER_URL)
        .setRequestInterceptor(this.mockRestAdapter.getUpholdRequestInterceptor())
        .setClient(new Client() {
            @Override
            public Response execute(Request request) throws IOException {
                requestReference.set(request);

                return new Response("some/url", 200, "reason", new ArrayList<Header>() {{
                    if (headers != null) {
                        for (Map.Entry<String, String> entry : headers.entrySet()) {
                            String key = entry.getKey();
                            String value = entry.getValue();

                            add(new retrofit.client.Header(key, value));
                        }
                    }
                }}, new TypedByteArray("application/json", responseString == null ? new byte[0] : responseString.getBytes()));
            }
    }).build();

    this.mockRestAdapter.setAdapter(this.restAdapter);
}
 

public OAuthHandler(Client client, String tokenIssuingEndpoint, String username,
		String password, String clientId, String clientSecret) {
	super();
	this.client = client;
	this.tokenIssuingEndpoint = tokenIssuingEndpoint;
	this.username = username;
	this.password = password;
	this.clientId = clientId;
	this.clientSecret = clientSecret;
}
 

/**
 * The HTTP client used for requests.
 */
public Builder setClient(final Client client) {
    if (client == null) {
        throw new NullPointerException("Client may not be null.");
    }
    return setClient(new Client.Provider() {
        @Override
        public Client get() {
            return client;
        }
    });
}
 

@Override
public Client get() {
	final OkHttpClient okHttpClient = new OkHttpClient();
	okHttpClient.setReadTimeout(configuration.getReadTimeout(), TimeUnit.MILLISECONDS);
	okHttpClient.setConnectTimeout(configuration.getConnectionTimeout(), TimeUnit.MILLISECONDS);
	return new OkClient(okHttpClient);
}
 

public OAuthHandler(Client client, String tokenIssuingEndpoint, String username,
		String password, String clientId, String clientSecret) {
	super();
	this.client = client;
	this.tokenIssuingEndpoint = tokenIssuingEndpoint;
	this.username = username;
	this.password = password;
	this.clientId = clientId;
	this.clientSecret = clientSecret;
}
 

@Override
public SecuredRestBuilder setClient(Client client) {
	this.client = client;
	return (SecuredRestBuilder) super.setClient(client);
}
 

public TaskExecutor(Client client) {
    this.client = client;
}
 

/**
 * Constructor
 * @param clientId
 * @param clientSecret
 * @param clientRedirectUri
 * @param client
 * @param logLevel
 */
public UberClient(String clientId, String clientSecret, String clientRedirectUri, String serverToken, Client client, boolean useSandbox, RestAdapter.LogLevel logLevel) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.clientRedirectUri = clientRedirectUri;
    this.serverToken = serverToken;

    GsonBuilder gsonBuilder = new GsonBuilder()
            .excludeFieldsWithoutExposeAnnotation()
            .registerTypeAdapter(Date.class, new JsonDeserializer<Date>() {
                public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                    return new Date(json.getAsJsonPrimitive().getAsLong());
                }
            });
    OkHttpClient okHttpClient = new OkHttpClient();
    gson = gsonBuilder.create();

    RestAdapter restAdapter = new RestAdapter.Builder()
            .setEndpoint(useSandbox ? sandboxApiUri : apiUri)
            .setRequestInterceptor(new RequestInterceptor() {
                @Override
                public void intercept(RequestFacade requestFacade) {

                    if (hasAccessToken()) {
                        requestFacade.addHeader("Authorization", "Bearer " + getAccessToken());
                        return;
                    } else if (hasServerToken()) {
                        requestFacade.addHeader("Authorization", "Token " + getServerToken());
                    }
                }
            })
            .setErrorHandler(new ErrorHandler() {
                @Override
                public Throwable handleError(RetrofitError retrofitError) {
                    if (retrofitError != null && retrofitError.getResponse() != null) {
                        switch (retrofitError.getResponse().getStatus()) {
                            case 401: //Unauthorized
                                return new UnauthorizedException();
                            case 403: //Forbidden
                                return new ForbiddenException();
                        }
                    }
                    return retrofitError;
                }
            })
            .setLogLevel(logLevel)
            .setClient(client == null ? new OkClient(okHttpClient) : client)
            .setConverter(new GsonConverter(gson))
            .build();

    apiService = restAdapter.create(UberService.class);
    if (useSandbox) {
        sandboxService = restAdapter.create(SandboxService.class);
    }

    RestAdapter authRestAdapter = new RestAdapter.Builder()
            .setEndpoint(oAuthUri)
            .setLogLevel(logLevel)
            .setClient(client == null ? new OkClient(okHttpClient) : client)
            .setConverter(new GsonConverter(gson))
            .build();
    authService = authRestAdapter.create(UberAuthService.class);

}
 

@Provides @Singleton
Client provideClient(OkHttpClient client) {
    return new OkClient(client);
}
 

public Client getWrappedClient() {
    return wrappedClient;
}
 

public void setWrappedClient(Client wrappedClient) {
    this.wrappedClient = wrappedClient;
}
 

public ConnectivityAwareUrlClient(Context context, Client client) {
    this.context = context;
    this.wrappedClient = client;
}
 

@Bean
public Client retrofitClient() {
  return new OkClient();
}