Remove Client, Request, Response, TypedInput, and TypedOutput abstractions.

Author: JakeWharton

retrofit-converters/jackson/src/main/java/retrofit/converter/JacksonConverter.java

@@ -3,21 +3,20 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.ResponseBody;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.UnsupportedEncodingException;
 import java.lang.reflect.Type;
-import retrofit.mime.TypedByteArray;
-import retrofit.mime.TypedInput;
-import retrofit.mime.TypedOutput;
 
 /**
  * A {@link Converter} which uses Jackson for reading and writing entities.
  *
  * @author Kai Waldron ([email protected])
  */
 public class JacksonConverter implements Converter {
-  private static final String MIME_TYPE = "application/json; charset=UTF-8";
+  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
 
   private final ObjectMapper objectMapper;
 
@@ -26,34 +25,30 @@ public JacksonConverter() {
   }
 
   public JacksonConverter(ObjectMapper objectMapper) {
+    if (objectMapper == null) throw new NullPointerException("objectMapper == null");
     this.objectMapper = objectMapper;
   }
 
-  @Override public Object fromBody(TypedInput body, Type type) throws IOException {
-    InputStream in = null;
+  @Override public Object fromBody(ResponseBody body, Type type) throws IOException {
+    InputStream is = body.byteStream();
     try {
       JavaType javaType = objectMapper.getTypeFactory().constructType(type);
-      in = body.in();
-      return objectMapper.readValue(in, javaType);
+      return objectMapper.readValue(is, javaType);
     } finally {
       try {
-        if (in != null) {
-          in.close();
-        }
+        is.close();
       } catch (IOException ignored) {
       }
     }
   }
 
-  @Override public TypedOutput toBody(Object object, Type type) {
+  @Override public RequestBody toBody(Object object, Type type) {
     try {
       JavaType javaType = objectMapper.getTypeFactory().constructType(type);
       String json = objectMapper.writerWithType(javaType).writeValueAsString(object);
-      return new TypedByteArray(MIME_TYPE, json.getBytes("UTF-8"));
+      return RequestBody.create(MEDIA_TYPE, json);
     } catch (JsonProcessingException e) {
-      throw new AssertionError(e);
-    } catch (UnsupportedEncodingException e) {
-      throw new AssertionError(e);
+      throw new RuntimeException(e);
     }
   }
 }

retrofit-converters/jackson/src/test/java/retrofit/converter/JacksonConverterTest.java

@@ -3,53 +3,55 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException;
-import java.io.ByteArrayOutputStream;
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.ResponseBody;
+import java.io.IOException;
+import okio.Buffer;
+import org.assertj.core.api.AbstractCharSequenceAssert;
 import org.junit.Test;
-import retrofit.mime.TypedByteArray;
-import retrofit.mime.TypedInput;
-import retrofit.mime.TypedOutput;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class JacksonConverterTest {
-  private static final String MIME_TYPE = "application/json; charset=UTF-8";
+  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
   private static final MyObject OBJECT = new MyObject("hello world", 10);
   private final String JSON = "{\"message\":\"hello world\",\"count\":10}";
 
   private final JacksonConverter converter = new JacksonConverter();
 
   @Test public void serialize() throws Exception {
-    TypedOutput typedOutput = converter.toBody(OBJECT, MyObject.class);
-    assertThat(typedOutput.mimeType()).isEqualTo(MIME_TYPE);
-    assertThat(asString(typedOutput)).isEqualTo(JSON);
+    RequestBody body = converter.toBody(OBJECT, MyObject.class);
+    assertThat(body.contentType()).isEqualTo(MEDIA_TYPE);
+    assertBody(body).isEqualTo(JSON);
   }
 
   @Test public void deserialize() throws Exception {
-    TypedInput input = new TypedByteArray(MIME_TYPE, JSON.getBytes());
-    MyObject result = (MyObject) converter.fromBody(input, MyObject.class);
+    ResponseBody body = ResponseBody.create(MEDIA_TYPE, JSON);
+    MyObject result = (MyObject) converter.fromBody(body, MyObject.class);
     assertThat(result).isEqualTo(OBJECT);
   }
 
   @Test public void deserializeWrongValue() throws Exception {
-    TypedInput input = new TypedByteArray(MIME_TYPE, "{\"foo\":\"bar\"}".getBytes());
+    ResponseBody body = ResponseBody.create(MEDIA_TYPE, "{\"foo\":\"bar\"}");
     try {
-      converter.fromBody(input, MyObject.class);
+      converter.fromBody(body, MyObject.class);
     } catch (UnrecognizedPropertyException ignored) {
     }
   }
 
   @Test public void deserializeWrongClass() throws Exception {
-    TypedInput input = new TypedByteArray(MIME_TYPE, JSON.getBytes());
+    ResponseBody body = ResponseBody.create(MEDIA_TYPE, JSON);
     try {
-      converter.fromBody(input, String.class);
+      converter.fromBody(body, String.class);
     } catch (JsonMappingException ignored) {
     }
   }
 
-  private String asString(TypedOutput typedOutput) throws Exception {
-    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-    typedOutput.writeTo(bytes);
-    return new String(bytes.toByteArray());
+  private static AbstractCharSequenceAssert<?, String> assertBody(RequestBody body) throws IOException {
+    Buffer buffer = new Buffer();
+    body.writeTo(buffer);
+    return assertThat(buffer.readUtf8());
   }
 
   static class MyObject {

retrofit-converters/protobuf/src/main/java/retrofit/converter/ProtoConverter.java

@@ -2,20 +2,20 @@
 package retrofit.converter;
 
 import com.google.protobuf.AbstractMessageLite;
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.ResponseBody;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
-import retrofit.mime.TypedByteArray;
-import retrofit.mime.TypedInput;
-import retrofit.mime.TypedOutput;
 
 /** A {@link Converter} that reads and writes protocol buffers. */
 public class ProtoConverter implements Converter {
-  private static final String MIME_TYPE = "application/x-protobuf";
+  private static final MediaType MEDIA_TYPE = MediaType.parse("application/x-protobuf");
 
-  @Override public Object fromBody(TypedInput body, Type type) throws IOException {
+  @Override public Object fromBody(ResponseBody body, Type type) throws IOException {
     if (!(type instanceof Class<?>)) {
       throw new IllegalArgumentException("Expected a raw Class<?> but was " + type);
     }
@@ -24,30 +24,31 @@ public class ProtoConverter implements Converter {
       throw new IllegalArgumentException("Expected a protobuf message but was " + c.getName());
     }
 
-    String mimeType = body.mimeType();
-    if (!MIME_TYPE.equals(mimeType)) {
-      throw new RuntimeException("Response content type was not a proto: " + mimeType);
-    }
-
+    InputStream is = body.byteStream();
     try {
       Method parseFrom = c.getMethod("parseFrom", InputStream.class);
-      return parseFrom.invoke(null, body.in());
+      return parseFrom.invoke(null, is);
     } catch (InvocationTargetException e) {
       throw new RuntimeException(c.getName() + ".parseFrom() failed", e.getCause());
     } catch (NoSuchMethodException e) {
       throw new IllegalArgumentException("Expected a protobuf message but was " + c.getName());
     } catch (IllegalAccessException e) {
       throw new AssertionError();
+    } finally {
+      try {
+        is.close();
+      } catch (IOException ignored) {
+      }
     }
   }
 
-  @Override public TypedOutput toBody(Object object, Type type) {
+  @Override public RequestBody toBody(Object object, Type type) {
     if (!(object instanceof AbstractMessageLite)) {
       throw new IllegalArgumentException(
           "Expected a protobuf message but was " + (object != null ? object.getClass().getName()
               : "null"));
     }
     byte[] bytes = ((AbstractMessageLite) object).toByteArray();
-    return new TypedByteArray(MIME_TYPE, bytes);
+    return RequestBody.create(MEDIA_TYPE, bytes);
   }
 }

retrofit-converters/protobuf/src/test/java/retrofit/converter/ProtoConverterTest.java

@@ -1,15 +1,16 @@
 // Copyright 2013 Square, Inc.
 package retrofit.converter;
 
-import com.google.common.io.BaseEncoding;
 import com.google.protobuf.InvalidProtocolBufferException;
-import java.io.ByteArrayOutputStream;
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.ResponseBody;
 import java.io.IOException;
-import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
+import okio.Buffer;
+import okio.ByteString;
+import org.assertj.core.api.AbstractCharSequenceAssert;
 import org.junit.Test;
-import retrofit.mime.TypedByteArray;
-import retrofit.mime.TypedOutput;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
@@ -19,22 +20,22 @@ public final class ProtoConverterTest {
   private static final Phone PROTO = Phone.newBuilder().setNumber("(519) 867-5309").build();
   private static final String ENCODED_PROTO = "Cg4oNTE5KSA4NjctNTMwOQ==";
 
-  private final ProtoConverter protoConverter = new ProtoConverter();
+  private final ProtoConverter converter = new ProtoConverter();
 
   @Test public void serialize() throws Exception {
-    TypedOutput protoBytes = protoConverter.toBody(PROTO, Phone.class);
-    assertThat(protoBytes.mimeType()).isEqualTo("application/x-protobuf");
-    assertThat(bytesOf(protoBytes)).isEqualTo(bytesOf(decodeBase64(ENCODED_PROTO)));
+    RequestBody body = converter.toBody(PROTO, Phone.class);
+    assertThat(body.contentType().toString()).isEqualTo("application/x-protobuf");
+    assertBody(body).isEqualTo(ENCODED_PROTO);
   }
 
   @Test public void deserialize() throws Exception {
-    Object proto = protoConverter.fromBody(decodeBase64(ENCODED_PROTO), Phone.class);
+    Object proto = converter.fromBody(protoResponse(ENCODED_PROTO), Phone.class);
     assertThat(proto).isEqualTo(PROTO);
   }
 
   @Test public void deserializeWrongClass() throws Exception {
     try {
-      protoConverter.fromBody(decodeBase64(ENCODED_PROTO), String.class);
+      converter.fromBody(protoResponse(ENCODED_PROTO), String.class);
       fail();
     } catch (IllegalArgumentException e) {
       assertThat(e).hasMessage("Expected a protobuf message but was java.lang.String");
@@ -43,7 +44,7 @@ public final class ProtoConverterTest {
 
   @Test public void deserializeWrongType() throws Exception {
     try {
-      protoConverter.fromBody(decodeBase64(ENCODED_PROTO), ArrayList.class.getGenericSuperclass());
+      converter.fromBody(protoResponse(ENCODED_PROTO), ArrayList.class.getGenericSuperclass());
       fail();
     } catch (IllegalArgumentException e) {
       assertThat(e).hasMessage("Expected a raw Class<?> but was java.util.AbstractList<E>");
@@ -52,33 +53,21 @@ public final class ProtoConverterTest {
 
   @Test public void deserializeWrongValue() throws Exception {
     try {
-      protoConverter.fromBody(decodeBase64("////"), Phone.class);
+      converter.fromBody(protoResponse("////"), Phone.class);
       fail();
     } catch (RuntimeException expected) {
       assertThat(expected.getCause() instanceof InvalidProtocolBufferException);
     }
   }
 
-  @Test public void deserializeWrongMime() throws Exception {
-    try {
-      protoConverter.fromBody(decodeBase64("////", "yummy/bytes"), Phone.class);
-      fail();
-    } catch (RuntimeException e) {
-      assertThat(e).hasMessage("Response content type was not a proto: yummy/bytes");
-    }
-  }
-
-  private static byte[] bytesOf(TypedOutput protoBytes) throws IOException {
-    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-    protoBytes.writeTo(bytes);
-    return bytes.toByteArray();
-  }
-
-  private static TypedByteArray decodeBase64(String base64) throws UnsupportedEncodingException {
-    return decodeBase64(base64, "application/x-protobuf");
+  private static ResponseBody protoResponse(String encodedProto) {
+    return ResponseBody.create(MediaType.parse("application/x-protobuf"), ByteString.decodeBase64(
+        encodedProto).toByteArray());
   }
 
-  private static TypedByteArray decodeBase64(String base64, String mime) throws UnsupportedEncodingException {
-    return new TypedByteArray(mime, BaseEncoding.base64().decode(base64));
+  private static AbstractCharSequenceAssert<?, String> assertBody(RequestBody body) throws IOException {
+    Buffer buffer = new Buffer();
+    body.writeTo(buffer);
+    return assertThat(buffer.readByteString().base64());
   }
 }

retrofit-converters/simplexml/src/main/java/retrofit/converter/SimpleXMLConverter.java

@@ -1,16 +1,15 @@
 package retrofit.converter;
 
-import java.io.ByteArrayOutputStream;
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.ResponseBody;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.lang.reflect.Type;
-
-import org.simpleframework.xml.core.Persister;
+import okio.Buffer;
 import org.simpleframework.xml.Serializer;
-
-import retrofit.mime.TypedByteArray;
-import retrofit.mime.TypedInput;
-import retrofit.mime.TypedOutput;
+import org.simpleframework.xml.core.Persister;
 
 /**
  * A {@link Converter} which uses SimpleXML for reading and writing entities.
@@ -20,7 +19,8 @@
 public class SimpleXMLConverter implements Converter {
   private static final boolean DEFAULT_STRICT = true;
   private static final String CHARSET = "UTF-8";
-  private static final String MIME_TYPE = "application/xml; charset=" + CHARSET;
+  private static final MediaType MEDIA_TYPE =
+      MediaType.parse("application/xml; charset=" + CHARSET);
 
   private final Serializer serializer;
 
@@ -43,35 +43,34 @@ public SimpleXMLConverter(Serializer serializer, boolean strict) {
     this.strict = strict;
   }
 
-  @Override public Object fromBody(TypedInput body, Type type) throws IOException {
+  @Override public Object fromBody(ResponseBody body, Type type) throws IOException {
+    InputStream is = body.byteStream();
     try {
-      return serializer.read((Class<?>) type, body.in(), strict);
+      return serializer.read((Class<?>) type, is, strict);
     } catch (IOException e) {
       throw e;
     } catch (Exception e) {
       throw new RuntimeException(e);
+    } finally {
+      try {
+        is.close();
+      } catch (IOException ignored) {
+      }
     }
   }
 
-  @Override public TypedOutput toBody(Object source, Type type) {
-    OutputStreamWriter osw = null;
-
+  @Override public RequestBody toBody(Object source, Type type) {
+    byte[] bytes;
     try {
-      ByteArrayOutputStream bos = new ByteArrayOutputStream();
-      osw = new OutputStreamWriter(bos, CHARSET);
+      Buffer buffer = new Buffer();
+      OutputStreamWriter osw = new OutputStreamWriter(buffer.outputStream(), CHARSET);
       serializer.write(source, osw);
       osw.flush();
-      return new TypedByteArray(MIME_TYPE, bos.toByteArray());
+      bytes = buffer.readByteArray();
     } catch (Exception e) {
       throw new AssertionError(e);
-    } finally {
-      try {
-        if (osw != null) {
-          osw.close();
-        }
-      } catch (IOException ignored) {
-      }
     }
+    return RequestBody.create(MEDIA_TYPE, bytes);
   }
 
   public boolean isStrict() {