使用 Wi-Fi Direct 创建 P2P 连接

Wi-Fi Direct（也称为对等网络或 P2P）可让您的应用快速发现附近的设备并与之互动，范围超出蓝牙的功能。

Wi-Fi Direct (P2P) API 允许应用连接到附近的设备，无需连接到网络或热点。如果您的应用旨在成为安全近距离网络的一部分，Wi-Fi Direct 是比传统 Wi-Fi 即时网络更合适的选择，原因如下：

Wi-Fi Direct 支持 WPA2 加密。（某些即时网络仅支持 WEP 加密。）
设备可以广播它们提供的服务，这有助于其他设备更轻松地发现合适的对等设备。
在确定哪个设备应成为网络的群主时，Wi-Fi Direct 会检查每个设备的电源管理、界面和服务功能，并使用这些信息选择能够最有效地处理服务器职责的设备。
Android 不支持 Wi-Fi 即时模式。

本课将向您展示如何使用 Wi-Fi P2P 查找和连接附近的设备。

设置应用权限

要使用 Wi-Fi Direct，请在清单中添加 ACCESS_FINE_LOCATION、CHANGE_WIFI_STATE、ACCESS_WIFI_STATE 和 INTERNET 权限。如果您的应用目标平台是 Android 13 (API 级别 33) 或更高版本，请还在清单中添加 NEARBY_WIFI_DEVICES 权限。Wi-Fi Direct 不需要互联网连接，但它使用标准的 Java 套接字，这需要 INTERNET 权限。因此，您需要以下权限才能使用 Wi-Fi Direct：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.nsdchat"
    ...
    <!-- If your app targets Android 13 (API level 33)
         or higher, you must declare the NEARBY_WIFI_DEVICES permission. -->
        <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES"
        <!-- If your app derives location information from Wi-Fi APIs,
             don't include the "usesPermissionFlags" attribute. -->
        android:usesPermissionFlags="neverForLocation" />
        
    <uses-permission
        android:required="true"
        android:name="android.permission.ACCESS_FINE_LOCATION"
        <!-- If any feature in your app relies on precise location information,
             don't include the "maxSdkVersion" attribute. -->
        android:maxSdkVersion="32" />
    <uses-permission
        android:required="true"
        android:name="android.permission.ACCESS_WIFI_STATE"/>
    <uses-permission
        android:required="true"
        android:name="android.permission.CHANGE_WIFI_STATE"/>
    <uses-permission
        android:required="true"
        android:name="android.permission.INTERNET"/>
    ...

除了上述权限之外，以下 API 还要求启用定位模式：

设置广播接收器和对等管理器

要使用 Wi-Fi Direct，您需要监听广播 intent，它们会在某些事件发生时通知您的应用。在您的应用中，实例化一个 IntentFilter，并将其设置为监听以下内容：

WIFI_P2P_STATE_CHANGED_ACTION: 指示 Wi-Fi Direct 是否已启用。
WIFI_P2P_PEERS_CHANGED_ACTION: 指示可用对等设备列表已更改。
WIFI_P2P_CONNECTION_CHANGED_ACTION: 指示 Wi-Fi Direct 连接状态已更改。从 Android 10 开始，这不是粘性广播。如果您的应用依赖于在注册时接收这些广播（因为它们曾经是粘性的），请改为在初始化时使用相应的 get 方法获取信息。
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: 指示此设备的配置详细信息已更改。从 Android 10 开始，这不是粘性广播。如果您的应用依赖于在注册时接收这些广播（因为它们曾经是粘性的），请改为在初始化时使用相应的 get 方法获取信息。

Kotlin

private val intentFilter = IntentFilter()
...
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main)

    // Indicates a change in the Wi-Fi Direct status.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)

    // Indicates a change in the list of available peers.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)

    // Indicates the state of Wi-Fi Direct connectivity has changed.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)

    // Indicates this device's details have changed.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
    ...
}

Java

private final IntentFilter intentFilter = new IntentFilter();
...
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    // Indicates a change in the Wi-Fi Direct status.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);

    // Indicates a change in the list of available peers.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);

    // Indicates the state of Wi-Fi Direct connectivity has changed.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);

    // Indicates this device's details have changed.
    intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
    ...
}

在 onCreate() 方法的末尾，获取 WifiP2pManager 的实例，并调用其 initialize() 方法。此方法返回一个 WifiP2pManager.Channel 对象，您稍后将使用它来将应用连接到 Wi-Fi Direct 框架。

Kotlin

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

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    manager = getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager
    channel = manager.initialize(this, mainLooper, null)
}

Java

Channel channel;
WifiP2pManager manager;

@Override
public void onCreate(Bundle savedInstanceState) {
    ...
    manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
    channel = manager.initialize(this, getMainLooper(), null);
}

