Aggiunge dinamicamente funzionalità a onclicklistener di Button Android

Question

Obiettivo: Sto cercando un modo per aggiungere funzionalità a onClickListener di un pulsante.

Illustrazione

Button trigger = new Button(getActivity()); 
    trigger.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      method1(); 
     } 
    }); 

    Button runMethod2Button = new Button(getActivity()); 
    runMethod2Button.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      method1(); 
      method2(); 
     } 
    }); 

    Button runMethod3Button = new Button(getActivity()); 
    runMethod3Button.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      method1(); 
      method3(); 
      method4(); 
     } 
    }); 

So che possiamo fare questo con l'eredità chiamando

@Override 
public void method(){ 
    super.method(); 
    // Do appended stuff 
} 

Oppure possiamo farlo in linea

new Object(){ 
    @Override 
    public void method(){ 
     super(); 
     // Do appended stuff 
    } 
} 

Le cose che ho provato

Estensione del pulsante per contenere un elenco di oggetti eseguibili. Quindi impostare il listener in clic per attivare tutti gli oggetti eseguibili.

C'è un modo diverso/più efficiente di farlo?

Answer 1

Dal momento che non ci occupiamo molto dello sfondo, perché lo vuoi fare, è difficile capire qual è il migliore. Se si desidera che l'ascoltatore originale sia immutato/non modificato, è possibile utilizzare un modello decoratore/wrapper.

Wikipedia Decorator Pattern

Nel caso concreto questo significa, è del tutto paragonabile al vostro approccio Runnable, ma non dipendono da un'altra interfaccia. Tutto quello viene gestito tramite il View.OnClickListener, che ha i seguenti vantaggi:

1. Si tratta di un approccio generico con il quale si può anche "estendere" gli ascoltatori a cui si ha accesso di origine o di cui non si desidera modificare.
2. È possibile creare il comportamento di estensione in fase di esecuzione e si può estendere ascoltatori già istanziati (in contrasto con l'uso dell'ereditarietà)

3. Le estensioni non devono sapere che sono le estensioni, sono solo normali OnClickListeners. Nell'approccio Runnable le estensioni sono "speciali" e ad esempio non ottengono il passaggio del parametro View del metodo onClick.

   public class OriginalOnClickListener implements View.OnClickListener{ 
   
       @Override 
       public void onClick(View v) { 
        Toast.makeText(MainActivity.this,"Original Click Listener",Toast.LENGTH_LONG).show(); 
       } 
   } 
   
   public class ExtensionOnClickListener implements View.OnClickListener{ 
   
       @Override 
       public void onClick(View v) { 
        Toast.makeText(MainActivity.this,"Extension Click Listener",Toast.LENGTH_LONG).show(); 
       } 
   } 
   
   public class DecoratorOnClickListener implements View.OnClickListener { 
   
       private final List<View.OnClickListener> listeners = new ArrayList<>(); 
   
       public void add(View.OnClickListener l) { 
        listeners.add(l); 
       } 
   
       @Override 
       public void onClick(View v) { 
        for(View.OnClickListener l : listeners){ 
         l.onClick(v); 
        } 
       } 
   } 
   

E l'utilizzo è simile a questo:

DecoratorOnClickListener dl = new DecoratorOnClickListener(); 

    dl.add(new OriginalOnClickListener()); 
    dl.add(new ExtensionOnClickListener()); 

    editText.setOnClickListener(dl); 

Answer 2

che dire qualcosa di simile

Button trigger = new Button(getActivity()); 
trigger.setOnClickListener(new View.OnClickListener() { 
    @Override 
    public void onClick(View v) { 
     method1(); 
     if (someVar) method2(); 
     if (someVar2) method3(); 
    } 
}) 

Answer 3

Penso che l'idea Runnable è ok, in base a ciò che hai detto qui. Visto che io non so davvero perché è necessario gestori click dinamici, credo che una possibile soluzione potrebbe essere simile a questa:

private class DynamicOnClickListener implements View.OnClickListener { 

    private final List<Runnable> mRunnables = new ArrayList<>(); 

    public void add(Runnable r) { 
     mRunnables.add(r); 
    } 

    @Override 
    public void onClick(View v) { 
     for (Runnable r : mRunnables) { 
      r.run(); 
     } 
    } 
} 

e desideri usare in questo modo:

DynamicOnClickListener listener = new DynamicOnClickListener(); 

    listener.add(new Runnable() { 
     @Override 
     public void run() { 
      doSomething(); 
     } 
    }); 

    listener.add(new Runnable() { 
     @Override 
     public void run() { 
      doSomethingElse(); 
     } 
    }); 

    mButton.setOnClickListener(listener);