com.squareup.okhttp.Protocol Java Examples

@VisibleForTesting
OkHttpClient modifyClient(OkHttpClient client, boolean loggingEnabled, boolean tls12Enforced, int connectTimeout, int readTimeout, int writeTimeout) {
    if (loggingEnabled) {
        enableLogging(client);
    }
    if (tls12Enforced) {
        enforceTls12(client);
    }
    if(connectTimeout > 0){
        client.setConnectTimeout(connectTimeout, TimeUnit.SECONDS);
    }
    if(readTimeout > 0){
        client.setReadTimeout(readTimeout, TimeUnit.SECONDS);
    }
    if(writeTimeout > 0){
        client.setWriteTimeout(writeTimeout, TimeUnit.SECONDS);
    }
    client.setProtocols(Arrays.asList(Protocol.HTTP_1_1, Protocol.SPDY_3));
    return client;
}
 

/**
 * Initializes the global URLStreamHandlerFactory.
 * <p>
 * This method is invoked by {@link #init(boolean, boolean)}.
 */
public static void initProtocols(final SSLSocketFactory sslSocketFactory) {
  // Configure URL protocol handlers
  final StreamHandlerFactory factory = StreamHandlerFactory.getInstance();
  URL.setURLStreamHandlerFactory(factory);
  final OkHttpClient okHttpClient = new OkHttpClient();

  final ArrayList<Protocol> protocolList = new ArrayList<>(2);
  protocolList.add(Protocol.HTTP_1_1);
  protocolList.add(Protocol.HTTP_2);
  okHttpClient.setProtocols(protocolList);

  okHttpClient.setConnectTimeout(100, TimeUnit.SECONDS);

  // HttpsURLConnection.setDefaultSSLSocketFactory(sslSocketFactory);
  okHttpClient.setSslSocketFactory(sslSocketFactory);
  okHttpClient.setFollowRedirects(false);
  okHttpClient.setFollowSslRedirects(false);
  factory.addFactory(new OkUrlFactory(okHttpClient));
  factory.addFactory(new LocalStreamHandlerFactory());
}
 

/**
 * @return a new http client
 */
private OkHttpClient createHttpClient() {
    OkHttpClient client = new OkHttpClient();
    client.setReadTimeout(connectorOptions.getReadTimeout(), TimeUnit.SECONDS);
    client.setWriteTimeout(connectorOptions.getWriteTimeout(), TimeUnit.SECONDS);
    client.setConnectTimeout(connectorOptions.getConnectTimeout(), TimeUnit.SECONDS);
    client.setFollowRedirects(connectorOptions.isFollowRedirects());
    client.setFollowSslRedirects(connectorOptions.isFollowRedirects());
    client.setProxySelector(ProxySelector.getDefault());
    client.setCookieHandler(CookieHandler.getDefault());
    client.setCertificatePinner(CertificatePinner.DEFAULT);
    client.setAuthenticator(AuthenticatorAdapter.INSTANCE);
    client.setConnectionPool(ConnectionPool.getDefault());
    client.setProtocols(Util.immutableList(Protocol.HTTP_1_1));
    client.setConnectionSpecs(DEFAULT_CONNECTION_SPECS);
    client.setSocketFactory(SocketFactory.getDefault());
    Internal.instance.setNetwork(client, Network.DEFAULT);

    return client;
}
 

/**
 * Constructor.
 * @param metricsServer
 */
public HawkularMetricsClient(URL metricsServer) {
    this.serverUrl = metricsServer;
    httpClient = new OkHttpClient();
    httpClient.setReadTimeout(DEFAULT_READ_TIMEOUT, TimeUnit.SECONDS);
    httpClient.setWriteTimeout(DEFAULT_WRITE_TIMEOUT, TimeUnit.SECONDS);
    httpClient.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT, TimeUnit.SECONDS);
    httpClient.setFollowRedirects(true);
    httpClient.setFollowSslRedirects(true);
    httpClient.setProxySelector(ProxySelector.getDefault());
    httpClient.setCookieHandler(CookieHandler.getDefault());
    httpClient.setCertificatePinner(CertificatePinner.DEFAULT);
    httpClient.setAuthenticator(AuthenticatorAdapter.INSTANCE);
    httpClient.setConnectionPool(ConnectionPool.getDefault());
    httpClient.setProtocols(Util.immutableList(Protocol.HTTP_1_1));
    httpClient.setConnectionSpecs(DEFAULT_CONNECTION_SPECS);
    httpClient.setSocketFactory(SocketFactory.getDefault());
    Internal.instance.setNetwork(httpClient, Network.DEFAULT);
}
 

public MattermostService(Context context) {
    this.context = context;
    String userAgent = context.getResources().getString(R.string.app_user_agent);

    cookieStore = new WebkitCookieManagerProxy();

    client.setProtocols(Arrays.asList(Protocol.HTTP_1_1));
    client.setCookieHandler(cookieStore);
    preferences = context.getSharedPreferences("App", Context.MODE_PRIVATE);
}
 

@Test
public void shouldNotUseHttp2Protocol() {
    OkHttpClient client = factory.createClient(false, false, 0, 0, 0);
    //Doesn't use default protocols
    assertThat(client.getProtocols(), is(notNullValue()));
    assertThat(client.getProtocols().contains(Protocol.HTTP_1_1), is(true));
    assertThat(client.getProtocols().contains(Protocol.SPDY_3), is(true));
    assertThat(client.getProtocols().contains(Protocol.HTTP_2), is(false));
}
 

