Improve error reporting by including optional error message

Author: Ian Bird

sdk/src/main/java/com/uid2/UID2Client.kt

@@ -111,8 +111,8 @@ internal class UID2Client(
         // Attempt to make the request via the provided NetworkSession.
         val response = session.loadData(url, request)
         if (response.code != HttpURLConnection.HTTP_OK) {
-            logger.e(TAG) { "Client details failure: ${response.code}" }
-            throw RequestFailureException(response.code)
+            logger.e(TAG) { "Client details failure: ${response.code} ${response.data}" }
+            throw RequestFailureException(response.code, response.data)
         }
 
         // The response should be an encrypted payload. Let's attempt to decrypt it using the key we were provided.

sdk/src/main/java/com/uid2/UID2Exception.kt

@@ -28,7 +28,7 @@ public class InputValidationException(description: String?) : UID2Exception(desc
 /**
  * An attempt was made to the API that resulted in a failure.
  */
-internal class RequestFailureException(val statusCode: Int) : UID2Exception()
+internal class RequestFailureException(val statusCode: Int, message: String? = null) : UID2Exception(message)
 
 /**
  * The encrypted payload could not be decrypted successfully.

sdk/src/main/java/com/uid2/network/DefaultNetworkSession.kt

@@ -1,5 +1,6 @@
 package com.uid2.network
 
+import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
 
@@ -16,35 +17,46 @@ public open class DefaultNetworkSession : NetworkSession {
      * Loads the given [URL] and [NetworkRequest] using [HttpURLConnection].
      */
     override fun loadData(url: URL, request: NetworkRequest): NetworkResponse {
-        val connection = openConnection(url).apply {
-            requestMethod = request.type.toRequestMethod()
+        try {
+            val connection = openConnection(url).apply {
+                requestMethod = request.type.toRequestMethod()
 
-            setRequestProperty("Accept", "application/json")
+                setRequestProperty("Accept", "application/json")
 
-            // If we've been given any request headers, add them to the request.
-            request.headers.forEach {
-                addRequestProperty(it.key, it.value)
-            }
+                // If we've been given any request headers, add them to the request.
+                request.headers.forEach {
+                    addRequestProperty(it.key, it.value)
+                }
 
-            // If data was provided, this will require us to write it to the output stream.
-            request.data?.let { data ->
-                doOutput = true
+                // If data was provided, this will require us to write it to the output stream.
+                request.data?.let { data ->
+                    doOutput = true
 
-                outputStream.use { outputStream ->
-                    outputStream.write(data.toByteArray(Charsets.UTF_8))
+                    outputStream.use { outputStream ->
+                        outputStream.write(data.toByteArray(Charsets.UTF_8))
+                    }
                 }
             }
-        }
 
-        // A successful response code should be in the [200-299] range.
-        val responseCode = connection.responseCode
-        if (responseCode !in SUCCESS_CODE_RANGE_MIN..SUCCESS_CODE_RANGE_MAX) {
-            return NetworkResponse(responseCode)
-        }
+            // A successful response code should be in the [200-299] range. If we receive something outside that range, then
+            // we should be reading from the errorStream rather than the standard inputStream.
+            val responseCode = connection.responseCode
+            val responseStream = if (NetworkSession.isSuccess(responseCode)) {
+                connection.inputStream
+            } else {
+                connection.errorStream
+            }
 
-        // We expect the response to be a String.
-        val responseText = connection.inputStream.bufferedReader().use { it.readText() }
-        return NetworkResponse(responseCode, responseText)
+            // We expect the response to be a String.
+            val responseText = runCatching {
+                responseStream.bufferedReader().use { it.readText() }
+            }.getOrDefault("")
+            return NetworkResponse(responseCode, responseText)
+        } catch (ex: IOException) {
+            // If we're unable to make a request, e.g. due to lack of connection, we will simply report an internal
+            // error.
+            return NetworkResponse(HttpURLConnection.HTTP_INTERNAL_ERROR)
+        }
     }
 
     /**
@@ -62,9 +74,4 @@ public open class DefaultNetworkSession : NetworkSession {
         NetworkRequestType.GET -> "GET"
         NetworkRequestType.POST -> "POST"
     }
-
-    private companion object {
-        const val SUCCESS_CODE_RANGE_MIN = HttpURLConnection.HTTP_OK
-        const val SUCCESS_CODE_RANGE_MAX = 299
-    }
 }

sdk/src/main/java/com/uid2/network/NetworkSession.kt

@@ -57,4 +57,16 @@ public interface NetworkSession {
      * @return The [NetworkResponse] which contains the outcome of the attempted request.
      */
     public fun loadData(url: URL, request: NetworkRequest): NetworkResponse
+
+    public companion object {
+        private const val SUCCESS_CODE_RANGE_MIN = 200
+        private const val SUCCESS_CODE_RANGE_MAX = 299
+
+        /**
+         * Function to determine if a given response code is considered a "success".
+         */
+        @JvmStatic
+        public fun isSuccess(responseCode: Int): Boolean =
+            responseCode in SUCCESS_CODE_RANGE_MIN..SUCCESS_CODE_RANGE_MAX
+    }
 }