Refactor Plivo Client and PHLORestClient

src/main/java/com/plivo/api/Client.java

@@ -0,0 +1,225 @@
+package com.plivo.api;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.BeanDescription;
+import com.fasterxml.jackson.databind.DeserializationConfig;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.PropertyNamingStrategy;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import com.plivo.api.util.Utils;
+import okhttp3.Credentials;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Protocol;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okhttp3.logging.HttpLoggingInterceptor;
+import okhttp3.logging.HttpLoggingInterceptor.Level;
+import retrofit2.Retrofit;
+import retrofit2.converter.jackson.JacksonConverterFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.ProtocolException;
+import java.text.SimpleDateFormat;
+
+public class Client {
+
+  private static SimpleModule simpleModule = new SimpleModule();
+  private static String version = "Unknown Version";
+  private boolean testing = false;
+  private static ObjectMapper objectMapper = new ObjectMapper();
+
+  public void setTesting(boolean testing) {
+    this.testing = testing;
+  }
+
+  public boolean isTesting() {
+    return testing;
+  }
+
+  static {
+    simpleModule.setDeserializerModifier(new BeanDeserializerModifier() {
+      @Override
+      public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config, JavaType type,
+                                                        BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
+        return new JsonDeserializer<Enum>() {
+          @Override
+          public Enum deserialize(JsonParser jp, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException {
+            Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
+            return Enum.valueOf(rawClass, jp.getValueAsString().toUpperCase().replace("-", "_"));
+          }
+        };
+      }
+    });
+    simpleModule.addSerializer(Enum.class, new StdSerializer<Enum>(Enum.class) {
+      @Override
+      public void serialize(Enum value, JsonGenerator gen, SerializerProvider provider)
+        throws IOException {
+        gen.writeString(value.name().toLowerCase().replace("_", "-"));
+      }
+    });
+  }
+
+  {
+    try {
+      InputStream inputStream = Client.class
+        .getResource("version.txt")
+        .openStream();
+
+      version = new BufferedReader(new InputStreamReader(inputStream)).readLine();
+    } catch (IOException ignored) {
+      ignored.printStackTrace();
+    }
+    objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+    objectMapper.disable(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS);
+    objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
+    objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
+  }
+
+  private final Interceptor interceptor = new HttpLoggingInterceptor()
+    .setLevel(Level.BODY);
+  private final String authId;
+  private final String authToken;
+  private OkHttpClient httpClient;
+  private Retrofit retrofit;
+  private PlivoAPIService apiService = null;
+
+  /**
+   * Constructs a new PlivoClient instance. To set a proxy, timeout etc, you can pass in an OkHttpClient.Builder, on which you can set
+   * the timeout and proxy using:
+   *
+   * <pre><code>
+   *   new OkHttpClient.Builder()
+   *   .proxy(proxy)
+   *   .connectTimeout(1, TimeUnit.MINUTES);
+   * </code></pre>
+   *
+   * @param authId
+   * @param authToken
+   * @param httpClientBuilder
+   * @param baseUrl
+   * @param simpleModule
+   */
+  public Client(String authId, String authToken, OkHttpClient.Builder httpClientBuilder, final String baseUrl, final SimpleModule simpleModule) {
+    if (!(Utils.isAccountIdValid(authId) || Utils.isSubaccountIdValid(authId))) {
+      throw new IllegalArgumentException("invalid account ID");
+    }
+
+    this.authId = authId;
+    this.authToken = authToken;
+    this.objectMapper.registerModule(simpleModule);
+
+    httpClient = httpClientBuilder
+      .addNetworkInterceptor(interceptor)
+      .addInterceptor(chain -> chain.proceed(
+        chain.request()
+          .newBuilder()
+          .addHeader("Authorization", Credentials.basic(getAuthId(), getAuthToken()))
+          .addHeader("User-Agent", String.format("%s/%s (Implementation: %s %s %s, Specification: %s %s %s)", "plivo-java", version,
+            Runtime.class.getPackage().getImplementationVendor(),
+            Runtime.class.getPackage().getImplementationTitle(),
+            Runtime.class.getPackage().getImplementationVersion(),
+            Runtime.class.getPackage().getSpecificationVendor(),
+            Runtime.class.getPackage().getSpecificationTitle(),
+            Runtime.class.getPackage().getSpecificationVersion()
+          ))
+          .build()
+      ))
+      .addNetworkInterceptor(chain -> {
+        Response response;
+        try {
+          response = chain.proceed(chain.request());
+        } catch (ProtocolException protocolException) {
+          // We return bodies for HTTP 204!
+          response = new Response.Builder()
+            .request(chain.request())
+            .code(204)
+            .protocol(Protocol.HTTP_1_1)
+            .body(ResponseBody.create(null, new byte[]{}))
+            .build();
+        }
+        return response;
+      }).build();
+
+    retrofit = new Retrofit.Builder()
+      .client(httpClient)
+      .baseUrl(baseUrl)
+      .addConverterFactory(JacksonConverterFactory.create(objectMapper))
+      .build();
+
+    this.apiService = retrofit.create(PlivoAPIService.class);
+  }
+
+  /**
+   * Constructs a new PlivoClient instance. To set a proxy, timeout etc, you can pass in an OkHttpClient.Builder, on which you can set
+   * the timeout and proxy using:
+   *
+   * <pre><code>
+   *   new OkHttpClient.Builder()
+   *   .proxy(proxy)
+   *   .connectTimeout(1, TimeUnit.MINUTES);
+   * </code></pre>
+   *
+   * @param authId
+   * @param authToken
+   */
+  public Client(String authId, String authToken,  final String baseUrl) {
+    this(authId, authToken, new OkHttpClient.Builder(), baseUrl, simpleModule);
+  }
+
+  /**
+   * Constructs a new PlivoClient instance. To set a proxy, timeout etc, you can pass in an OkHttpClient.Builder, on which you can set
+   * the timeout and proxy using:
+   *
+   * <pre><code>
+   *   new OkHttpClient.Builder()
+   *   .proxy(proxy)
+   *   .connectTimeout(1, TimeUnit.MINUTES);
+   * </code></pre>
+   *
+   * @param authId
+   * @param authToken
+   * @param httpClientBuilder
+   */
+  public Client(String authId, String authToken, OkHttpClient.Builder httpClientBuilder,  final String baseUrl) {
+    this(authId, authToken, httpClientBuilder, baseUrl, simpleModule);
+  }
+
+  public static ObjectMapper getObjectMapper() {
+    return objectMapper;
+  }
+
+  Retrofit getRetrofit() {
+    return retrofit;
+  }
+
+  public PlivoAPIService getApiService() {
+    return apiService;
+  }
+
+  void setApiService(PlivoAPIService apiService) {
+    this.apiService = apiService;
+  }
+
+  public String getAuthId() {
+    return authId;
+  }
+
+  public String getAuthToken() {
+    return authToken;
+  }
+}

