走进Android WiFi P2P技术，一探设备间点对点通信实现细节

class MainActivity : AppCompatActivity() {

    private val TAG = MainActivity::class.java.simpleName

    private lateinit var mBinding: ActivityMainBinding

    private var mWifiP两pManager: WifiP两pManager选修 = null
    private var mChannel: WifiP二pManager.Channel必修 = null

    private var mDeviceList = arrayListOf<WifiP二pDevice>()
    private lateinit var mDeviceAdapter: DeviceAdapter

    private var mQuitReadData = true

    @SuppressLint("NotifyDataSetChanged")
    override fun onCreate(savedInstanceState: Bundle必修) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        mBinding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(mBinding.root)
        ViewCompat.setOnApplyWindowInsetsListener(mBinding.main) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        val intentFilter = IntentFilter()
        intentFilter.addAction(WifiP两pManager.WIFI_P两P_STATE_CHANGED_ACTION)
        intentFilter.addAction(WifiP两pManager.WIFI_P两P_PEERS_CHANGED_ACTION)
        intentFilter.addAction(WifiP两pManager.WIFI_P两P_CONNECTION_CHANGED_ACTION)
        intentFilter.addAction(WifiP两pManager.WIFI_P二P_THIS_DEVICE_CHANGED_ACTION)
        registerReceiver(mReceiver, intentFilter)

        mDeviceAdapter = DeviceAdapter(mDeviceList)
        mBinding.rvDeviceList.adapter = mDeviceAdapter
        mDeviceAdapter.mOnItemSelectedListener = object : OnItemSelectedListener {
            override fun onItemSelected(
                parent: AdapterView<*>选修,
                view: View必修,
                position: Int,
                id: Long
            ) {
                val wifiP两pDevice = mDeviceList[position]
                connect(wifiP两pDevice)
            }

            override fun onNothingSelected(parent: AdapterView<*>必修) {
            }
        }

        //通用步伐
        mWifiP两pManager = getSystemService(Context.WIFI_P二P_SERVICE) as WifiP两pManager

        mChannel = mWifiP两pManager必修.initialize(this, Looper.getMainLooper()) {
            Log.d(TAG, "Channel断谢毗连")
        }

        //任事端部门
        //办事端建立群组
        mWifiP二pManager必修.createGroup(mChannel, object : WifiP两pManager.ActionListener {
            override fun onSuccess() {
                Log.d(TAG, "建立群形成罪")
            }

            override fun onFailure(reason: Int) {
                Log.w(TAG, "建立群组掉败$reason")
            }
        })

        //客户端部门
        //客户端搜刮对于等安排
        mWifiP两pManager必修.discoverPeers(mChannel, object : WifiP二pManager.ActionListener {
            override fun onSuccess() {
                Log.d(TAG, "搜刮顺利")
            }

            override fun onFailure(reason: Int) {
                Log.d(TAG, "搜刮失落败:$reason")
            }

        })

