better file structure

Signed-off-by: alperozturk96 <alper_ozturk@proton.me>

Author: alperozturk96

app/src/main/java/com/nextcloud/client/network/ConnectivityServiceImpl.kt

@@ -36,11 +36,15 @@ class ConnectivityServiceImpl(
     private val walledCheckCache: WalledCheckCache
 ) : ConnectivityService {
 
-    private val scope = CoroutineScope(Dispatchers.IO)
+    companion object {
+        private const val TAG = "ConnectivityServiceImpl"
+        private const val CONNECTIVITY_CHECK_ROUTE = "/index.php/204"
+    }
 
+    // region private values
+    private val scope = CoroutineScope(Dispatchers.IO)
     private var availabilityCheckJob: Job? = null
     private var notifyJob: Job? = null
-
     private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
     private val listeners = mutableSetOf<NetworkChangeListener>()
 
@@ -50,52 +54,92 @@ class ConnectivityServiceImpl(
     private val key: ConnectivityKey
         get() = ConnectivityKey.getBy(accountManager)
 
-    override fun addListener(listener: NetworkChangeListener) {
-        listeners.add(listener)
-    }
+    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
+        override fun onLost(network: Network) {
+            Log_OC.w(TAG, "connection lost")
+            updateConnectivity()
+        }
 
-    override fun removeListener(listener: NetworkChangeListener) {
-        listeners.remove(listener)
+        override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+            Log_OC.d(TAG, "capability changed")
+            updateConnectivity()
+        }
     }
+    // endregion
 
-    private fun notifyListeners() {
-        if (listeners.isEmpty()) {
-            return
-        }
+    init {
+        connectivityManager.registerDefaultNetworkCallback(networkCallback)
+        updateConnectivity()
+        Log_OC.d(TAG, "connectivity service constructed")
+    }
 
-        notifyJob?.cancel()
-        notifyJob = scope.launch {
+    // region overridden methods
+    override fun isNetworkAndServerAvailable(callback: GenericCallback<Boolean>) {
+        availabilityCheckJob?.cancel()
+        availabilityCheckJob = scope.launch {
             val available = !isInternetWalled()
+            Log_OC.d(TAG, "isNetworkAndServerAvailable: $available")
             withContext(Dispatchers.Main) {
-                listeners.forEach {
-                    it.networkAndServerConnectionListener(available)
-                }
+                callback.onComplete(available)
             }
         }
     }
 
-    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
-        override fun onLost(network: Network) {
-            Log_OC.w(TAG, "connection lost")
-            updateConnectivity()
+    override fun isConnected() = currentConnectivity.isConnected
+
+    override fun isInternetWalled(): Boolean {
+        val currentKey = key
+        val cachedValue = walledCheckCache.getValue(currentKey)
+        if (cachedValue != null) {
+            Log_OC.d(TAG, "cached value is used, isWalled: $cachedValue")
+            return cachedValue
         }
 
-        override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-            Log_OC.d(TAG, "capability changed")
-            updateConnectivity()
+        val baseServerAddress = accountManager.user.server.uri.toString()
+        if (baseServerAddress.isEmpty()) {
+            Log_OC.e(TAG, "no base server address, internet is walled")
+            return true
         }
+
+        val resolvedCapabilities = resolveNetworkCapabilities()
+        if (resolvedCapabilities == null || !isSupportedTransport(resolvedCapabilities)) {
+            Log_OC.e(TAG, "no usable network transport at check time, treating as walled")
+            return true
+        }
+
+        val get = requestBuilder.invoke(baseServerAddress + CONNECTIVITY_CHECK_ROUTE)
+        val client = clientFactory.createPlainClient()
+
+        val isWalled = try {
+            val status = get.execute(client)
+            (!(status == HttpStatus.SC_NO_CONTENT && get.getResponseContentLength() <= 0)).also {
+                if (it) Log_OC.w(TAG, "server returned unexpected response, status: $status")
+            }
+        } catch (e: Exception) {
+            Log_OC.e(TAG, "exception during server check", e)
+            getWalledValueFromException(e)
+        } finally {
+            get.releaseConnection()
+        }
+
+        walledCheckCache.setValue(currentKey, isWalled)
+
+        Log_OC.d(TAG, "server check, isWalled: $isWalled")
+        return isWalled
     }
 
-    fun interface GetRequestBuilder {
-        operator fun invoke(url: String): GetMethod
+    override fun getConnectivity() = currentConnectivity
+
+    override fun addListener(listener: NetworkChangeListener) {
+        listeners.add(listener)
     }
 
-    init {
-        connectivityManager.registerDefaultNetworkCallback(networkCallback)
-        updateConnectivity()
-        Log_OC.d(TAG, "connectivity service constructed")
+    override fun removeListener(listener: NetworkChangeListener) {
+        listeners.remove(listener)
     }
+    // endregion
 
+    // region public methods
     fun updateConnectivity() {
         val currentKey = key
         val previous = currentConnectivity
@@ -135,6 +179,33 @@ class ConnectivityServiceImpl(
         }
     }
 
+    @Suppress("unused")
+    fun unregisterCallback() {
+        connectivityManager.unregisterNetworkCallback(networkCallback)
+    }
+
+    fun interface GetRequestBuilder {
+        operator fun invoke(url: String): GetMethod
+    }
+    // endregion
+
+    // region private methods
+    private fun notifyListeners() {
+        if (listeners.isEmpty()) {
+            return
+        }
+
+        notifyJob?.cancel()
+        notifyJob = scope.launch {
+            val available = !isInternetWalled()
+            withContext(Dispatchers.Main) {
+                listeners.forEach {
+                    it.networkAndServerConnectionListener(available)
+                }
+            }
+        }
+    }
+
     @Suppress("DEPRECATION")
     private fun resolveNetworkCapabilities(): NetworkCapabilities? {
         connectivityManager.activeNetwork
@@ -158,62 +229,6 @@ class ConnectivityServiceImpl(
                     capabilities.hasTransport(NetworkCapabilities.TRANSPORT_USB)
                 )
 
-    override fun isNetworkAndServerAvailable(callback: GenericCallback<Boolean>) {
-        availabilityCheckJob?.cancel()
-        availabilityCheckJob = scope.launch {
-            val available = !isInternetWalled()
-            Log_OC.d(TAG, "isNetworkAndServerAvailable: $available")
-            withContext(Dispatchers.Main) {
-                callback.onComplete(available)
-            }
-        }
-    }
-
-    override fun isConnected() = currentConnectivity.isConnected
-
-    override fun isInternetWalled(): Boolean {
-        val currentKey = key
-        val cachedValue = walledCheckCache.getValue(currentKey)
-        if (cachedValue != null) {
-            Log_OC.d(TAG, "cached value is used, isWalled: $cachedValue")
-            return cachedValue
-        }
-
-        val baseServerAddress = accountManager.user.server.uri.toString()
-        if (baseServerAddress.isEmpty()) {
-            Log_OC.e(TAG, "no base server address, internet is walled")
-            return true
-        }
-
-        val resolvedCapabilities = resolveNetworkCapabilities()
-        if (resolvedCapabilities == null || !isSupportedTransport(resolvedCapabilities)) {
-            Log_OC.e(TAG, "no usable network transport at check time, treating as walled")
-            return true
-        }
-
-        val get = requestBuilder.invoke(baseServerAddress + CONNECTIVITY_CHECK_ROUTE)
-        val client = clientFactory.createPlainClient()
-
-        val isWalled = try {
-            val status = get.execute(client)
-            (!(status == HttpStatus.SC_NO_CONTENT && get.getResponseContentLength() <= 0)).also {
-                if (it) Log_OC.w(TAG, "server returned unexpected response, status: $status")
-            }
-        } catch (e: Exception) {
-            Log_OC.e(TAG, "exception during server check", e)
-            getWalledValueFromException(e)
-        } finally {
-            get.releaseConnection()
-        }
-
-        walledCheckCache.setValue(currentKey, isWalled)
-
-        Log_OC.d(TAG, "server check, isWalled: $isWalled")
-        return isWalled
-    }
-
-    override fun getConnectivity() = currentConnectivity
-
     private fun getWalledValueFromException(e: Exception): Boolean = when (e) {
         is UnknownHostException,
         is ConnectException -> {
@@ -241,14 +256,5 @@ class ConnectivityServiceImpl(
             currentConnectivity.isServerAvailable?.let { !it } ?: true
         }
     }
-
-    @Suppress("unused")
-    fun unregisterCallback() {
-        connectivityManager.unregisterNetworkCallback(networkCallback)
-    }
-
-    companion object {
-        private const val TAG = "ConnectivityServiceImpl"
-        private const val CONNECTIVITY_CHECK_ROUTE = "/index.php/204"
-    }
+    // endregion
 }