private Response createJsonResponse(String jsonPayload, int code) {
    Request request = new Request.Builder()
            .url("https://someurl.com")
            .build();

    final ResponseBody responseBody = ResponseBody.create(MediaType.parse("application/json; charset=utf-8"), jsonPayload);
    return new Response.Builder()
            .request(request)
            .protocol(Protocol.HTTP_1_1)
            .body(responseBody)
            .code(code)
            .build();
}
 

private Response createBytesResponse(byte[] content, int code) {
    Request request = new Request.Builder()
            .url("https://someurl.com")
            .build();

    final ResponseBody responseBody = ResponseBody.create(MediaType.parse("application/octet-stream; charset=utf-8"), content);
    return new Response.Builder()
            .request(request)
            .protocol(Protocol.HTTP_1_1)
            .body(responseBody)
            .code(code)
            .build();
}
 

private static ProtocolVersion parseProtocol(final Protocol p) {
    switch (p) {
        case HTTP_1_0:
            return new ProtocolVersion("HTTP", 1, 0);
        case HTTP_1_1:
            return new ProtocolVersion("HTTP", 1, 1);
        case SPDY_3:
            return new ProtocolVersion("SPDY", 3, 1);
        case HTTP_2:
            return new ProtocolVersion("HTTP", 2, 0);
    }

    throw new IllegalAccessError("Unkwown protocol");
}
 

private static ProtocolVersion parseProtocol(final Protocol protocol) {
  switch (protocol) {
    case HTTP_1_0:
      return new ProtocolVersion("HTTP", 1, 0);
    case HTTP_1_1:
      return new ProtocolVersion("HTTP", 1, 1);
    case SPDY_3:
      return new ProtocolVersion("SPDY", 3, 1);
    case HTTP_2:
      return new ProtocolVersion("HTTP", 2, 0);
    default:
      throw new IllegalAccessError("Unkwown protocol");
  }
}
 

public HttpProtocolSender(final UPID sender)
{
    this.client = new OkHttpClient();
    client.setProtocols(ImmutableList.of(Protocol.HTTP_1_1));

    this.sender = sender.asString();
}
 

private static ProtocolVersion parseProtocol(final Protocol p) {
    switch (p) {
        case HTTP_1_0:
            return new ProtocolVersion("HTTP", 1, 0);
        case HTTP_1_1:
            return new ProtocolVersion("HTTP", 1, 1);
        case SPDY_3:
            return new ProtocolVersion("SPDY", 3, 1);
        case HTTP_2:
            return new ProtocolVersion("HTTP", 2, 0);
    }

    throw new IllegalAccessError("Unkwown protocol");
}
 

private void setProtocols(String protocolsString, boolean append) {
  List<Protocol> protocolsList = new ArrayList<>();
  if (append) {
    protocolsList.addAll(client.getProtocols());
  }
  for (String protocol : protocolsString.split(",", -1)) {
    try {
      protocolsList.add(Protocol.get(protocol));
    } catch (IOException e) {
      throw new IllegalStateException(e);
    }
  }
  client.setProtocols(protocolsList);
}
 

@Test
public void testHappyPath() throws IOException {
  InOrder inOrder = Mockito.inOrder(mMockEventReporter);
  hookAlmostRealRequestWillBeSent(mMockEventReporter);
  ByteArrayOutputStream capturedOutput =
      hookAlmostRealInterpretResponseStream(mMockEventReporter);

  Uri requestUri = Uri.parse("http://www.facebook.com/nowhere");
  String requestText = "Test input";
  Request request = new Request.Builder()
      .url(requestUri.toString())
      .method(
          "POST",
          RequestBody.create(MediaType.parse("text/plain"), requestText))
      .build();
  String originalBodyData = "Success!";
  Response reply = new Response.Builder()
      .request(request)
      .protocol(Protocol.HTTP_1_1)
      .code(200)
      .body(ResponseBody.create(MediaType.parse("text/plain"), originalBodyData))
      .build();
  Response filteredResponse =
      mInterceptor.intercept(
          new SimpleTestChain(request, reply, mock(Connection.class)));

  inOrder.verify(mMockEventReporter).isEnabled();
  inOrder.verify(mMockEventReporter)
      .requestWillBeSent(any(NetworkEventReporter.InspectorRequest.class));
  inOrder.verify(mMockEventReporter)
      .dataSent(
          anyString(),
          eq(requestText.length()),
          eq(requestText.length()));
  inOrder.verify(mMockEventReporter)
      .responseHeadersReceived(any(NetworkEventReporter.InspectorResponse.class));

  String filteredResponseString = filteredResponse.body().string();
  String interceptedOutput = capturedOutput.toString();

  inOrder.verify(mMockEventReporter).dataReceived(anyString(), anyInt(), anyInt());
  inOrder.verify(mMockEventReporter).responseReadFinished(anyString());

  assertEquals(originalBodyData, filteredResponseString);
  assertEquals(originalBodyData, interceptedOutput);

  inOrder.verifyNoMoreInteractions();
}
 

private Response fakeResponse(int code) {
  Request fakeRequest = new Request.Builder().url("http://host/url").build();
  return new Response.Builder().protocol(Protocol.HTTP_2).request(fakeRequest).code(code).build();
}