MainActivity.kt

package space.sc0rp10n.wifidirect

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.net.wifi.p2p.*
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.provider.Settings
import android.util.Log
import android.view.View
import android.widget.*
import androidx.appcompat.app.AppCompatActivity
import java.io.IOException
import java.io.InputStream
import java.io.OutputStream
import java.net.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class MainActivity : AppCompatActivity() {

    lateinit var aSwitch: Button
    lateinit var discoverButton: Button
    lateinit var sendButton: ImageButton
    lateinit var listView: ListView
    lateinit var messageTextView: TextView
    lateinit var connectionStatus: TextView
    lateinit var typeMsg: EditText

    lateinit var manager: WifiP2pManager
    lateinit var channel: WifiP2pManager.Channel

    lateinit var receiver: BroadcastReceiver
    lateinit var intentFilter: IntentFilter

    val peers = mutableListOf<WifiP2pDevice>()
    lateinit var deviceNameArray: Array<String>
    lateinit var deviceArray: Array<WifiP2pDevice>

    lateinit var socket: Socket

    lateinit var serverClass: ServerClass
    lateinit var clientClass: ClientClass

    var isHost: Boolean = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initialWork()
        exqListener()
    }

    private fun exqListener() {
        aSwitch.setOnClickListener {
            object: View.OnClickListener {
                override fun onClick(view: View?) {
                    val intent = Intent(Settings.ACTION_WIFI_SETTINGS)
                    startActivityForResult(intent, 1)
                    Log.d("Wifi on off", "clicked")
                }
            }
        }

        discoverButton.setOnClickListener(
            object : View.OnClickListener {
                override fun onClick(view: View?) {
                    Log.d("Discovery", "Started")
                    manager.discoverPeers(
                        channel,
                        object : WifiP2pManager.ActionListener {
                            override fun onSuccess() {
                                connectionStatus.setText("Discovery Started")
                            }

                            override fun onFailure(reasonCode: Int) {
                                connectionStatus.setText("Discovery Starting Failed")
                            }
                        }
                    )
                }
            }
        )

        listView.setOnItemClickListener(
            object : AdapterView.OnItemClickListener {
                override fun onItemClick(adapterView: AdapterView<*>, view: View, i: Int, l: Long) {
                    val device: WifiP2pDevice = deviceArray[i]
                    val config = WifiP2pConfig()
                    config.deviceAddress = device.deviceAddress

                    manager.connect(channel, config, object : WifiP2pManager.ActionListener {
                            override fun onSuccess() {
                                connectionStatus.setText("Connected " + device.deviceAddress)
                            }

                            override fun onFailure(reasonCode: Int) {
                                Log.d("Reason", reasonCode.toString())
                                connectionStatus.setText("Not Connected")
                            }
                        }
                    )
                }
            }
        )

        sendButton.setOnClickListener(
            object : View.OnClickListener {
                override fun onClick(view: View?) {
                    val executor: ExecutorService = Executors.newSingleThreadExecutor()
                    val msg: String = typeMsg.text.toString()
                    executor.execute(object : Runnable {
                        override fun run() {
                            if (msg != null && isHost) {
                                serverClass.write(msg.toByteArray())
                            } else if (msg != null && !isHost) {
                                clientClass.write(msg.toByteArray())
                            }
                        }
                    })
                }
            }
        )
    }

    private fun initialWork() {
        aSwitch = findViewById(R.id.switch1)
        discoverButton = findViewById(R.id.buttonDiscover)
        sendButton = findViewById(R.id.sendButton)
        listView = findViewById(R.id.listView)
        messageTextView = findViewById(R.id.messageTextView)
        connectionStatus = findViewById(R.id.connection_status)
        typeMsg = findViewById(R.id.editTextTypeMsg)

        manager = getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager
        channel = manager.initialize(this, mainLooper, null)
        receiver = WiFiDirectBroadcastReceiver(manager, channel, this)

        intentFilter = IntentFilter()
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
//        intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
    }

    val peerListListener =
        object: WifiP2pManager.PeerListListener {
            override fun onPeersAvailable(wifiP2pDeviceList: WifiP2pDeviceList?) {
                if (wifiP2pDeviceList != null) {
                    if (!wifiP2pDeviceList.equals(peers)) {
                        peers.clear()
                        peers.addAll(wifiP2pDeviceList.deviceList)

                        deviceNameArray = Array<String>(wifiP2pDeviceList.deviceList.size) {i -> ""}
                        deviceArray = Array<WifiP2pDevice>(wifiP2pDeviceList.deviceList.size) {i -> WifiP2pDevice()}

                        var index: Int = 0
                        for (device: WifiP2pDevice in wifiP2pDeviceList.deviceList) {
                            deviceNameArray[index] = device.deviceName
                            deviceArray[index] = device
                            index += 1
                        }

                        val adapter: ArrayAdapter<String> = ArrayAdapter(applicationContext, android.R.layout.simple_list_item_1, deviceNameArray)
                        listView.setAdapter(adapter)
                    }
                } else {
                    connectionStatus.setText("No Device Found")
                    return
                }
            }
        }

    val connectionInfoListener =
        object: WifiP2pManager.ConnectionInfoListener {
            override fun onConnectionInfoAvailable(wifiP2pInfo: WifiP2pInfo?) {
                val groupOwnerAddress: InetAddress = wifiP2pInfo!!.groupOwnerAddress
                if(wifiP2pInfo.groupFormed && wifiP2pInfo.isGroupOwner) {
                    Toast.makeText(applicationContext, "Server Starting", Toast.LENGTH_SHORT).show()
                    connectionStatus.setText("Host")
                    isHost = true
                    serverClass = ServerClass(messageTextView, socket)
                    serverClass.start()
                    Toast.makeText(applicationContext, "Server Done", Toast.LENGTH_SHORT).show()
                } else if (wifiP2pInfo.groupFormed) {
                    Toast.makeText(applicationContext, "Client Starting", Toast.LENGTH_SHORT).show()
                    connectionStatus.setText("Client")
                    isHost = false
                    clientClass = ClientClass(groupOwnerAddress, messageTextView, socket)
                    clientClass.start()
                    Toast.makeText(applicationContext, "Client Done", Toast.LENGTH_SHORT).show()
                }
            }
        }

    protected override fun onResume() {
        Log.d("onResume", "Started")
        super.onResume()
        registerReceiver(receiver, intentFilter)
        Log.d("onResume", "Passed")
    }

    override fun onPause() {
        Log.d("onPause", "Started")
        super.onPause()
        unregisterReceiver(receiver)
        Log.d("onPause", "Passed")
    }

    public class ServerClass (var messageTextView: TextView, var socket: Socket) : Thread() {
        lateinit var serverSocket: ServerSocket
        lateinit var inputStream: InputStream
        lateinit var outputStream: OutputStream

        fun write(bytes: ByteArray) {
            try {
                outputStream.write(bytes)
            } catch (e: IOException) {
                e.printStackTrace()
            }
        }

        override fun run() {
            try {
                serverSocket = ServerSocket(8888)
                socket = serverSocket.accept()
                inputStream = socket.getInputStream()
                outputStream = socket.getOutputStream()
            } catch (e: IOException) {
                e.printStackTrace()
            }

            val executor : ExecutorService = Executors.newSingleThreadExecutor()
            val handler: Handler = Handler(Looper.getMainLooper())

            executor.execute(object: Runnable {
                override fun run() {
                    val buffer = ByteArray(1024)
                    var bytes: Int
                    while(socket!=null) {
                        try {
                            bytes = inputStream.read(buffer)
                            if(bytes > 0) {
                                val finalBytes: Int = bytes
                                handler.post(object : Runnable {
                                    override fun run() {
                                        val tempMsg: String = String(buffer, 0, finalBytes)
                                        messageTextView.setText(tempMsg)
                                    }
                                })
                            }
                        } catch (e: IOException) {
                            e.printStackTrace()
                        }
                    }
                }
            })
        }
    }

    class ClientClass(var hostAddress: InetAddress, var messageTextView: TextView, var socket: Socket) : Thread() {

        var hostAdd: String
        lateinit var inputStream: InputStream
        lateinit var outputStream: OutputStream
//        lateinit var socket: Socket

        init {
            hostAdd = hostAddress.hostAddress as String
            socket = Socket()
        }

        fun write(bytes: ByteArray) {
            try {
                outputStream.write(bytes)
            } catch (e: IOException) {
                e.printStackTrace()
            }
        }

        override fun run() {
            try {
                socket.connect(InetSocketAddress(hostAdd, 8888), 500)
                inputStream = socket.getInputStream()
                outputStream = socket.getOutputStream()
            } catch (e: IOException) {
                e.printStackTrace()
            }

            val executor: ExecutorService = Executors.newSingleThreadExecutor()
            val handler: Handler = Handler(Looper.getMainLooper())

            executor.execute(object: Runnable {
                override fun run() {
                    val buffer = ByteArray(1024)
                    var bytes: Int
                    while(socket!= null) {
                        try {
                            bytes = inputStream.read(buffer)
                            if (bytes>0){
                                val finalBytes: Int = bytes
                                handler.post(object : Runnable {
                                    override fun run() {
                                        val tempMsg = String(buffer, 0, finalBytes)
                                        messageTextView.setText(tempMsg)
                                    }
                                })
                            }
                        } catch (e: IOException) {
                            e.printStackTrace()
                        }
                    }
                }
            })
        }
    }
}