在完成无泄漏时终止来自AsyncTask的网络服务发现

Question

我正在尝试简单地找到一个带有MDN的设备，保存IP并杀死“网络服务发现”(NSD)一旦完成。

NSD和AsyncTask在这里冲突。

使用NSD获取IP是可行的，但如果AsyncTask不是静态的，它会警告泄漏。

如果AsyncTask是静态的，则NSD从onPostExecute（）表示；
非静态字段'mNSDManager'不能从静态上下文引用

如果我将AsyncTask设置为静态但必须注释掉MNSDManager.StopServiceDiscovery（mDiscoveryListener）,则如果应用程序退出,NSD仍然会从onDestroy中被杀死；在onPostExecute（）中执行此操作。

使用NSD，我可以在5-15秒内获得IP，但如果AsyncTask是静态的，我不能杀死它，NSD就会非常忙。

如果我通过使AsyncTask静态化来满足它，mNsdManager会抱怨:
非静态字段'mNsdManager'不能从静态上下文引用

我可以编译的唯一方法是使AsyncTask非静态，接受可能的泄漏，或者保留AsyncTask静态，并注释掉onPostExecute（）中的KILL行。

下面的代码中标记了2个错误。

基于Android事件的AsyncTask似乎是最好的方法，但这是正确的方法吗？

我怎样才能杀死mNsdManager而仍然使AsyncTask保持静态以阻止泄漏？

    package com.fib.onacci.fibonacci;

    private static final String TAG = "CLOCK : ";
    private TextView mIP_address;

    // NSD members, Allows app to discover the "fibonacci.local"
    // Reference: 
    // http://developer.android.com/training/connect-devices-wirelessly/nsd.html

          private static NsdManager mNsdManager;
          private static NsdManager.DiscoveryListener mDiscoveryListener;
          private NsdManager.ResolveListener mResolveListener;
          private NsdServiceInfo mServiceInfo;
          public String mRPiAddress;
          public static String IPaddress ="-"; // something to look for change
          private static final String SERVICE_TYPE = "_http._tcp."; 

        public class MainActivity extends AppCompatActivity {

        private static final String TAG = "CLOCK: ";

          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);

              new getIPtoTextView().execute();  // start the AsyncTask

              // setup nDNS and find IP
              mRPiAddress = "";
              IPaddress = "-";
              mNsdManager = (NsdManager)(getApplicationContext().getSystemService(Context.NSD_SERVICE));
              initializeResolveListener();
              initializeDiscoveryListener();
              mNsdManager.discoverServices( SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);

          }  // END onCreate

         // NSD start - Network discovery

ERROR This AsyncTask class should be static or leaks might occur 
          A static field will leak contexts.   

          private static class getIPtoTextView extends AsyncTask {
              /** part of nDiscovery - find clock and kill discovery service
               *  `doInBackground` is run on a separate, background thread
               */
              @Override
              protected Void doInBackground(Void... params) {
                  String mloop = IPaddress;
                  while ( mloop.equals("-")) {
                      mloop = IPaddress;
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  Log.i( TAG, "doInBackground - IP Found - " + mloop );
                  return null;
              }

              /** part of nDiscovery
               * `onPostExecute` is run after `doInBackground`, and it's
               * run on the main/ui thread, so you it's safe to update ui
               * components from it. (this is the correct way to update ui
               * components.)
               */
              @Override
              protected void onPostExecute(Void param) {
                Log.i( TAG, "onPostExecute - IP Found - " + IPaddress );

                  TextView IP_Window = findViewById(R.id.IP_address); 
                  IP_Window.setText( IPaddress);  // post IP address to TextView

ERROR Non-static field 'mNsdManager' cannot be referenced from a static context
                  mNsdManager.stopServiceDiscovery( mDiscoveryListener);                     // kill mDiscoveryListener
              }
          }  // end asyncTask class

          private void initializeDiscoveryListener() {

            mDiscoveryListener = new NsdManager.DiscoveryListener() { // Listener

                  @Override
                  public void onDiscoveryStarted(String regType) {
                  }

                  @Override
                  public void onServiceFound(NsdServiceInfo service) { // service found!
                      String name = service.getServiceName();
                      String type = service.getServiceType();

                      if ( type.equals(SERVICE_TYPE) && name.contains("Fibonacci")) {
                          Log.i( TAG, "\n\tNSD Service Found @ ' " + name + "'");
                          mNsdManager.resolveService(service, mResolveListener);
                      }
                  }

                  @Override
                  public void onServiceLost(NsdServiceInfo service) {  
                  }

                  @Override
                  public void onDiscoveryStopped(String serviceType) {
                  }

                  @Override
                  public void onStartDiscoveryFailed(String serviceType, int errorCode) {
                      mNsdManager.stopServiceDiscovery(this);
                  }

                  @Override
                  public void onStopDiscoveryFailed(String serviceType, int errorCode) {
                      mNsdManager.stopServiceDiscovery(this);
                  }
              };
          }

          private void initializeResolveListener() {
              mResolveListener = new NsdManager.ResolveListener(){

                  @Override
                  public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
                      Log.i( TAG, "\n\t\tNSD Resolve failed " + errorCode + "\n\n" );
                  }

                  @Override
                  public void onServiceResolved( NsdServiceInfo serviceInfo ) {
                      mServiceInfo = serviceInfo;
                      InetAddress host = mServiceInfo.getHost();
                       IPaddress = host.getHostAddress();
                      mRPiAddress = IPaddress;
                      Log.i( TAG, "\n\t\tNSD Resolved address = " + IPaddress + "\n\n" );
                    }
                };
            }

            @Override
            protected void onPause() {
                super.onPause();
                if ( mDiscoveryListener != null) {
                    mNsdManager.stopServiceDiscovery( mDiscoveryListener);
                }
            }

            @Override
            protected void onResume() {
                super.onResume();
                if ( mDiscoveryListener != null) {
                  mIP_address.setText( R.string.searching );  // TextView - Searching -
                    try {
                        Thread.sleep( 1500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    initializeDiscoveryListener();
                }
            }

            @Override
            protected void onDestroy() {
                super.onDestroy();
                mNsdManager.stopServiceDiscovery( mDiscoveryListener);  
            }
        // NSD end //
      }

Answer 1

需要重写，因为我无法在没有太多错误的情况下使类getIPtoTextView成为静态的。

一旦我可以将类getIPtoTextView设置为静态，我就移动了MNSDManager.StopServiceDiscovery（mDiscoveryListener）；onPause（）和onDestroy（）都工作得很好。