set java.io and ktor socket optionals

Author: pedroSG94

common/build.gradle.kts

@@ -50,6 +50,8 @@ afterEvaluate {
 }
 
 dependencies {
+    implementation(libs.ktor.network)
+    implementation(libs.ktor.network.tls)
     implementation(libs.androidx.annotation)
     implementation(libs.kotlinx.coroutines.android)
     testImplementation(libs.kotlinx.coroutines.test)

common/src/main/java/com/pedro/common/socket/StreamSocket.kt

@@ -0,0 +1,5 @@
+package com.pedro.common.socket.base
+
+enum class SocketType {
+    KTOR, JAVA
+}

common/src/main/java/com/pedro/common/socket/TcpStreamSocketBase.kt

@@ -0,0 +1,58 @@
+/*
+ *
+ *  * Copyright (C) 2024 pedroSG94.
+ *  *
+ *  * Licensed under the Apache License, Version 2.0 (the "License");
+ *  * you may not use this file except in compliance with the License.
+ *  * You may obtain a copy of the License at
+ *  *
+ *  * http://www.apache.org/licenses/LICENSE-2.0
+ *  *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS,
+ *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  * See the License for the specific language governing permissions and
+ *  * limitations under the License.
+ *
+ */
+
+package com.pedro.common.socket.base
+
+import com.pedro.common.socket.java.TcpStreamSocketJava
+import com.pedro.common.socket.java.UdpStreamSocketJava
+import com.pedro.common.socket.ktor.TcpStreamSocketKtor
+import com.pedro.common.socket.ktor.UdpStreamSocketKtor
+import javax.net.ssl.TrustManager
+
+/**
+ * Created by pedro on 22/9/24.
+ */
+abstract class StreamSocket {
+  protected val timeout = 5000L
+  abstract suspend fun connect()
+  abstract suspend fun close()
+  abstract fun isConnected(): Boolean
+  abstract fun isReachable(): Boolean
+
+  companion object {
+    fun createTcpSocket(
+      type: SocketType,
+      host: String, port: Int, secured: Boolean, certificates: TrustManager? = null
+    ): TcpStreamSocket {
+      return when (type) {
+        SocketType.KTOR -> TcpStreamSocketKtor(host, port, secured, certificates)
+        SocketType.JAVA -> TcpStreamSocketJava(host, port, secured, certificates)
+      }
+    }
+
+    fun createUdpSocket(
+      type: SocketType,
+      host: String, port: Int, sourcePort: Int? = null, receiveSize: Int? = null, udpType: UdpType = UdpType.UNICAST
+    ): UdpStreamSocket {
+      return when (type) {
+        SocketType.KTOR -> UdpStreamSocketKtor(host, port, sourcePort, receiveSize, udpType)
+        SocketType.JAVA -> UdpStreamSocketJava(host, port, sourcePort, receiveSize, udpType)
+      }
+    }
+  }
+}

common/src/main/java/com/pedro/common/socket/base/SocketType.kt

@@ -0,0 +1,13 @@
+package com.pedro.common.socket.base
+
+abstract class TcpStreamSocket: StreamSocket() {
+    abstract suspend fun write(bytes: ByteArray)
+    abstract suspend fun write(bytes: ByteArray, offset: Int, size: Int)
+    abstract suspend fun write(b: Int)
+    abstract suspend fun write(string: String)
+    abstract suspend fun flush()
+    abstract suspend fun read(bytes: ByteArray)
+    abstract suspend fun read(size: Int): ByteArray
+    abstract suspend fun readLine(): String?
+
+}

common/src/main/java/com/pedro/common/socket/base/StreamSocket.kt

@@ -0,0 +1,6 @@
+package com.pedro.common.socket.base
+
+abstract class UdpStreamSocket: StreamSocket() {
+    abstract suspend fun write(bytes: ByteArray)
+    abstract suspend fun read(): ByteArray
+}

common/src/main/java/com/pedro/common/socket/base/TcpStreamSocket.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.pedro.common.socket
+package com.pedro.common.socket.base
 
 /**
  * Created by pedro on 6/3/24.

common/src/main/java/com/pedro/common/socket/base/UdpStreamSocket.kt

@@ -1,4 +1,4 @@
-package com.pedro.common.socket
+package com.pedro.common.socket.java
 
 import java.io.IOException
 import java.net.InetSocketAddress
@@ -10,12 +10,12 @@ import javax.net.ssl.SSLContext
 import javax.net.ssl.SSLSocket
 import javax.net.ssl.TrustManager
 
-class TcpStreamSocket(
+class TcpStreamSocketJava(
     private val host: String,
     private val port: Int,
     private val secured: Boolean,
     private val certificates: TrustManager? = null
-): TcpStreamSocketBase() {
+): TcpStreamSocketJavaBase() {
 
     override fun onConnectSocket(timeout: Long): Socket {
         val socket = if (secured) {

…/java/com/pedro/common/socket/UdpType.kt …/com/pedro/common/socket/base/UdpType.ktcommon/src/main/java/com/pedro/common/socket/UdpType.kt renamed to common/src/main/java/com/pedro/common/socket/base/UdpType.kt common/src/main/java/com/pedro/common/socket/UdpType.kt renamed to common/src/main/java/com/pedro/common/socket/base/UdpType.kt

@@ -0,0 +1,70 @@
+package com.pedro.common.socket.java
+
+import com.pedro.common.readUntil
+import com.pedro.common.socket.base.TcpStreamSocket
+import java.io.BufferedReader
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.InputStreamReader
+import java.net.Socket
+
+abstract class TcpStreamSocketJavaBase: TcpStreamSocket() {
+
+    private var socket = Socket()
+    private var input = ByteArrayInputStream(byteArrayOf()).buffered()
+    private var output = ByteArrayOutputStream().buffered()
+    private var reader = InputStreamReader(input).buffered()
+
+    abstract fun onConnectSocket(timeout: Long): Socket
+
+    override suspend fun connect() {
+        socket = onConnectSocket(timeout)
+        reader = BufferedReader(InputStreamReader(socket.getInputStream()))
+        output = socket.getOutputStream().buffered()
+        input = socket.getInputStream().buffered()
+    }
+
+    override suspend fun close() {
+        if (socket.isConnected) {
+            runCatching { socket.shutdownOutput() }
+            runCatching { socket.shutdownInput() }
+            runCatching { socket.close() }
+        }
+    }
+
+    override suspend fun write(bytes: ByteArray) {
+        output.write(bytes)
+    }
+
+    override suspend fun write(bytes: ByteArray, offset: Int, size: Int) {
+        output.write(bytes, offset, size)
+    }
+
+    override suspend fun write(b: Int) {
+        output.write(b)
+    }
+
+    override suspend fun write(string: String) {
+        write(string.toByteArray())
+    }
+
+    override suspend fun flush() {
+        output.flush()
+    }
+
+    override suspend fun read(bytes: ByteArray) {
+        input.readUntil(bytes)
+    }
+
+    override suspend fun read(size: Int): ByteArray {
+        val data = ByteArray(size)
+        read(data)
+        return data
+    }
+
+    override suspend fun readLine(): String? = reader.readLine()
+
+    override fun isConnected(): Boolean = socket.isConnected
+
+    override fun isReachable(): Boolean = socket.inetAddress?.isReachable(timeout.toInt()) ?: false
+}