如何解决嵌套Fragment的ViewPager中Fragment的TextView更新UI闪烁问题？

Hey there! Let's fix that annoying UI flicker you're dealing with when updating TextViews in your ViewPager's fragments. Greenrobot EventBus gets the job done, but the flicker is definitely a pain—here are some reliable alternatives that'll give you smoother UI updates:

1. Directly Access Child Fragments via the Adapter #

Since you're using FragmentPagerAdapter, you can grab the target child fragment directly through the adapter and call an update method on it. This cuts out the middleman of event buses and keeps updates tight.

How to implement it: #

• First, add a public method in your child fragment to handle the TextView update (make sure it runs on the main thread):

  public class YourChildFragment extends Fragment {
      private TextView targetTextView;
  
      // ... your existing code (onCreateView, etc.)
  
      public void updateTextView(String newText) {
          if (targetTextView != null && isResumed()) {
              targetTextView.setText(newText);
          }
      }
  }
  

• Then, in your parent fragment, fetch the child fragment using either the adapter's getItem() or findFragmentByTag() (the latter is more reliable for cached fragments):

  // Option 1: Using getItem() (note: may recreate the fragment if not cached)
  YourChildFragment targetFragment = (YourChildFragment) yourPagerAdapter.getItem(targetPosition);
  if (targetFragment != null) {
      targetFragment.updateTextView(yourNewValue);
  }
  
  // Option 2: Using findFragmentByTag (more reliable for existing fragments)
  String fragmentTag = "android:switcher:" + yourViewPager.getId() + ":" + targetPosition;
  YourChildFragment targetFragment = (YourChildFragment) getChildFragmentManager().findFragmentByTag(fragmentTag);
  if (targetFragment != null && targetFragment.isVisible()) {
      targetFragment.updateTextView(yourNewValue);
  }
  

Pro tip: Always check if the fragment is visible/resumed before updating to avoid unnecessary UI changes that cause flicker.

2. Use ViewModel + LiveData (Recommended) #

This is the Jetpack best practice for cross-component data sharing. It's lifecycle-aware, automatically handles main thread updates, and eliminates memory leaks—plus it'll stop that flicker cold.

How to implement it: #

1. Create a shared ViewModel to hold your text data:

   public class SharedPagerViewModel extends ViewModel {
       // Create MutableLiveData for each page's text
       private final MutableLiveData<String> page0Text = new MutableLiveData<>();
       private final MutableLiveData<String> page1Text = new MutableLiveData<>();
   
       // Setters to update the data
       public void setPage0Text(String text) {
           page0Text.setValue(text); // Automatically runs on main thread
       }
   
       public void setPage1Text(String text) {
           page1Text.setValue(text);
       }
   
       // Getters to observe the data
       public LiveData<String> getPage0Text() {
           return page0Text;
       }
   
       public LiveData<String> getPage1Text() {
           return page1Text;
       }
   }
   

2. In your parent fragment, get the ViewModel instance (using the activity's scope to share it with child fragments) and update the data when needed:

   SharedPagerViewModel viewModel = new ViewModelProvider(requireActivity()).get(SharedPagerViewModel.class);
   // When you need to update page 0's text
   viewModel.setPage0Text(yourRandomValue);
   

3. In each child fragment, observe the corresponding LiveData to update the TextView:

   SharedPagerViewModel viewModel = new ViewModelProvider(requireActivity()).get(SharedPagerViewModel.class);
   // For page 0 fragment
   viewModel.getPage0Text().observe(getViewLifecycleOwner(), newText -> {
       targetTextView.setText(newText);
   });
   

Why this works: LiveData only delivers updates when the fragment is in an active lifecycle state (visible to the user), so you won't get updates when the fragment is hidden—eliminating flicker caused by off-screen updates.

3. Interface Callback Pattern #

Define a callback interface that your child fragments implement, then have the adapter hold references to these callbacks to trigger updates directly.

How to implement it: #

1. Create the callback interface:

   public interface TextUpdateListener {
       void onTextUpdated(String newText);
   }
   

2. Have your child fragment implement this interface:

   public class YourChildFragment extends Fragment implements TextUpdateListener {
       private TextView targetTextView;
   
       @Override
       public void onTextUpdated(String newText) {
           if (targetTextView != null) {
               targetTextView.setText(newText);
           }
       }
   
       // ... rest of your fragment code
   }
   

3. Update your SamplePagerAdapter to track these listeners:

   public class SamplePagerAdapter extends FragmentPagerAdapter {
       private final List<TextUpdateListener> updateListeners = new ArrayList<>();
   
       // ... your existing constructor and getItemCount()
   
       @Override
       public Fragment getItem(int position) {
           YourChildFragment fragment = new YourChildFragment();
           updateListeners.add(fragment);
           return fragment;
       }
   
       // Method to trigger updates for a specific page
       public void updateTextForPage(int position, String newText) {
           if (position >= 0 && position < updateListeners.size()) {
               updateListeners.get(position).onTextUpdated(newText);
           }
       }
   }
   

4. In your parent fragment, call the adapter's update method when needed:

   yourPagerAdapter.updateTextForPage(targetPosition, yourNewValue);
   

Note: If your ViewPager destroys off-screen fragments (default cache is 1), make sure to refresh the listener list when fragments are recreated to avoid null pointers.

Why EventBus Causes Flicker #

Most often, it's because events are dispatched even when the target fragment is not visible, or multiple events are received in quick succession. When the fragment becomes visible again, it re-renders the text, causing that annoying flicker. The above solutions avoid this by only updating the UI when the fragment is active.

内容的提问来源于stack exchange，提问作者sagar potdar