Android wifidirect discovery在后台服务中多次发现相同的对等点

我一直在尝试发现多个对等点——多次在后台服务中而不是在活动中。大致基于此：

因为，一旦接收到对等方的广告服务，如果该对等方离开并返回到范围内，则不会重新出现。我之所以需要重新发现相同的对等点，是因为我正在根据应用程序的使用情况更改TXT记录值。需要重新公布，并且接收设备使用新值更新本地文件

尽管如此，我还是设法以一种不可靠的方式实现了这一点。 通过，删除localservice和serviceRequest，并使用处理程序重新启动注册和发现

但是，我注意到一些早期的广告被汇集在一起，即使广告设备停止了广告，TXT侦听器也不会连接，有时还会继续显示。这会在添加本地服务和服务发现请求时导致WifiP2pManager忽略警告。因此，侦听器有时不会收到广告，而在禁用Wifi的情况下会一直收到广告

01-06 17:14:34.324  26591-26591/com.cutting.chai.wifi D/WifiP2pManager﹕ Ignored { when=-25ms what=139313 target=android.net.wifi.p2p.WifiP2pManager$Channel$P2pHandler }
[ 01-06 17:14:34.324 26591:26591 D/Status] Added Local Service
01-06 17:14:34.324  26591-26591/com.cutting.chai.wifi D/WifiP2pManager﹕ Ignored { when=-25ms what=139313 target=android.net.wifi.p2p.WifiP2pManager$Channel$P2pHandler }
01-06 17:14:34.324  26591-26591/com.cutting.chai.wifi D/WifiP2pManager﹕ Ignored { when=-26ms what=139313 target=android.net.wifi.p2p.WifiP2pManager$Channel$P2pHandler }
[ 01-06 17:14:34.324 26591:26591 D/Status]  Added service discovery request

下面是我的代码：

public class WifiDirectDiscoverService extends Service{


public static final String TAG = "wifidirectservicedemo";

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


private WifiP2pManager manager;


private final IntentFilter intentFilter = new IntentFilter();
private WifiP2pManager.Channel channel;
private BroadcastReceiver mReceiver;
private WifiP2pDnsSdServiceRequest serviceRequest;
WifiP2pDnsSdServiceInfo service;

/* Preferences to get user data to set the advertisement record */
private ccSharedPreferences sharedPreferences;
private String[] interestCodes;
private String[] hobbyCodes;


Handler mHandler = new Handler();


@Override
public IBinder onBind(Intent arg0) {

    return null;
}

public void onCreate() {
    super.onCreate();
    Log.d("Server", ">>>onCreate()");
}



final Runnable ToastRunnable = new Runnable(){
    public void run(){
        Toast.makeText(getApplicationContext(), "discover service",
                Toast.LENGTH_LONG).show();



        manager.removeLocalService(channel, service, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess () {
                appendStatus("Remove Local Service");
            }

            @Override
            public void onFailure ( int error){
                appendStatus("Failed to remove a service "+error);
            }
        });


        manager.removeServiceRequest(channel, serviceRequest, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                appendStatus("Clear Service Requests");
            }

            @Override
            public void onFailure(int error) {
                appendStatus("Failed to clear Service Requests "+error);
            }
        });


        startRegistration();
        setupListener();
        initiateDiscovery();

        mHandler.postDelayed(ToastRunnable, 15000);
    }
};


@Override
public int onStartCommand(Intent intent, int flags, int startId) {

    super.onStartCommand(intent, startId, startId);

    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(getApplicationContext(), getMainLooper(), null);

    mReceiver = new WiFiDirectBroadcastReceiver(manager, channel, WifiDirectDiscoverService.this);
    registerReceiver(mReceiver, intentFilter);

    startRegistration();
    setupListener();
    initiateDiscovery();

    mHandler.postDelayed(ToastRunnable, 10000);

    return START_STICKY;

}


/**
 * Registers a local service and then initiates a service discovery
 */
private void startRegistration() {

    sharedPreferences = new ccSharedPreferences();

    Map<String, String> record = new HashMap<>();



    record.put(TXTRECORD_PROP_AVAILABLE, "visible");



    int size = record.toString().length();


    Toast.makeText(getApplicationContext(), size + " bytes record ", Toast.LENGTH_LONG).show();

    service = WifiP2pDnsSdServiceInfo.newInstance(
            SERVICE_INSTANCE, SERVICE_REG_TYPE, record);

    manager.addLocalService(channel, service, new WifiP2pManager.ActionListener() {

        @Override
        public void onSuccess() {
            appendStatus("Added Local Service");
        }

        @Override
        public void onFailure(int error) {
            appendStatus("Failed to add a service "+error);
        }
    });

}