src/main/java/com/plivo/api/PhloRestClient.java → src/main/java/com/plivo/api/PhloClient.java

@@ -12,15 +12,16 @@
 import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+
 import okhttp3.OkHttpClient;
 
 import java.io.IOException;
 
-public class PhloRestClient {
+public class PhloClient {
 
   protected static String BASE_URL = "https://phlorunner.plivo.com/v1/";
   private SimpleModule simpleModule = new SimpleModule();
-  private final PlivoClient client;
+  private final Client client;
 
   {
     simpleModule.setDeserializerModifier(new BeanDeserializerModifier() {
@@ -46,15 +47,15 @@ public void serialize(Enum value, JsonGenerator gen, SerializerProvider provider
     });
   }
 
-  public PhloRestClient(String authId, String authToken) {
-    this.client = new PlivoClient(authId, authToken, new OkHttpClient.Builder(), BASE_URL, simpleModule);
+  public PhloClient(String authId, String authToken) {
+    this.client = new Client(authId, authToken, new OkHttpClient.Builder(), BASE_URL, simpleModule);
   }
 
-  public PhloRestClient(String authId, String authToken, OkHttpClient.Builder httpClientBuilder) {
-    this.client = new PlivoClient(authId, authToken, httpClientBuilder, BASE_URL, simpleModule);
+  public PhloClient(String authId, String authToken, OkHttpClient.Builder httpClientBuilder) {
+    this.client = new Client(authId, authToken, httpClientBuilder, BASE_URL, simpleModule);
   }
 
-  public PlivoClient getClient() {
+  public Client getClient() {
     return client;
   }
 }

src/main/java/com/plivo/api/Plivo.java

@@ -2,30 +2,30 @@
 
 public class Plivo {
 
-  private static PlivoClient plivoInstance = null;
-  private static PlivoClient phloInstance = null;
+  private static Client plivoInstance = null;
+  private static Client phloInstance = null;
 
   /**
-   * Initializes the global {@link PlivoClient} plivoInstance
+   * Initializes the global {@link Client} plivoInstance
    */
   public static synchronized void init(String authId, String authToken) {
-    plivoInstance = new PlivoClient(authId, authToken);
-    phloInstance = new PhloRestClient(authId, authToken).getClient();
+    plivoInstance = new PlivoClient(authId, authToken).getClient();
+    phloInstance = new PhloClient(authId, authToken).getClient();
   }
 
   /**
-   * Initializes the global {@link PlivoClient} plivoInstance, taking the authId and authToken from
+   * Initializes the global {@link Client} plivoInstance, taking the authId and authToken from
    * environment variables called PLIVO_AUTH_ID and PLIVO_AUTH_TOKEN.
    */
   public static synchronized void init() {
     init(System.getenv("PLIVO_AUTH_ID"), System.getenv("PLIVO_AUTH_TOKEN"));
   }
 
-  public static PlivoClient getClient() {
+  public static Client getClient() {
     return plivoInstance;
   }
 
-  public static PlivoClient getPhloClient() {
+  public static Client getPhloClient() {
     return phloInstance;
   }
 }