I am trying to connect my mobile and Tv emulator. My mobile and pc connected to the same wifi. By discovering the devices from mobile. I got resolved the host and port. But I can’t send the message to Tv. When trying to send, I got connection refused error.

Tv app code and Mobile app code:

package com.example.tv_app_to_connect_mobile

import android.content.Context
import android.net.nsd.NsdManager
import android.net.nsd.NsdServiceInfo
import android.os.Bundle
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.tv_app_to_connect_mobile.ui.theme.Tv_app_to_connect_mobileTheme
import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.PrintWriter
import java.net.Inet4Address
import java.net.InetAddress
import java.net.NetworkInterface
import java.net.ServerSocket
import java.net.Socket
import java.net.SocketException

class MainActivity : ComponentActivity() {
    private var servicename = "NsdChat"
    private var servicetype = "_nsdchat._tcp"
    private var nsdManager: NsdManager? = null
    private var serverSocket: ServerSocket? = null
    private var port: Int = -1

    private val registrationListener = object : NsdManager.RegistrationListener {
        override fun onServiceRegistered(serviceInfo: NsdServiceInfo) {
            servicename = serviceInfo.serviceName
            Log.i("NSD", "Service registered: $servicename")
        }

        override fun onRegistrationFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
            Log.e("NSD", "Service registration failed: $errorCode")
        }

        override fun onServiceUnregistered(serviceInfo: NsdServiceInfo) {
            Log.i("NSD", "Service unregistered: ${serviceInfo.serviceName}")
        }

        override fun onUnregistrationFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
            Log.e("NSD", "Service unregistration failed: $errorCode")
        }
    }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            Tv_app_to_connect_mobileTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "TV app for receiving messages from phone",
                        modifier = Modifier.padding(innerPadding)
                    )

                }
            }
        }
        startServer()
    }

    private fun startServer() {
        Thread {
            try {
                serverSocket = ServerSocket(0)
                port = serverSocket!!.localPort
                Log.i("NSD","Port: $port")
                registerService()  // Register the service after the port is set
                while (true) {
                    val clientSocket = serverSocket!!.accept()
                    handleClient(clientSocket)
                }
            } catch (e: Exception) {
                e.printStackTrace()
                Log.i("NSD-ER","${e.printStackTrace()}")
            }
        }.start()
    }

    private fun handleClient(clientSocket: Socket) {
        Thread {
            try {
                val input = BufferedReader(InputStreamReader(clientSocket.getInputStream()))
                val output = PrintWriter(clientSocket.getOutputStream(), true)
                var message: String?
                while (input.readLine().also { message = it } != null) {
                    Log.i("NSD", "Received: $message")
                    output.println("Message received")
                }
                clientSocket.close()
            } catch (e: Exception) {
                e.printStackTrace()
                Log.i("NSD-ER","${e.printStackTrace()}")
            }
        }.start()
    }

    private fun registerService() {
        val serviceInfo = NsdServiceInfo().apply {
            serviceName = "NsdChat"
            serviceType = "_nsdchat._tcp"
            port = [email protected]
//            host = InetAddress.getByName(getLocalIpAddress())
        }
        nsdManager = getSystemService(Context.NSD_SERVICE) as NsdManager
        nsdManager?.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, registrationListener)
    }
//    fun getLocalIpAddress(): String? {
//        try {
//            val en = NetworkInterface.getNetworkInterfaces()
//            while (en.hasMoreElements()) {
//                val intf = en.nextElement()
//                val enumIpAddr = intf.inetAddresses
//                while (enumIpAddr.hasMoreElements()) {
//                    val inetAddress = enumIpAddr.nextElement()
//                    if (!inetAddress.isLoopbackAddress && inetAddress is Inet4Address) {
//                        return inetAddress.hostAddress
//                    }
//                }
//            }
//        } catch (ex: SocketException) {
//            Log.e("NSD", "getLocalIpAddress", ex)
//        }
//        return null
//    }


    override fun onPause() {
        nsdManager?.unregisterService(registrationListener)
        serverSocket?.close()
        super.onPause()
    }

    override fun onDestroy() {
        nsdManager?.unregisterService(registrationListener)
        serverSocket?.close()
        super.onDestroy()
    }
}

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "$name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    Tv_app_to_connect_mobileTheme {
        Greeting("Android")
    }
}

//Mobile app code 
package com.example.phone_app_to_connect_tv

import android.annotation.SuppressLint
import android.content.Context
import android.net.nsd.NsdManager
import android.net.nsd.NsdManager.DiscoveryListener
import android.net.nsd.NsdServiceInfo
import android.os.Bundle
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.unit.dp
import com.example.phone_app_to_connect_tv.ui.theme.Phone_app_to_connect_TvTheme
import java.io.PrintWriter
import java.net.Socket

