clean up tryConnect function

owncloudComLibrary/src/main/java/com/owncloud/android/lib/resources/status/GetRemoteStatusOperation.kt

@@ -75,81 +75,98 @@ class GetRemoteStatusOperation : RemoteOperation<OwnCloudVersion>() {
         return URL(oldLocation.protocol, oldLocation.host, oldLocation.port, redirectedLocation).toString()
     }
 
-    private fun tryConnection(client: OwnCloudClient): Boolean {
+    private fun checkIfConnectionIsRedirectedToNoneSecure(
-        var successfulConnection = false
+        isConnectionSecure: Boolean,
-        val baseUrlStr = client.baseUri.toString()
+        baseUrl: String,
-        try {
+        redirectedUrl: String
-            var getMethod = GetMethod(URL(baseUrlStr + OwnCloudClient.STATUS_PATH)).apply {
+    ): Boolean {
+        return isConnectionSecure ||
+                (baseUrl.startsWith(HTTPS_PREFIX) && redirectedUrl.startsWith(HTTP_PREFIX))
+    }
+
+    private fun getGetMethod(url: String): GetMethod {
+        return GetMethod(URL(url + OwnCloudClient.STATUS_PATH)).apply {
             setReadTimeout(TRY_CONNECTION_TIMEOUT, TimeUnit.SECONDS)
             setConnectionTimeout(TRY_CONNECTION_TIMEOUT, TimeUnit.SECONDS)
         }
-            client.setFollowRedirects(false)
+    }
-            var isRedirectToNonSecureConnection = false
+
+    data class RequestResult(
+        val getMethod: GetMethod,
+        val status: Int,
+        val result: RemoteOperationResult<OwnCloudVersion>,
+        val redirectedToUnsecureLocation: Boolean
+    )
+
+    fun requestAndFollowRedirects(baseLocation: String): RequestResult {
+        var currentLocation = baseLocation
+        var redirectedToUnsecureLocation = false
         var status: Int
-            try {
+
+        while (true) {
+            val getMethod = getGetMethod(currentLocation)
+
             status = client.executeHttpMethod(getMethod)
-                latestResult =
+            val result =
-                    if (isSuccess(status)) RemoteOperationResult(ResultCode.OK)
+                if (isSuccess(status)) RemoteOperationResult<OwnCloudVersion>(ResultCode.OK)
                 else RemoteOperationResult(getMethod)
 
-            } catch (sslE: SSLException) {
+            if (result.redirectedLocation.isNullOrEmpty() || result.isSuccess) {
-                latestResult = RemoteOperationResult(sslE)
+                return RequestResult(getMethod, status, result, redirectedToUnsecureLocation)
-                return successfulConnection
-            }
-
-            var redirectedLocation = updateLocationWithRedirectPath(baseUrlStr, latestResult.redirectedLocation)
-            while (!redirectedLocation.isNullOrEmpty() && !latestResult.isSuccess) {
-                isRedirectToNonSecureConnection =
-                    isRedirectToNonSecureConnection ||
-                            (baseUrlStr.startsWith(HTTPS_PREFIX) && redirectedLocation.startsWith(
-                                HTTP_PREFIX
-                            ))
-
-                getMethod = GetMethod(URL(redirectedLocation)).apply {
-                    setReadTimeout(TRY_CONNECTION_TIMEOUT, TimeUnit.SECONDS)
-                    setConnectionTimeout(TRY_CONNECTION_TIMEOUT, TimeUnit.SECONDS)
-                }
-
-                status = client.executeHttpMethod(getMethod)
-                latestResult = RemoteOperationResult(getMethod)
-                redirectedLocation = updateLocationWithRedirectPath(redirectedLocation, latestResult.redirectedLocation)
-            }
-
-            if (isSuccess(status)) {
-                val respJSON = JSONObject(getMethod.getResponseBodyAsString())
-                if (!respJSON.getBoolean(NODE_INSTALLED)) {
-                    latestResult = RemoteOperationResult(ResultCode.INSTANCE_NOT_CONFIGURED)
             } else {
+                val nextLocation = updateLocationWithRedirectPath(currentLocation, result.redirectedLocation)
+                redirectedToUnsecureLocation =
+                    checkIfConnectionIsRedirectedToNoneSecure(
+                        redirectedToUnsecureLocation,
+                        currentLocation,
+                        nextLocation
+                    )
+                currentLocation = nextLocation
+            }
+        }
+    }
+
+    private fun handleRequestResult(requestResult: RequestResult, baseUrl: String): RemoteOperationResult<OwnCloudVersion> {
+        if (!isSuccess(requestResult.status))
+            return RemoteOperationResult(requestResult.getMethod)
+
+        val respJSON = JSONObject(requestResult.getMethod.getResponseBodyAsString())
+        if (!respJSON.getBoolean(NODE_INSTALLED))
+            return RemoteOperationResult(ResultCode.INSTANCE_NOT_CONFIGURED)
+
         val version = respJSON.getString(NODE_VERSION)
         val ocVersion = OwnCloudVersion(version)
         // the version object will be returned even if the version is invalid, no error code;
         // every app will decide how to act if (ocVersion.isVersionValid() == false)
-                    latestResult = if (isRedirectToNonSecureConnection) {
+        val result =
-                        RemoteOperationResult(ResultCode.OK_REDIRECT_TO_NON_SECURE_CONNECTION)
+            if (requestResult.redirectedToUnsecureLocation) {
+                RemoteOperationResult<OwnCloudVersion>(ResultCode.OK_REDIRECT_TO_NON_SECURE_CONNECTION)
             } else {
-                        if (baseUrlStr.startsWith(HTTPS_PREFIX)) RemoteOperationResult(ResultCode.OK_SSL)
+                if (baseUrl.startsWith(HTTPS_PREFIX)) RemoteOperationResult(ResultCode.OK_SSL)
                 else RemoteOperationResult(ResultCode.OK_NO_SSL)
             }
-                    latestResult.data = ocVersion
+        result.data = ocVersion
-                    successfulConnection = true
+        return result
-                }
-            } else {
-                latestResult = RemoteOperationResult(getMethod)
     }
+
+    private fun tryConnection(client: OwnCloudClient): Boolean {
+        val baseUrl = client.baseUri.toString()
+        try {
+            client.setFollowRedirects(false)
+
+            val requestResult = requestAndFollowRedirects(baseUrl)
+            val operationResult = handleRequestResult(requestResult, baseUrl)
+            return operationResult.code == ResultCode.OK_SSL || operationResult.code == ResultCode.OK_NO_SSL
         } catch (e: JSONException) {
             latestResult = RemoteOperationResult(ResultCode.INSTANCE_NOT_CONFIGURED)
+            return false
         } catch (e: Exception) {
             latestResult = RemoteOperationResult(e)
+            return false
+        } catch (sslE: SSLException) {
+            latestResult = RemoteOperationResult(sslE)
+            return false
         }
-        when {
-            latestResult.isSuccess -> Timber.i("Connection check at $baseUrlStr successful: ${latestResult.logMessage}")
-
-            latestResult.isException ->
-                Timber.e(latestResult.exception, "Connection check at $baseUrlStr: ${latestResult.logMessage}")
-
-            else -> Timber.e("Connection check at $baseUrlStr failed: ${latestResult.logMessage}")
-        }
-        return successfulConnection
     }
 
     private fun isSuccess(status: Int): Boolean = status == HttpConstants.HTTP_OK