The Listener class is useful to manage dynamically the listeners when the allowMultipleListeners is set to "true", allowing the communication and, eventually, the interruption of the routine of the listener

StandardResponseCode

enum StandardResponseCode

StandardResponseCode list of available response status code

Properties

allowMultipleListeners

protected val allowMultipleListeners: Boolean

allowMultipleListeners whether accept multiple listeners at the same time

continueSingleRoutine

protected open var continueSingleRoutine: Boolean

continueSingleRoutine whether continue the routine for the single listener if allowMultipleListeners is set to "false"

currentHost

protected val currentHost: String

currentHost current server host used in the communication

currentServerPort

protected open var currentServerPort: Int

currentServerPort current server port used in the communication

defaultErrorResponse

protected open var defaultErrorResponse: String

defaultErrorResponse default error response

defaultSuccessResponse

protected open var defaultSuccessResponse: String

defaultSuccessResponse default successful response

executor

protected val executor: ExecutorService

"executor" of the routines

lastContentRed

protected open var lastContentRed: String

lastContentRed last content red with readContent or readContent

listeners

protected val listeners: ConcurrentHashMap<Integer, SocketManager.Listener>

listeners list of listeners to use if the allowMultipleListeners flag is set to "true"

NEW_LINE_REPLACER

protected val NEW_LINE_REPLACER: String = "@-/-/-@"

NEW_LINE_REPLACER is the constants which indicates the replacer to use when the content message contains multiple lines

publicHostAddress

protected open var publicHostAddress: String

publicHostAddress public host address

serverSocket

protected open var serverSocket: ServerSocket

serverSocket socket managed by the server

serverUse

protected val serverUse: Boolean

serverUse whether the runtime use of this class is server side or not

socket

protected open var socket: Socket

socket socket used in the communication

Functions

acceptRequest

open fun acceptRequest(): Socket

Method to accept a new socket request No-any params required

acceptRequestOn

open fun acceptRequestOn(port: Int): Socket

Method to accept a new socket request

areAllowedMultipleListeners

open fun areAllowedMultipleListeners(): Boolean

Method to get allowMultipleListeners instance No-any params required

closeCommunication

open fun closeCommunication()

Method to stop the communication No-any params required

continueListening

open fun continueListening(): Boolean

Method to get if the listener's workflow needs to continue or not Any param required

continueListeningOn

open fun continueListeningOn(port: Int): Boolean

Method to get if the listener's workflow needs to continue or not

exit

protected open fun exit(errorMessage: String)

Method to print an error occurred and exit with status code 1

getActiveServerSocket

open fun getActiveServerSocket(): ServerSocket

Method to get serverSocket instance No-any params required

getActiveSocket

open fun getActiveSocket(): Socket

Method to get socket instance No-any params required

getCurrentServerPort

open fun getCurrentServerPort(): Int

Method to get currentServerPort instance No-any params required

getExecutor

open fun getExecutor(): ExecutorService

Method to get executor instance No-any params required

getHost

open fun getHost(publicAddress: Boolean): String

Method to get host where the server is running

getIpAddress

open fun getIpAddress(socket: Socket): String

This method is used to get an ip address from a Socket

getListeners

open fun getListeners(): ConcurrentHashMap<Integer, SocketManager.Listener>

Method to get listeners instance No-any params required

isServerUse

open fun isServerUse(): Boolean

Method to get serverUse instance No-any params required

pingHost

open fun pingHost(timeout: Int): Boolean

open fun pingHost(host: String, port: Int, timeout: Int): Boolean

This method is used to ping a host on a specific port and get whether is reachable

readContent

open fun readContent(): String

Method to read a content message received with the socket request No-any params required

open fun readContent(targetSocket: Socket): String

Method to read a content message received with the socket request

readLastContent

open fun readLastContent(): String

Method to read the last content message red in the stream with the socket request No-any params required

sendDefaultErrorResponse

open fun sendDefaultErrorResponse()

Method to send the defaultErrorResponse No-any params required

sendDefaultErrorResponseTo

open fun sendDefaultErrorResponseTo(port: Int)

open fun sendDefaultErrorResponseTo(host: String)

open fun sendDefaultErrorResponseTo(host: String, port: Int)

Method to send the defaultErrorResponse

sendSuccessResponse

open fun sendSuccessResponse()

Method to send the defaultSuccessResponse No-any params required

sendSuccessResponseTo

open fun sendSuccessResponseTo(port: Int)

open fun sendSuccessResponseTo(host: String)

open fun sendSuccessResponseTo(host: String, port: Int)

Method to send the defaultSuccessResponse

setDefaultErrorResponse

open fun <T> setDefaultErrorResponse(defaultErrorResponse: T)

Method to set the default error response to send as error

setDefaultSuccessResponse

open fun <T> setDefaultSuccessResponse(defaultSuccessResponse: T)

Method to set the default successful response to send as success

startListener

open fun startListener(port: Int, routine: Runnable)

Method to start a new listener

stopAllListeners

open fun stopAllListeners()

Method to stop the listener's workflow No-any params required

stopListener

open fun stopListener()

Method to stop the listener's workflow Any param required


         SocketManager socketManager = new SocketManager(false);
         socketManager.startListener(3218, new Runnable() {
            
            public void run() {
                while (socketManager.continueListening()) {
                    // do listener's workflow
                }
                // listener's workflow when has been stopped
            }
        });

        // your code's workflow

        socketManager.stopListener(); // --> the single listener will be stopped

stopListenerOn

open fun stopListenerOn(port: Int)

Method to stop the listener's workflow

toString

open fun toString(): String

Returns a string representation of the object No-any params required

writeContent