Java WIFI直接发现未找到对等点

我得到了一个wifidirect应用程序，它成功地发现并连接到一个对等应用程序，我将该应用程序“附加”到我正在开发的另一个应用程序上。该应用程序本应通过蓝牙控制机器人，同时通过Wifidirect进行通信，它有一个“播放按钮”，当点击时，它会转到另一个活动，该活动有两个片段，一个是在点击“播放”按钮后出现的第一个片段，并要求用户连接到对等方（这是我连接的wifidirect应用程序），连接后进入第二个片段，这个片段有游戏界面，它有所有的蓝牙部分（连接和控制机器人）

总而言之：第一个活动有一个播放按钮，点击按钮后，它将转到第二个活动，带有两个片段。第二个活动必须使用Wifidirect连接到对等方，然后必须使用蓝牙连接和控制机器人

在第二个活动中，WifiDirect和Bluetooth通信同时发生（令人困惑…我知道）

我的问题是：如果我只使用Wifidirect应用程序，它搜索和连接都很成功，但通过两个应用程序的“融合”，它永远搜索不到任何东西。你知道发生了什么吗？可能是很多通信或同一活动中发生的许多事情？如果我感到困惑，请告诉我

我的Wifidiscovery活动：

public class WiFiServiceDiscoveryActivity extends Activity implements
    DeviceClickListener, Handler.Callback, MessageTarget,
    ConnectionInfoListener {

public static final String TAG = "wifidirectdemo";

// TXT RECORD properties
public static final String TXTRECORD_PROP_AVAILABLE = "available";
public static final String SERVICE_INSTANCE = "_wifidemotest";
public static final String SERVICE_REG_TYPE = "_presence._tcp";

public static final int MESSAGE_READ = 0x400 + 1;
public static final int MY_HANDLE = 0x400 + 2;
private WifiP2pManager manager;

static final int SERVER_PORT = 4545;

private final IntentFilter intentFilter = new IntentFilter();
private Channel channel;
private BroadcastReceiver receiver = null;
private WifiP2pDnsSdServiceRequest serviceRequest;

private Handler handler = new Handler(this);
private jogar chatFragment;
private WiFiDirectServicesList servicesList;

private TextView statusTxtView;
Button botaorecomecar;

public Handler getHandler() {
    return handler;
}

public void setHandler(Handler handler) {
    this.handler = handler;
}

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    statusTxtView = (TextView) findViewById(R.id.status_text);
    botaorecomecar = (Button) findViewById(R.id.botaorecomecar);

    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);

    manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
    channel = manager.initialize(this, getMainLooper(), null);
    startRegistrationAndDiscovery();

    servicesList = new WiFiDirectServicesList();
    getFragmentManager().beginTransaction()
            .add(R.id.container_root, servicesList, "services").commit();

    botaorecomecar.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent = getIntent();
            finish();
            startActivity(intent);
        }


    });}





@Override
protected void onRestart() {
    Fragment frag = getFragmentManager().findFragmentByTag("services");
    if (frag != null) {
        getFragmentManager().beginTransaction().remove(frag).commit();
    }
    super.onRestart();
}

@Override
protected void onStop() {
    if (manager != null && channel != null) {
        manager.removeGroup(channel, new ActionListener() {

            @Override
            public void onFailure(int reasonCode) {
                Log.d(TAG, "Disconecção falhada. Razão: :" + reasonCode);
            }

            @Override
            public void onSuccess() {
            }

        });
    }
    super.onStop();
}

/**
 * Registers a local service and then initiates a service discovery
 */
private void startRegistrationAndDiscovery() {
    Map<String, String> record = new HashMap<String, String>();
    record.put(TXTRECORD_PROP_AVAILABLE, "visivel");

    WifiP2pDnsSdServiceInfo service = WifiP2pDnsSdServiceInfo.newInstance(
            SERVICE_INSTANCE, SERVICE_REG_TYPE, record);
    manager.addLocalService(channel, service, new ActionListener() {

        @Override
        public void onSuccess() {
            appendStatus("Serviço local adicionado");
        }

        @Override
        public void onFailure(int error) {
            appendStatus("Falha ao adicionar serviço");
        }
    });

    discoverService();

}