class MainActivity : ComponentActivity() {
    private var SERVICE_NAME = "Client Device"
    private var SERVICE_TYPE = "_nsdchat._tcp"

    private var hostAddress: String? = null
    private var hostPort = 0
    private var nsdManager: NsdManager? = null

    private var discoveryListener: NsdManager.DiscoveryListener?=null
    private var resolveListener: NsdManager.ResolveListener?=null


    @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            Phone_app_to_connect_TvTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) {
                    MainScreen { message, onResponseReceived ->
                        sendMessageToTV(message, onResponseReceived)
                    }
                }
            }
        }
        nsdManager = getSystemService(Context.NSD_SERVICE) as NsdManager
        discoveryListener = object : NsdManager.DiscoveryListener {
            override fun onDiscoveryStarted(serviceType: String) {
                Log.d("NSD", "Service discovery started for type: $serviceType")
            }

            override fun onServiceFound(service: NsdServiceInfo) {
                Log.d("NSD", "Service discovery success: ${service.serviceName}, ${service.serviceType}")
//                Log.d("NSD", "${service.serviceType}==")
//                if (service.serviceType == SERVICE_TYPE && service.serviceName=="NsdChat") {
                    Log.d("NSD", "Service match found, attempting to resolve")
                    nsdManager?.resolveService(service, resolveListener)
//                }
            }

            override fun onServiceLost(service: NsdServiceInfo) {
                Log.e("NSD", "Service lost: $service")
            }

            override fun onDiscoveryStopped(serviceType: String) {
                Log.i("NSD", "Discovery stopped: $serviceType")
            }

            override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
                Log.e("NSD", "Discovery failed: Error code:$errorCode")
                nsdManager?.stopServiceDiscovery(this)
            }

            override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
                Log.e("NSD", "Discovery failed: Error code:$errorCode")
                nsdManager?.stopServiceDiscovery(this)
            }
        }
        resolveListener = object : NsdManager.ResolveListener {
            override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
                Log.e("NSD", "Resolve failed: $errorCode, $serviceInfo")
            }

            override fun onServiceResolved(serviceInfo: NsdServiceInfo) {
                Log.d("NSD", "Resolve succeeded: $serviceInfo")
                hostPort = serviceInfo.port
                hostAddress = serviceInfo.host.hostAddress
                Log.d("NSD", "Host Address: $hostAddress, Host Port: $hostPort")
            }
        }

//        nsdManager?.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, discoveryListener)
    }

    override fun onResume() {
        super.onResume()
        nsdManager?.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, discoveryListener)

    }

    override fun onPause() {
        nsdManager?.stopServiceDiscovery(discoveryListener)
        super.onPause()
    }

    override fun onDestroy() {
        nsdManager?.stopServiceDiscovery(discoveryListener)
        super.onDestroy()
    }

    private fun sendMessageToTV(message: String, onResponseReceived: (String) -> Unit) {
        Thread {
            try {
                Log.i("NSD","Host Addrs./ : $hostAddress")
                Log.i("NSD","Host Port./ : $hostPort")
                val socket = Socket(hostAddress, hostPort)
                val output = PrintWriter(socket.getOutputStream(), true)
                val input = socket.getInputStream().bufferedReader()
                output.println(message)
                val response = input.readLine()
                runOnUiThread {
                    onResponseReceived(response)
                }
                socket.close()
            } catch (e: Exception) {
                Log.i("NSD-ER","${e.printStackTrace()}")
            }
        }.start()
    }
}

@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@Composable
fun MainScreen(sendMessage: (String, (String) -> Unit) -> Unit) {
    var userText by remember { mutableStateOf(TextFieldValue("")) }
    var outputText by remember { mutableStateOf("Here, the output will be shown") }

    Scaffold(modifier = Modifier.fillMaxSize()) {
        Column(
            modifier = Modifier.fillMaxSize(),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Spacer(modifier = Modifier.height(20.dp))
            Text(text = outputText)
            Spacer(modifier = Modifier.height(20.dp))
            simpleTextField(userText) { newText ->
                userText = newText
            }
            Spacer(modifier = Modifier.height(20.dp))
            Button(onClick = {
                sendMessage(userText.text) { response ->
                    outputText = "Response from TV: $response"
                }
            }) {
                Text(text = "Send the message to TV")
            }
        }
    }
}

@Composable
fun simpleTextField(userText: TextFieldValue, onTextChange: (TextFieldValue) -> Unit) {
    TextField(
        value = userText,
        onValueChange = { newText ->
            onTextChange(newText)
        }
    )
}

Why I can’t send the message to Tv