现在创建一个新的 BroadcastReceiver 类，您将使用它来监听系统 Wi-Fi 状态的变化。在 onReceive() 方法中，添加一个条件来处理上面列出的每个状态更改。

Kotlin

override fun onReceive(context: Context, intent: Intent) {
    when(intent.action) {
        WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> {
            // Determine if Wi-Fi Direct mode is enabled or not, alert
            // the Activity.
            val state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1)
            activity.isWifiP2pEnabled = state == WifiP2pManager.WIFI_P2P_STATE_ENABLED
        }
        WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {

            // The peer list has changed! We should probably do something about
            // that.

        }
        WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> {

            // Connection state changed! We should probably do something about
            // that.

        }
        WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION -> {
            (activity.supportFragmentManager.findFragmentById(R.id.frag_list) as DeviceListFragment)
                    .apply {
                        updateThisDevice(
                                intent.getParcelableExtra(
                                        WifiP2pManager.EXTRA_WIFI_P2P_DEVICE) as WifiP2pDevice
                        )
                    }
        }
    }
}

Java

@Override
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
        // Determine if Wi-Fi Direct mode is enabled or not, alert
        // the Activity.
        int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
        if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
            activity.setIsWifiP2pEnabled(true);
        } else {
            activity.setIsWifiP2pEnabled(false);
        }
    } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {

        // The peer list has changed! We should probably do something about
        // that.

    } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {

        // Connection state changed! We should probably do something about
        // that.

    } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
        DeviceListFragment fragment = (DeviceListFragment) activity.getFragmentManager()
                .findFragmentById(R.id.frag_list);
        fragment.updateThisDevice((WifiP2pDevice) intent.getParcelableExtra(
                WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));

    }
}

最后，在主 Activity 处于活动状态时，添加代码来注册 intent 过滤器和广播接收器，并在 Activity 暂停时取消注册。执行此操作的最佳位置是 onResume() 和 onPause() 方法。

Kotlin

/** register the BroadcastReceiver with the intent values to be matched  */
public override fun onResume() {
    super.onResume()
    receiver = WiFiDirectBroadcastReceiver(manager, channel, this)
    registerReceiver(receiver, intentFilter)
}

public override fun onPause() {
    super.onPause()
    unregisterReceiver(receiver)
}

Java

/** register the BroadcastReceiver with the intent values to be matched */
@Override
public void onResume() {
    super.onResume();
    receiver = new WiFiDirectBroadcastReceiver(manager, channel, this);
    registerReceiver(receiver, intentFilter);
}

@Override
public void onPause() {
    super.onPause();
    unregisterReceiver(receiver);
}

启动对等设备发现

要开始使用 Wi-Fi P2P 搜索附近的设备，请调用 discoverPeers()。此方法接受以下参数：

您在初始化对等管理器时收到的 WifiP2pManager.Channel
WifiP2pManager.ActionListener 的实现，其方法在发现成功和失败时由系统调用。

Kotlin

manager.discoverPeers(channel, object : WifiP2pManager.ActionListener {

    override fun onSuccess() {
        // Code for when the discovery initiation is successful goes here.
        // No services have actually been discovered yet, so this method
        // can often be left blank. Code for peer discovery goes in the
        // onReceive method, detailed below.
    }

    override fun onFailure(reasonCode: Int) {
        // Code for when the discovery initiation fails goes here.
        // Alert the user that something went wrong.
    }
})

Java

manager.discoverPeers(channel, new WifiP2pManager.ActionListener() {

    @Override
    public void onSuccess() {
        // Code for when the discovery initiation is successful goes here.
        // No services have actually been discovered yet, so this method
        // can often be left blank. Code for peer discovery goes in the
        // onReceive method, detailed below.
    }

    @Override
    public void onFailure(int reasonCode) {
        // Code for when the discovery initiation fails goes here.
        // Alert the user that something went wrong.
    }
});

请记住，这只会启动对等设备发现。discoverPeers() 方法会启动发现过程，然后立即返回。如果对等设备发现过程成功启动，系统会通过调用所提供操作监听器中的方法来通知您。此外，发现会一直处于活动状态，直到启动连接或形成 P2P 群组。

获取对等设备列表

现在编写用于获取和处理对等设备列表的代码。首先实现 WifiP2pManager.PeerListListener 接口，该接口提供有关 Wi-Fi Direct 检测到的对等设备的信息。此信息还允许您的应用确定对等设备何时加入或离开网络。以下代码段演示了这些与对等设备相关的操作：

Kotlin

private val peers = mutableListOf<WifiP2pDevice>()
...