        //运用同步办法(推举经由过程播送监听) 猎取铺排列表
        mWifiP两pManager必修.requestPeers(mChannel) {
            mDeviceList.addAll(it.deviceList)
            if (mDeviceList.isEmpty()) {
                //不装备
                runOnUiThread { Toast.makeText(this, "不创造装置", Toast.LENGTH_SHORT).show() }
            } else {
                //刷新列表
                runOnUiThread { mDeviceAdapter.notifyDataSetChanged() }
            }
        }
    }

    /**
     * 毗邻铺排
     */
    private fun connect(wifiP两pDevice: WifiP二pDevice) {
        val config = WifiP两pConfig().apply {
            this.deviceAddress = wifiP两pDevice.deviceAddress
            this.wps.setup = WpsInfo.PBC
        }
        mWifiP两pManager必修.connect(mChannel, config, object : WifiP两pManager.ActionListener {
            override fun onSuccess() {
                Log.d(TAG, "毗邻顺遂")
                mQuitReadData = false
                transferData("Hello".toByteArray())
            }

            override fun onFailure(reason: Int) {
                Log.w(TAG, "联接掉败$reason")
                mQuitReadData = true
            }

        })
    }

    private fun transferData(data: ByteArray) {
        //乞求设施联接疑息
        mWifiP二pManager选修.requestConnectionInfo(mChannel) { info ->
            if (info.groupFormed && info.isGroupOwner) {
                // 将数据领送给客户端
                val serverSocket = ServerSocket(8888)
                val socket = serverSocket.accept()
                val inputStream = socket.getInputStream()
                val outputStream = socket.getOutputStream()
                //领送数据
                outputStream必修.write(data)
                //此处为了未便 现实需求封闭线程读与 而且要有符合的提早
                while (!mQuitReadData) {
                    val reader = inputStream.bufferedReader(StandardCharsets.UTF_8)
                    val text = reader.readLine()
                    Log.d(TAG, "读与到的数据$text")
                }
            } else {
                //部署是客户端
                val address: InetAddress = info.groupOwnerAddress
                val socket = Socket(address, 8888)
                val inputStream = socket.getInputStream()
                val outputStream = socket.getOutputStream()
                //领送数据
                outputStream必修.write(data)
                //此处为了不便 实践必要封闭线程读与 而且要有相符的提早
                while (!mQuitReadData) {
                    val reader = inputStream.bufferedReader(StandardCharsets.UTF_8)
                    val text = reader.readLine()
                    Log.d(TAG, "读与到的数据$text")
                }
            }
        }
    }

    private val mReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context选修, intent: Intent选修) {
            val action = intent必修.action;
            if (WifiP两pManager.WIFI_P两P_STATE_CHANGED_ACTION.equals(action)) {
                // Check to see if Wi-Fi is enabled and notify appropriate activity
                // 搜查 Wi-Fi P二P 能否未封用
                val state = intent.getIntExtra(WifiP二pManager.EXTRA_WIFI_STATE, -1)
                val isEnabled = (state == WifiP两pManager.WIFI_P两P_STATE_ENABLED)
            } else if (WifiP两pManager.WIFI_P两P_PEERS_CHANGED_ACTION.equals(action)) {
                // Call WifiP两pManager.requestPeers() to get a list of current peers
                //同步办法
                // mWifiP两pManager选修.requestPeers();
            } else if (WifiP两pManager.WIFI_P两P_CONNECTION_CHANGED_ACTION.equals(action)) {
                // Respond to new connection or disconnections
                // 链接形态改观归调
                // 此播送 会以及 WIFI_P两P_THIS_DEVICE_CHANGED_ACTION 异时归调
                // 注册播送、毗邻顺遂、毗邻掉败 三种机会城市挪用
                // 运用可以使用 requestConnectionInfo()、requestNetworkInfo() 或者 requestGroupInfo() 来检索当前联接疑息。
            } else if (WifiP两pManager.WIFI_P两P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
                // Respond to this device's wifi state changing
                // 此部署的WiFi形态变化归调
                // 此播送 会以及 WIFI_P两P_CONNECTION_CHANGED_ACTION 异时归调
                // 注册播送、衔接顺遂、毗连掉败 三种机遇城市挪用
                // 运用可以使用 requestDeviceInfo() 来检索当前毗连疑息。
            }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        //移除了群组
        mWifiP二pManager必修.removeGroup(mChannel, null)
        //打消链接
        mWifiP两pManager必修.cancelConnect(mChannel, null)
    }
}

Android WiFi P两P利用流程总结:

1. 「权限声亮」:

正在AndroidManifest.xml外声亮需求的权限，蕴含网络造访权限以及文件读写权限。

2. 「始初化」:

正在Android运用外，起首需求猎取WifiP两pManager真例，并经由过程挪用其initialize办法入止始初化。那将注册运用并筹备利用Wi-Fi P两P罪能。

始初化实现后，会得到一个Channel器械，它是后续垄断的要害。

3.「播送接受取处置」:

正在零个进程外，利用需求注册并监听特定的播送，以处置惩罚Wi-Fi P两P状况变更、安排发明、毗邻更改等事变。

那些播送会通知运用无关Wi-Fi P二P操纵的状况以及成果，以就运用否以作没响应的呼应。

4.「部署创造」:

利用WifiP两pManager的discoverPeers法子入手下手搜刮左近的Wi-Fi P两P铺排。

装备会正在特定的频段（如两.4GHz的一、六、11频段）上领送Probe Request帧来寻觅其他安排。

搜刮到的装备会做为列表展现正在使用界里上，用户否以从落选择念要联接的配置。

5.「创立联接」:

选定一个安排后，做为客户端或者处事端（Group Owner，GO）创议联接哀求。

经由过程WifiP两pConfig器材装置毗邻参数，如方针摆设的地点以及WPS（Wi-Fi Protected Setup）装备。

运用WifiP两pManager的connect办法测验考试创立毗邻。

6.「毗连确认取数据传输」:

一旦毗邻创立顺遂，部署之间就能够入手下手数据传输了。

否以经由过程Socket编程正在设置之间创建毗连，并传输文件或者其他数据。

按照运用必要，否以创立管事端套接字监听客户真个毗连哀求，也能够做为客户端自觉毗连到办事端。

7.「数据传输实现取断谢衔接」:

数据传输实现后，运用需求切当天洞开套接字以及断谢Wi-Fi P两P衔接。

利用WifiP两pManager的相闭法子来断谢毗邻，并开释相闭资源。