Обнаружение службы Wi-Fi P2P работает с перебоями

WifiP2p (в целом):

Некоторое время назад я разрабатывал приложение с довольно сложной системой сетевого подключения на основе WifiP2p с Service Broadcasting/Discovery. И, основываясь на этом опыте, я уже написал здесь на SO несколько постов о том, насколько это сложно, утомительно и проблематично. Вот два из них (они полны внутренних знаний, которые я получил о WifiP2p с Service Discovery и о самом WifiP2p):

Почему обнаружение пиров для Android WifiDirect так ненадежно

Wi-Fi P2P. Информировать всех доступных пиров о некотором событии

Я бы посоветовал вам прочитать оба моих ответа (хотя они немного больше сосредоточены на самом WifiP2p). Они должны дать вам некоторое представление о вещах, которые вы должны искать при работе с WifiP2p Service Discovery. Я могу легко сказать, что если вы хотите построить эффективную, относительно надежную и надежную систему соединения WifiP2p (особенно с Service Discovery), вам придется попотеть.

WifiP2p Service Discovery:

Чтобы лучше ответить на ваш точный вопрос, я расскажу вам, что я сделал (в отличие от вас), чтобы мой Service Discovery работал довольно надежно.

1. Трансляция Service:

Прежде всего: перед регистрацией вашего Service (методом addLocalService) вы должны использовать метод clearLocalServices WifiP2pManager. И важно, чтобы вы только вызывали addLocalService, если прослушиватель передал clearLocalServices, возвращенный с обратным вызовом onSuccess.

Хотя это довольно хорошо настраивает широковещательную рассылку, я обнаружил, что другие узлы не всегда могли обнаружить широковещательный service (особенно когда эти узлы еще не обнаруживали активно службы в момент регистрации вашего локального Service, но они «присоединились» позже). ). Я не мог найти способ решить эту проблему на 100% надежно. И поверьте мне, я пытался, вероятно, все, что связано с WifiP2p. И нет, последовательность clearLocalServices-addLocalService не давала удовлетворительных результатов. Или даже больше: делать что-то другое работало намного лучше. Что я решил сделать, так это то, что после того, как я успешно добавил локальную службу (обратный вызов onSuccess от addLocalService), я запустил Thread, который периодически вызывал бы метод discoverPeers WifiP2pManager. Казалось, это вынуждало ретранслировать всю service информацию.

Итак... в основном код вашего вещания должен выглядеть более-менее так (имейте в виду, что каждый фрагмент кода, который я публикую здесь, лишен всех "проверок", если система сетевого подключения находится в правильном состоянии). государство, вы должны разработать их самостоятельно, чтобы они лучше всего соответствовали вашему решению):

public void startBroadcastingService(){
    mWifiP2pManager.clearLocalServices(mWifiP2pChannel, new WifiP2pManager.ActionListener() {
        @Override
        public void onSuccess() {
            mWifiP2pManager.addLocalService(mWifiP2pChannel, mWifiP2pServiceInfo,
                    new WifiP2pManager.ActionListener() {

                        @Override
                        public void onSuccess() {
                            // service broadcasting started
                            mServiceBroadcastingHandler
                                    .postDelayed(mServiceBroadcastingRunnable,
                                            SERVICE_BROADCASTING_INTERVAL);
                        }

                        @Override
                        public void onFailure(int error) {
                            // react to failure of adding the local service
                        }
                    });
        }

        @Override
        public void onFailure(int error) {
            // react to failure of clearing the local services
        }
    });
}

где должно быть mServiceBroadcastingRunnable:

private Runnable mServiceBroadcastingRunnable = new Runnable() {
    @Override
    public void run() {
        mWifiP2pManager.discoverPeers(mWifiP2pChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
            }

            @Override
            public void onFailure(int error) {
            }
        });
        mServiceBroadcastingHandler
                .postDelayed(mServiceBroadcastingRunnable, SERVICE_BROADCASTING_INTERVAL);
    }
};

2. Обнаружение Service:

Для обнаружения вашего service я использовал аналогичный подход. И с подставкой открытия, и с попыткой форсировать "переоткрытие" services.

Настройка производилась последовательностью следующих трех методов WifiP2pManager:

removeServiceRequest, addServiceRequest, discoverServices

Они вызывались именно в таком порядке, и конкретный метод (точнее, второй или третий) вызывался только после того, как предыдущий «возвратился» с обратным вызовом onSuccess.

Повторное открытие services производилось интуитивным методом (просто повторением указанной последовательности: removeServiceRequest -> addServiceRequest -> discoverServices).

База моего кода выглядела более-менее так (для запуска Service Discovery я сначала вызывал prepareServiceDiscovery(), а затем startServiceDiscovery()):

public void prepareServiceDiscovery() {
    mWifiP2pManager.setDnsSdResponseListeners(mWifiP2pChannel,
            new WifiP2pManager.DnsSdServiceResponseListener() {

                @Override
                public void onDnsSdServiceAvailable(String instanceName,
                                                    String registrationType, WifiP2pDevice srcDevice) {
                    // do all the things you need to do with detected service
                }
            }, new WifiP2pManager.DnsSdTxtRecordListener() {

                @Override
                public void onDnsSdTxtRecordAvailable(
                        String fullDomainName, Map<String, String> record,
                        WifiP2pDevice device) {
                    // do all the things you need to do with detailed information about detected service
                }
            });

    mWifiP2pServiceRequest = WifiP2pDnsSdServiceRequest.newInstance();
}

private void startServiceDiscovery() {
    mWifiP2pManager.removeServiceRequest(mWifiP2pChannel, mWifiP2pServiceRequest,
            new WifiP2pManager.ActionListener() {
                @Override
                public void onSuccess() {
                    mWifiP2pManager.addServiceRequest(mWifiP2pChannel, mWifiP2pServiceRequest,
                            new WifiP2pManager.ActionListener() {

                                @Override
                                public void onSuccess() {
                                    mWifiP2pManager.discoverServices(mWifiP2pChannel,
                                            new WifiP2pManager.ActionListener() {

                                                @Override
                                                public void onSuccess() {
                                                    //service discovery started

                                                    mServiceDiscoveringHandler.postDelayed(
                                                            mServiceDiscoveringRunnable,
                                                            SERVICE_DISCOVERING_INTERVAL);
                                                }

                                                @Override
                                                public void onFailure(int error) {
                                                    // react to failure of starting service discovery
                                                }
                                            });
                                }

                                @Override
                                public void onFailure(int error) {
                                    // react to failure of adding service request
                                }
                            });
                }

                @Override
                public void onFailure(int reason) {
                    // react to failure of removing service request
                }
            });
}

the mServiceDiscoveringRunnable was just:

private Runnable mServiceDiscoveringRunnable = new Runnable() {
    @Override
    public void run() {
        startServiceDiscovery();
    }
};

Все это заставило мою систему работать достаточно хорошо. Это еще не было совершенным, но из-за отсутствия документации по этому вопросу я думаю, что не мог сделать больше, чтобы улучшить его.

Если вы протестируете этот подход, обязательно расскажите мне, как он работает у вас (или работает ли он у вас ;)).

если проблема заключается в обнаружении службы, я считаю, что создание группы - лучший способ сделать устройство и службу обнаруживаемыми, но если создана группа на всех устройствах, вы не можете подключиться напрямую. но как сеть Wi-Fi. я делаю это каждый день, и это работает.