为什么为Android Wi-Fi Direct查找对等点如此不可靠？

我正在试用Android的Wi-Fi Direct（如果您愿意，也可以使用P2P）。我原以为它在我的两部手机之间工作得很好，但我意识到我在使用

WifiP2pManager.discoverPeers（）

和/或

WifiP2pManager.requestPeers（）

时遇到了问题。我观察到这些结果：

• 在1分钟以上的时间内，未发现对等点，也未触发回调。我也通过Android Wi-Fi设置的Wi-Fi Direct部分观察到了这一点。这很奇怪，因为有时发现几乎立即完成

• 我有一个Roku设备，手机B放在手机a旁边。虽然所有设备都连接到我的Wi-Fi，但Roku只在约10%的时间内出现，而手机a和B则在彼此之间出现

• 当我断开两部手机与所有Wi-Fi的连接并进行另一次扫描时，Roku出现了（！！！），但手机B直到我刷新至少十次后才出现

---

我的两部手机是Nexus 7（运行4.4.4）和Nexus 5（运行5.0）。

我最近一直在开发一款基于WiFi Direct（WiFi P2P服务发现）的连接系统的应用程序，我可以肯定的一点是，整个过程在未来是一个巨大的痛苦。主要是因为缺少文档，但也因为在开发基于wifi direct的解决方案时，在进行任何方法调用之前，您需要注意基本上所有的事情（尤其是来自侦听器的所有回调）

我想最让人讨厌的两件事是：

• 一个未记录的

  UNKNOWN\u错误

  （我认为它的

  int

  代码是

  -3

  ）正在方法中抛出。wifi守护进程本身似乎存在某种问题。唯一能阻止这种情况发生的方法是在你开始使用WiFi direct之前重置WiFi

• 您的方法调用处于错误状态-例如，如果您的广播接收器中没有接收到，或者如果“您的_设备”在中没有接收到正确的。这通常会导致调用您的一个s（例如，或失败原因）

---

通过每10秒请求一次对等发现，我能够“解决”一些手机没有出现的问题。我想我遇到这种情况是因为一部手机始终是主机，我没有费心让它发现同龄人（因为它不尝试加入他们），Wifi Direct将在主机手机上睡觉。我不会对对等结果做任何处理，但它会唤醒Wifi Direct系统。可能有更好的方法可以调用，但我不确定它是什么。如果让我猜的话，我会说我在浪费电池寿命。

根据我的经验，它是可靠的。经过大量的尝试，我得到了如下强大的可行流程：

...
wifiP2pManager.clearLocalServices(wifiP2pChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                HashMap<String, String> record = new HashMap<>();
                record.put("name", "Amos");
                WifiP2pDnsSdServiceInfo serviceInfo = WifiP2pDnsSdServiceInfo.newInstance(AppConfig.DNS_SD_SERVICE_NAME, AppConfig.DNS_SD_SERVICE_TYPE, record);
                wifiP2pManager.addLocalService(wifiP2pChannel, serviceInfo, new WifiP2pManager.ActionListener() {
                    @Override
                    public void onSuccess() {
                        wifiP2pManager.setDnsSdResponseListeners(wifiP2pChannel, WifiDirectFragment.this, WifiDirectFragment.this);
                        wifiP2pManager.clearServiceRequests(wifiP2pChannel, new WifiP2pManager.ActionListener() {
                            @Override
                            public void onSuccess() {
                                wifiP2pManager.addServiceRequest(wifiP2pChannel, WifiP2pDnsSdServiceRequest.newInstance(), new WifiP2pManager.ActionListener() {
                                    @Override
                                    public void onSuccess() {
                                        wifiP2pManager.discoverPeers(wifiP2pChannel, new WifiP2pManager.ActionListener() {
                                            @Override
                                            public void onSuccess() {
                                                wifiP2pManager.discoverServices(wifiP2pChannel, new WifiP2pManager.ActionListener() {
                                                    @Override
                                                    public void onSuccess() {
                                                        // this is my recursive discovery approach                                                            
                                                        handler.postDelayed(discoveryRunnable, AppConfig.DNS_SD_SERVICE_DISCOVERABLE_DURATION_S * 1000);
                                                    }

                                                    @Override
                                                    public void onFailure(int code) {
                                                    }
                                                });
                                            }

                                            @Override
                                            public void onFailure(int code) {
                                            }
                                        });
                                    }

                                    @Override
                                    public void onFailure(int code) {
                                    }
                                });
                            }

                            @Override
                            public void onFailure(int code) {
                            }
                        });
                    }

                    @Override
                    public void onFailure(int code) {
                    }
                });
            }

            @Override
            public void onFailure(int code) {
            }
        });

。。。
wifiP2pManager.clearLocalServices（wifiP2pChannel，新的wifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
HashMap记录=新建HashMap（）；
记录。填写（“名称”、“Amos”）；
WifiP2pDnsSdServiceInfo serviceInfo=WifiP2pDnsSdServiceInfo.newInstance（AppConfig.DNS\u SD\u SERVICE\u名称，AppConfig.DNS\u SD\u SERVICE\u类型，记录）；
wifiP2pManager.addLocalService（wifiP2pChannel，serviceInfo，新的wifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
wifiP2pManager.setDnsSdResponseListeners（wifip2pcchannel，WifiDirectFragment.this，WifiDirectFragment.this）；
wifiP2pManager.clearServiceRequests（wifiP2pChannel，新的wifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
wifiP2pManager.addServiceRequest（wifiP2pChannel，Wifip2pDNSSDSServiceRequest.newInstance（），new wifiP2pManager.ActionListener（））{
@凌驾
成功时的公共无效（）{
DiscoveryPeers（wifiP2pChannel，新的wifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
discoverServices（wifip2pcchannel，新的wifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
//这是我的递归发现方法
handler.postDelayed（discoveryRunnable，AppConfig.DNS\u SD\u SERVICE\u DISCOVERABLE\u DURATION\u S*1000）；
}
@凌驾
公共失效失效失效（内部代码）{
}
});
}
@凌驾
公共失效失效失效（内部代码）{
}
});
}
@凌驾
公共失效失效失效（内部代码）{
}
});
}
@凌驾
公共失效失效失效（内部代码）{
}
});
}
@凌驾
公共v