Android内存泄漏解决及跨类调用Dialog避免空指针问题咨询

Hey Steven, let's break down your two Android development problems with practical, actionable solutions that follow best practices:

First, let's clarify why static Context references cause leaks: Static fields hold strong references to the Context (like an Activity) even after the Activity is destroyed. The Garbage Collector (GC) can't reclaim that memory, leading to leaks. Here's how to fix this properly without using @SuppressLint("StaticFieldLeak"):

• Use Application Context when possible
  If DataConnect doesn't need Activity-specific functionality (like launching a new Activity or showing a dialog), use the Application Context instead—it has the same lifecycle as your app, so it won't leak when Activities are destroyed.
  Example code for DataConnect:

  public class DataConnect {
      private final Context appContext;
  
      public DataConnect(Context context) {
          // Grab the Application Context instead of the passed Activity Context
          this.appContext = context.getApplicationContext();
      }
  
      // All your methods should use appContext from here on
      public void fetchData() {
          // Use appContext for operations like accessing resources or ContentResolver
      }
  }
  

• Use WeakReference for Activity-specific needs
  If you must use an Activity Context (e.g., to interact with the current Activity's UI), wrap it in a WeakReference. This lets the GC collect the Activity when it's no longer needed, preventing leaks.
  Example code:

  public class DataConnect {
      private WeakReference<Context> activityContextRef;
  
      public DataConnect(Context activityContext) {
          this.activityContextRef = new WeakReference<>(activityContext);
      }
  
      public void updateActivityUI() {
          // Always check if the reference is still valid before using it
          Context context = activityContextRef.get();
          if (context != null && !((Activity) context).isFinishing() && !((Activity) context).isDestroyed()) {
              // Perform your UI-related operation safely
          }
      }
  }
  

• Refactor DataConnect to use a singleton with Application Context
  If DataConnect is a singleton, initialize it using your app's Application Context (not an Activity Context) to avoid leaks. Do this in your custom Application class:

  public class MyApp extends Application {
      private static DataConnect instance;
  
      @Override
      public void onCreate() {
          super.onCreate();
          // Initialize singleton with Application Context
          instance = new DataConnect(getApplicationContext());
      }
  
      public static DataConnect getInstance() {
          return instance;
      }
  }
  

  Don't forget to declare your custom Application in AndroidManifest.xml:

  <application
      android:name=".MyApp"
      <!-- other attributes -->
  >
  </application>
  

The error java.lang.NullPointerException: Attempt to invoke virtual method 'boolean com.orhanobut.dialogplus.DialogPlus.isShowing()' on a null object reference happens when you try to access the DialogPlus object before it's initialized, or after it's been destroyed (e.g., when the Activity is finished). Here's how to handle this correctly:

• Let MainActivity manage its own Dialog (Use Callback Interfaces)
  Never let other classes hold a direct reference to your DialogPlus object. Instead, define a callback interface that other classes can use to request actions, and let MainActivity handle the Dialog operations itself. This avoids null references and potential leaks.
  Step 1: Define the callback interface

  public interface DialogController {
      void checkDialogStatus();
      void showDialog();
      void dismissDialog();
  }
  

  Step 2: Implement the interface in MainActivity

  public class MainActivity extends AppCompatActivity implements DialogController {
      private DialogPlus dialog;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          // Initialize DialogPlus here (after setContentView!)
          dialog = DialogPlus.newDialog(this)
                  .setContentHolder(new ViewHolder(R.layout.your_dialog_layout))
                  .create();
      }
  
      @Override
      public void checkDialogStatus() {
          // Safely check if the dialog exists and is showing
          if (dialog != null && dialog.isShowing()) {
              // Do whatever you need here (e.g., update dialog content)
          }
      }
  
      @Override
      public void showDialog() {
          if (dialog != null && !dialog.isShowing()) {
              dialog.show();
          }
      }
  
      @Override
      public void dismissDialog() {
          if (dialog != null && dialog.isShowing()) {
              dialog.dismiss();
          }
      }
  
      // Clean up the dialog when the Activity is destroyed
      @Override
      protected void onDestroy() {
          super.onDestroy();
          if (dialog != null) {
              dialog.dismiss();
              dialog = null;
          }
      }
  }
  

  Step 3: Use the callback in your other class

  public class OtherClass {
      private DialogController dialogController;
  
      // Pass the callback when creating OtherClass
      public OtherClass(DialogController controller) {
          this.dialogController = controller;
      }
  
      public void someMethodThatNeedsDialog() {
          // Request MainActivity to check the dialog status
          if (dialogController != null) {
              dialogController.checkDialogStatus();
          }
      }
  }
  

• Use ViewModel to Manage Dialog State (Recommended for Complex Flows)
  If you need to share dialog state across components (e.g., fragments, other classes), use a ViewModel to hold the dialog's state (instead of the Dialog object itself). This keeps your UI logic separated and avoids null references.
  Example ViewModel:

  public class MainViewModel extends ViewModel {
      private final MutableLiveData<Boolean> shouldShowDialog = new MutableLiveData<>();
  
      public LiveData<Boolean> getShouldShowDialog() {
          return shouldShowDialog;
      }
  
      public void requestDialogCheck() {
          // Trigger a check (you can adjust this logic based on your needs)
          shouldShowDialog.postValue(true);
      }
  }
  

  In MainActivity:

  public class MainActivity extends AppCompatActivity {
      private DialogPlus dialog;
      private MainViewModel viewModel;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          viewModel = new ViewModelProvider(this).get(MainViewModel.class);
          dialog = DialogPlus.newDialog(this)
                  .setContentHolder(new ViewHolder(R.layout.your_dialog_layout))
                  .create();
  
          // Observe the ViewModel's state to control the dialog
          viewModel.getShouldShowDialog().observe(this, show -> {
              if (show != null) {
                  if (show && !dialog.isShowing()) {
                      dialog.show();
                  } else if (!show && dialog.isShowing()) {
                      dialog.dismiss();
                  }
              }
          });
      }
  }
  

  In your other class:

  public class OtherClass {
      private MainViewModel viewModel;
  
      public OtherClass(MainViewModel viewModel) {
          this.viewModel = viewModel;
      }
  
      public void checkDialog() {
          viewModel.requestDialogCheck();
      }
  }
  

内容的提问来源于stack exchange，提问作者Steven Phyo