private void setupListener() {

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

    WifiP2pManager.DnsSdTxtRecordListener txtListener = new WifiP2pManager.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) {


                        if (record.get(TXTRECORD_PROP_AVAILABLE) != null) {
                            Log.d(TAG,
                                    device.deviceName + " is "
                                            + record.get(TXTRECORD_PROP_AVAILABLE));

                            Toast.makeText(getApplicationContext(), device.deviceName + " is " + record.get(TXTRECORD_PROP_AVAILABLE), Toast.LENGTH_LONG).show();

                            Toast.makeText(getApplicationContext(), "Advertised Service is " + record.toString(), Toast.LENGTH_LONG).show();
                            Log.d("Record", record.toString());



                        }

                    }
                };


    WifiP2pManager.DnsSdServiceResponseListener servListener = new WifiP2pManager.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.

                WiFiP2pService service = new WiFiP2pService();
                service.device = srcDevice;
                service.instanceName = instanceName;
                service.serviceRegistrationType = registrationType;


                Log.d(TAG, "onBonjourServiceAvailable "
                        + instanceName);

                Toast.makeText(getApplicationContext(), service.device + " is around ", Toast.LENGTH_LONG).show();
                Toast.makeText(getApplicationContext(), instanceName + " is the instance name ", Toast.LENGTH_LONG).show();


            }

        }
    };




    manager.setDnsSdResponseListeners(channel, servListener, txtListener);


}

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

                @Override
                public void onSuccess() {
                    appendStatus("Added service discovery request");
                }

                @Override
                public void onFailure(int arg0) {
                    appendStatus("Failed adding service discovery request "+arg0);
                }
            });

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

        @Override
        public void onSuccess() {
            appendStatus("Service discovery initiated");
        }

        @Override
        public void onFailure(int arg0) {
            appendStatus("Service discovery failed "+arg0);

        }
    });

}

public void appendStatus(String status) {
    Log.d("Status" + "\n", status);
}

@Override
public void onDestroy() {
    Toast.makeText(this, "service onDestroy", Toast.LENGTH_LONG).show();
    mHandler.removeCallbacksAndMessages(null);
}
}

public类WifiDirectDiscoverService扩展服务{
公共静态最终字符串TAG=“wifidirectservicedemo”；
//TXT记录属性
公共静态最终字符串TXTRECORD_PROP_AVAILABLE=“AVAILABLE”；
公共静态最终字符串服务\u实例=“\u ccwifidirect”；
公共静态最终字符串服务\u REG\u TYPE=“\u presence.\u tcp”；
私人WifiP2pManager经理；
私有最终IntentFilter IntentFilter=新IntentFilter（）；
私有WifiP2pManager.Channel；
专用广播接收机；
私有WifiP2pDnsSdServiceRequest服务请求；
WifiP2pDnsSdServiceInfo服务；
/*获取用户数据以设置广告记录的首选项*/
私人CCSharedReferences SharedReferences；
私有字符串[]兴趣码；
私有字符串[]霍比码；
Handler mHandler=新的Handler（）；
@凌驾
公共IBinder onBind（意图arg0）{
返回null；
}
public void onCreate（）{
super.onCreate（）；
Log.d（“服务器”，即“>>>onCreate（）”；
}
最终可运行到可运行表=新可运行（）{
公开募捐{
Toast.makeText（getApplicationContext（），“发现服务”，
Toast.LENGTH_LONG）.show（）；
manager.removeLocalService（通道、服务、新WifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
附件状态（“删除本地服务”）；
}
@凌驾
公共void onFailure（int错误）{
appendStatus（“删除服务失败”+错误）；
}
});
manager.removeServiceRequest（通道，serviceRequest，新的WifiP2pManager.ActionListener（）{
@凌驾
成功时的公共无效（）{
附件状态（“清除服务请求”）；
}
@凌驾
公共void onFailure（int错误）{
appendStatus（“清除服务请求失败”+错误）；
}
});
startRegistration（）；
setupListener（）；
发起调查（）；
mHandler.postDelayed（到2020年，15000）；
}
};
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
super.onStartCommand（intent、startId、startId）；
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（getApplicationContext（），getMainLooper（），null）；
mReceiver=新的WiFiDirectBroadcastReceiver（管理器、频道、WifiDirectDiscoverService.this）；
注册接收者（mReceiver，intentFilter）；
startRegistration（）；
setupListener（）；
发起调查（）；
mHandler.postDelayed（到2020年，10000）；
返回开始时间；
}
/**
*注册本地服务，然后启动服务发现
*/
私人作废startRegistration（）{
SharedReferences=新的CCSharedReferences（）；
映射记录=新的HashMap（）；
记录。放置（TXTRECORD_PROP_可用，“可见”）；
int size=record.toString（）.length（）；
Toast.makeText（getApplicationContext（），大小+字节记录），Toast.LENGTH\u LONG.show（）；
service=WifiP2pDnsSdServiceInfo.newInstance(
服务实例、服务注册类型、记录）；
addLocalService（频道、服务、新的WifiP2pManager.ActionListener（）的名称）{
@凌驾
成功时的公共无效（）{
附件状态（“添加的本地服务”）；
}
@凌驾
公共void onFailure（int错误）{
appendStatus（“添加服务失败”+错误）；
}
});
}
私有void setupListener（）{
/*
*为DNS-SD服务注册侦听器。这些是调用的回调
*在实际发现服务时由系统执行。
*/
WifiP2pManager.DnsSdTxtRecordListener txtListener=新建WifiP2pManager.DnsSdTxtRecordListener（）{
/**
*一个新的TXT记录可用。拿起广告
*好友姓名。
*/
@凌驾
公共无效onDnsSdTxtRecordAvailable(
字符串fullDomainName，映射记录，
WIFIP2P（设备设备）{
if（record.get（TXTRECORD\u PROP\u可用）！=null）{
Log.d（标签，
deviceName+“是”
+获取（TXTRECORD_PROP_可用））；
烤面包