private void discoverService() {

    /*
     * Register listeners for DNS-SD services. These are callbacks invoked
     * by the system when a service is actually discovered.
     */

    manager.setDnsSdResponseListeners(channel,
            new DnsSdServiceResponseListener() {

                @Override
                public void onDnsSdServiceAvailable(String instanceName,
                                                    String registrationType, WifiP2pDevice srcDevice) {

                    // A service has been discovered. Is this our app?

                    if (instanceName.equalsIgnoreCase(SERVICE_INSTANCE)) {

                        // update the UI and add the item the discovered
                        // device.
                        WiFiDirectServicesList fragment = (WiFiDirectServicesList) getFragmentManager()
                                .findFragmentByTag("serviços");
                        if (fragment != null) {
                            WiFiDevicesAdapter adapter = ((WiFiDevicesAdapter) fragment
                                    .getListAdapter());
                            WiFiP2pService service = new WiFiP2pService();
                            service.device = srcDevice;
                            service.instanceName = instanceName;
                            service.serviceRegistrationType = registrationType;
                            adapter.add(service);
                            adapter.notifyDataSetChanged();
                            Log.d(TAG, "onBonjourServiceAvailable "
                                    + instanceName);
                        }
                    }

                }
            }, new DnsSdTxtRecordListener() {

                /**
                 * A new TXT record is available. Pick up the advertised
                 * buddy name.
                 */
                @Override
                public void onDnsSdTxtRecordAvailable(
                        String fullDomainName, Map<String, String> record,
                        WifiP2pDevice device) {
                    Log.d(TAG,
                            device.deviceName + " é "
                                    + record.get(TXTRECORD_PROP_AVAILABLE));
                }
            });

    // After attaching listeners, create a service request and initiate
    // discovery.
    serviceRequest = WifiP2pDnsSdServiceRequest.newInstance();
    manager.addServiceRequest(channel, serviceRequest,
            new ActionListener() {

                @Override
                public void onSuccess() {
                    appendStatus("Adicionado pedido de descoberta de serviços");
                }

                @Override
                public void onFailure(int arg0) {
                    appendStatus("Falha ao adicionar pedido de descoberta de serviços");
                }
            });
    manager.discoverServices(channel, new ActionListener() {

        @Override
        public void onSuccess() {
            appendStatus("Descoberta de serviços iniciada");
        }

        @Override
        public void onFailure(int arg0) {
            appendStatus("Descoberta de serviços falhada");

        }
    });
}

@Override
public void connectP2p(WiFiP2pService service) {
    WifiP2pConfig config = new WifiP2pConfig();
    config.deviceAddress = service.device.deviceAddress;
    config.wps.setup = WpsInfo.PBC;
    if (serviceRequest != null)
        manager.removeServiceRequest(channel, serviceRequest,
                new ActionListener() {

                    @Override
                    public void onSuccess() {
                    }

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

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

        @Override
        public void onSuccess() {
            appendStatus("A conectar a um serviço");
        }

        @Override
        public void onFailure(int errorCode) {
            appendStatus("Falha ao conectar a serviço");
        }
    });
}

@Override
public boolean handleMessage(Message msg) {
    switch (msg.what) {
        case MESSAGE_READ:
            byte[] readBuf = (byte[]) msg.obj;
            // construct a string from the valid bytes in the buffer
            String readMessage = new String(readBuf, 0, msg.arg1);
            Log.d(TAG, readMessage);
            (chatFragment).pushMessage(readMessage);
            break;

        case MY_HANDLE:
            Object obj = msg.obj;
            (chatFragment).setChatManager((ChatManager) obj);

    }
    return true;
}

@Override
public void onResume() {
    super.onResume();
    receiver = new WiFiDirectBroadcastReceiver(manager, channel, this);
    registerReceiver(receiver, intentFilter);
}

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

@Override
public void onConnectionInfoAvailable(WifiP2pInfo p2pInfo) {
    Thread handler = null;
    /*
     * The group owner accepts connections using a server socket and then spawns a
     * client socket for every client. This is handled by {@code
     * GroupOwnerSocketHandler}
     */

    if (p2pInfo.isGroupOwner) {
        Log.d(TAG, "Conectado como GroupOwner");
        try {
            handler = new GroupOwnerSocketHandler(
                    ((MessageTarget) this).getHandler());
            handler.start();
        } catch (IOException e) {
            Log.d(TAG,
                    "Falha ao criar uma thread de servidor - " + e.getMessage());
            return;
        }
    } else {
        Log.d(TAG, "Conectado como peer");
        handler = new ClientSocketHandler(
                ((MessageTarget) this).getHandler(),
                p2pInfo.groupOwnerAddress);
        handler.start();
    }
    chatFragment = new jogar();
    getFragmentManager().beginTransaction()
            .replace(R.id.container_root, chatFragment).commit();
    statusTxtView.setVisibility(View.GONE);
}