private val peerListListener = WifiP2pManager.PeerListListener { peerList ->
    val refreshedPeers = peerList.deviceList
    if (refreshedPeers != peers) {
        peers.clear()
        peers.addAll(refreshedPeers)

        // If an AdapterView is backed by this data, notify it
        // of the change. For instance, if you have a ListView of
        // available peers, trigger an update.
        (listAdapter as WiFiPeerListAdapter).notifyDataSetChanged()

        // Perform any other updates needed based on the new list of
        // peers connected to the Wi-Fi P2P network.
    }

    if (peers.isEmpty()) {
        Log.d(TAG, "No devices found")
        return@PeerListListener
    }
}

Java

private List<WifiP2pDevice> peers = new ArrayList<WifiP2pDevice>();
...

private PeerListListener peerListListener = new PeerListListener() {
    @Override
    public void onPeersAvailable(WifiP2pDeviceList peerList) {

        List<WifiP2pDevice> refreshedPeers = peerList.getDeviceList();
        if (!refreshedPeers.equals(peers)) {
            peers.clear();
            peers.addAll(refreshedPeers);

            // If an AdapterView is backed by this data, notify it
            // of the change. For instance, if you have a ListView of
            // available peers, trigger an update.
            ((WiFiPeerListAdapter) getListAdapter()).notifyDataSetChanged();

            // Perform any other updates needed based on the new list of
            // peers connected to the Wi-Fi P2P network.
        }

        if (peers.size() == 0) {
            Log.d(WiFiDirectActivity.TAG, "No devices found");
            return;
        }
    }
}

现在修改您的广播接收器的 onReceive() 方法，当收到带有动作 WIFI_P2P_PEERS_CHANGED_ACTION 的 intent 时，调用 requestPeers()。您需要以某种方式将此监听器传递给接收器。一种方法是将其作为参数传递给广播接收器的构造函数。

Kotlin

fun onReceive(context: Context, intent: Intent) {
    when (intent.action) {
        ...
        WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {

            // Request available peers from the wifi p2p manager. This is an
            // asynchronous call and the calling activity is notified with a
            // callback on PeerListListener.onPeersAvailable()
            mManager?.requestPeers(channel, peerListListener)
            Log.d(TAG, "P2P peers changed")


        }
        ...
    }
}

Java

public void onReceive(Context context, Intent intent) {
    ...
    else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {

        // Request available peers from the wifi p2p manager. This is an
        // asynchronous call and the calling activity is notified with a
        // callback on PeerListListener.onPeersAvailable()
        if (mManager != null) {
            mManager.requestPeers(channel, peerListListener);
        }
        Log.d(WiFiDirectActivity.TAG, "P2P peers changed");
    }...
}

现在，带有动作 WIFI_P2P_PEERS_CHANGED_ACTION 的 intent 会触发对更新对等设备列表的请求。

连接到对等设备

要连接到对等设备，请创建一个新的 WifiP2pConfig 对象，并将您要连接的设备所对应的 WifiP2pDevice 中的数据复制到其中。然后调用 connect() 方法。

Kotlin

override fun connect() {
    // Picking the first device found on the network.
    val device = peers[0]

    val config = WifiP2pConfig().apply {
        deviceAddress = device.deviceAddress
        wps.setup = WpsInfo.PBC
    }

    manager.connect(channel, config, object : WifiP2pManager.ActionListener {

        override fun onSuccess() {
            // WiFiDirectBroadcastReceiver notifies us. Ignore for now.
        }

        override fun onFailure(reason: Int) {
            Toast.makeText(
                    this@WiFiDirectActivity,
                    "Connect failed. Retry.",
                    Toast.LENGTH_SHORT
            ).show()
        }
    })
}

Java

@Override
public void connect() {
    // Picking the first device found on the network.
    WifiP2pDevice device = peers.get(0);

    WifiP2pConfig config = new WifiP2pConfig();
    config.deviceAddress = device.deviceAddress;
    config.wps.setup = WpsInfo.PBC;

    manager.connect(channel, config, new ActionListener() {

        @Override
        public void onSuccess() {
            // WiFiDirectBroadcastReceiver notifies us. Ignore for now.
        }

        @Override
        public void onFailure(int reason) {
            Toast.makeText(WiFiDirectActivity.this, "Connect failed. Retry.",
                    Toast.LENGTH_SHORT).show();
        }
    });
}

如果您的群组中的每个设备都支持 Wi-Fi Direct，则在连接时无需明确要求群组密码。但是，要允许不支持 Wi-Fi Direct 的设备加入群组，您需要通过调用 requestGroupInfo() 来检索此密码，如下面的代码段所示：

Kotlin

manager.requestGroupInfo(channel) { group ->
    val groupPassword = group.passphrase
}

Java

manager.requestGroupInfo(channel, new GroupInfoListener() {
  @Override
  public void onGroupInfoAvailable(WifiP2pGroup group) {
      String groupPassword = group.getPassphrase();
  }
});

