Saving listeners correctly when changing orientation

Consider the following scenario:

• I have Activity
  
  with UI elements that fire DialogFragment
  
  when clicked
• DialogFragment
  
  has a listener interface
  
  that Activity
  
  provides an implementation. Let's say for example Activity
  
  is an image editor and DialogFragment
  
  picks contrast - there will be a dialog box OnContrastChangedListener
  
  that Activity
  
  implements

• Activity
  
  implemented this interface
  
  to update views in my UI. Continuing with the image editor example, Activity
  
  implement OnContrastChangedListener
  
  to update its preview - something like this:

  contrastDialog.setOnContrastChangedListener(new OnContrastChangedListener {
      @Override
      public void OnContrastChanged(int newContrast) {
          getPreviewView().updateWithContrast(newContrast);            
      }
  });
  
        
  
          
          
          
        
  
      

• The orientation changes and everything is recreated and the listener is saved and restored correctly using the recommended techniques here (the listener is saved in Fragment
  
  and restored when the lifecycle restores the state).

The problem is that the listener interface is now broken . The function getPreviewView()

now returns null

, although when called elsewhere in Activity

it returns the correct value

Sorry for the poor terminology (my knowledge of compilation and bytecode is limited), but I can understand what happened. The frontend was compiled with a version getPreviewView()

that returned a preview view that was destroyed on orientation change and has since been released / garbage collected / now null

.

My question is, is there a way in Java to make the compilation of an interface pending value / function change - like a keyword volatile

in C (I expect not)? In that case, what's the best approach to get around this situation? I have considered the following:

• Create DialogFragment
  
  (and it interface
  
  ) in code that reruns when recreated Activity
  
  . It's okay for things like OnClickListeners
  
  for Buttons
  
  , as they are definitely created. But this one DialogFragment
  
  is only created when the button is pressed, so this approach means every dialog for the screen is created every time Activity
  
  - it seems wasteful as they might not even be executed
• Create all possible interfaces
  
  for Activity
  
  each time and store them in member variables, then use these interfaces
  
  when the request DialogFragments
  
  should be created by the event. The same comments as above - seem wasteful, making everything possible interface
  
  just in case it is running.
• Keep some of the hacky open dialog member variables in action that define the re-creation interfaces
  
  . Hacky and creates a connection between Activity
  
  and DialogFragment
  
  , which is not a big practice.

As you can see, all options involve leisure, somewhat wasteful - is there a way to reuse an existing implementation interface

?

EDIT: Options 1 and 2 won't work because they need a reference to an existing one Dialog

. This can all be done, but it increasingly relies on the hack option along with the variables of the current "Dialogue", getting DialogFragment

help FragmentManager

when restarting the activity, applying it appropriately based on the variable "current dialog", recreating the listener. Is there a less messy way?