public void appendStatus(String status) {
    String current = statusTxtView.getText().toString();
    statusTxtView.setText(current + "\n" + status);
}

公共类WiFiServiceDiscoveryActivity扩展了活动实现
DeviceClickListener、Handler.Callback、MessageTarget、，
连接信息侦听器{
公共静态最终字符串TAG=“wifidirectdemo”；
//TXT记录属性
公共静态最终字符串TXTRECORD_PROP_AVAILABLE=“AVAILABLE”；
公共静态最终字符串服务\u实例=“\u wifidemotest”；
公共静态最终字符串服务\u REG\u TYPE=“\u presence.\u tcp”；
公共静态最终整型消息_READ=0x400+1；
公共静态final int MY_HANDLE=0x400+2；
私人WifiP2pManager经理；
静态最终int服务器_端口=4545；
私有最终IntentFilter IntentFilter=新IntentFilter（）；
专用信道；
专用广播接收器=空；
私有WifiP2pDnsSdServiceRequest服务请求；
私有处理程序=新处理程序（此）；
私人乔加查特酒店；
私人WiFiDirectServicesList服务列表；
私有文本视图状态txtview；
按钮BotaoRececar；
公共处理程序getHandler（）{
返回处理程序；
}
公共void setHandler（处理程序）{
this.handler=handler；
}
/**在首次创建活动时调用*/
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
statusTxtView=（TextView）findViewById（R.id.status\u text）；
BotaoRecoecar=（按钮）findViewById（R.id.BotaoRecoecar）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u STATE\u CHANGED\u ACTION）；
intentFilter.addAction（WifiP2pManager.WIFI\u P2P\u PEERS\u CHANGED\u ACTION）；
意向过滤器
.addAction（WifiP2pManager.WIFI\u P2P\u连接\u更改\u操作）；
意向过滤器
.addAction（WifiP2pManager.WIFI\u P2P\u此设备\u更改\u操作）；
manager=（WifiP2pManager）getSystemService（Context.WIFI\u P2P\u服务）；
channel=manager.initialize（this，getMainLooper（），null）；
startRegistrationAndDiscovery（）；
servicesList=newwifidirectserviceslist（）；
getFragmentManager（）.beginTransaction（）
.add（R.id.container_root，servicesList，“services”）.commit（）；
botaorecocar.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
Intent=getIntent（）；
完成（）；
星触觉（意向）；
}
});}
@凌驾
受保护的void onRestart（）{
Fragment frag=getFragmentManager（）.findFragmentByTag（“服务”）；
如果（frag！=null）{
getFragmentManager（）.beginTransaction（）.remove（frag.commit（）；
}
super.onRestart（）；
}
@凌驾
受保护的void onStop（）{
if（manager！=null&&channel！=null）{
manager.removeGroup（频道，新ActionListener（）{
@凌驾
公共失效失效失效（int推理代码）{
Log.d（标签“Disconecão falhada.Razão:：”+推理代码）；
}
@凌驾
成功时的公共无效（）{
}
});
}
super.onStop（）；
}
/**
*注册本地服务，然后启动服务发现
*/
私有无效startRegistrationAndDiscovery（）{
映射记录=新的HashMap（）；
记录。放置（TXTRECORD_PROP_可用，“visivel”）；
WifiP2pDnsSdServiceInfo服务=WifiP2pDnsSdServiceInfo.newInstance(
服务实例、服务注册类型、记录）；
addLocalService（频道、服务、新ActionListener（）{
@凌驾
成功时的公共无效（）{
附录状态（“服务本地adicionado”）；
}
@凌驾
公共void onFailure（int错误）{
附录状态（“Falha ao adicionar serviço”）；
}
});
discoverService（）；
}
私有void discoverService（）{
/*
*为DNS-SD服务注册侦听器。这些是调用的回调
*在实际发现服务时由系统执行。
*/
manager.setDnsSdResponseListeners（频道，
新的DnsSdServiceResponseListener（）{
@凌驾
公共无效onDnsSdServiceAvailable（字符串instanceName，
字符串注册类型，WifiP2pDevice（设备）{
//已发现服务。这是我们的应用程序吗？
if（instanceName.equalsIgnoreCase（服务\实例））{
//更新UI并添加发现的项
//装置。
WiFiDirectServicesList片段=（WiFiDirectServicesList）getFragmentManager（）
.findFragmentByTag（“ser
 // A service has been discovered. Is this our app?

 if (instanceName.equalsIgnoreCase(SERVICE_INSTANCE)) {