请注意，WifiP2pManager.ActionListener 在 connect() 方法中实现的，只会在启动成功或失败时通知您。要监听连接状态的变化，请实现 WifiP2pManager.ConnectionInfoListener 接口。其 onConnectionInfoAvailable() 回调会在连接状态更改时通知您。在多个设备将连接到一个设备的情况下（例如有三个或更多玩家的游戏，或聊天应用），一个设备被指定为“群主”。您可以通过遵循创建群组部分中的步骤，将特定设备指定为网络的群主。

Kotlin

private val connectionListener = WifiP2pManager.ConnectionInfoListener { info ->

    // String from WifiP2pInfo struct
    val groupOwnerAddress: String = info.groupOwnerAddress.hostAddress

    // After the group negotiation, we can determine the group owner
    // (server).
    if (info.groupFormed && info.isGroupOwner) {
        // Do whatever tasks are specific to the group owner.
        // One common case is creating a group owner thread and accepting
        // incoming connections.
    } else if (info.groupFormed) {
        // The other device acts as the peer (client). In this case,
        // you'll want to create a peer thread that connects
        // to the group owner.
    }
}

Java

@Override
public void onConnectionInfoAvailable(final WifiP2pInfo info) {

    // String from WifiP2pInfo struct
    String groupOwnerAddress = info.groupOwnerAddress.getHostAddress();

    // After the group negotiation, we can determine the group owner
    // (server).
    if (info.groupFormed && info.isGroupOwner) {
        // Do whatever tasks are specific to the group owner.
        // One common case is creating a group owner thread and accepting
        // incoming connections.
    } else if (info.groupFormed) {
        // The other device acts as the peer (client). In this case,
        // you'll want to create a peer thread that connects
        // to the group owner.
    }
}

现在回到广播接收器的 onReceive() 方法，并修改监听 WIFI_P2P_CONNECTION_CHANGED_ACTION intent 的部分。收到此 intent 时，调用 requestConnectionInfo()。这是一个异步调用，因此结果将由您作为参数提供的连接信息监听器接收。

Kotlin

when (intent.action) {
    ...
    WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> {

        // Connection state changed! We should probably do something about
        // that.

        mManager?.let { manager ->

            val networkInfo: NetworkInfo? = intent
                    .getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO) as NetworkInfo

            if (networkInfo?.isConnected == true) {

                // We are connected with the other device, request connection
                // info to find group owner IP

                manager.requestConnectionInfo(channel, connectionListener)
            }
        }
    }
    ...
}

Java

    ...
    } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {

        if (manager == null) {
            return;
        }

        NetworkInfo networkInfo = (NetworkInfo) intent
                .getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);

        if (networkInfo.isConnected()) {

            // We are connected with the other device, request connection
            // info to find group owner IP

            manager.requestConnectionInfo(channel, connectionListener);
        }
        ...

创建群组

如果您希望运行您的应用的设备作为包含旧版设备（即不支持 Wi-Fi Direct 的设备）的网络的群主，您可以遵循与连接到对等设备部分相同的步骤，只是使用 createGroup() 而不是 connect() 来创建新的 WifiP2pManager.ActionListener。WifiP2pManager.ActionListener 中的回调处理方式相同，如下面的代码段所示：

Kotlin

manager.createGroup(channel, object : WifiP2pManager.ActionListener {
    override fun onSuccess() {
        // Device is ready to accept incoming connections from peers.
    }

    override fun onFailure(reason: Int) {
        Toast.makeText(
                this@WiFiDirectActivity,
                "P2P group creation failed. Retry.",
                Toast.LENGTH_SHORT
        ).show()
    }
})

Java

manager.createGroup(channel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        // Device is ready to accept incoming connections from peers.
    }

    @Override
    public void onFailure(int reason) {
        Toast.makeText(WiFiDirectActivity.this, "P2P group creation failed. Retry.",
                Toast.LENGTH_SHORT).show();
    }
});

注意：如果网络中的所有设备都支持 Wi-Fi Direct，您可以在每个设备上使用 connect() 方法，因为该方法会创建群组并自动选择群主。

创建群组后，您可以调用 requestGroupInfo() 以检索有关网络上对等设备的详细信息，包括设备名称和连接状态。

使用 Wi-Fi Direct 创建 P2P 连接 使用收藏集保持井然有序 根据您的偏好保存内容并进行分类。

设置应用权限

设置广播接收器和对等管理器

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

启动对等设备发现

Kotlin

Java

获取对等设备列表

Kotlin

Java

Kotlin

Java

连接到对等设备

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

创建群组

Kotlin

Java

使用 Wi-Fi Direct 创建 P2P 连接