Dynamische Funktionalität an Button onclicklistener Android

Question

senden Ziel: Ich bin auf der Suche nach einer Möglichkeit zum Hinzufügen von Funktionalität zu einer Schaltfläche onClickListener.

Illustration

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(); 
     } 
    }); 

Ich weiß, wir dies mit Vererbung tun

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

telefonisch oder wir können es tun Inline

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

Dinge, die ich versucht habe,

Erweitern der Schaltfläche, um eine Liste der ausführbaren Objekte zu enthalten. Setzen Sie dann den On-Click-Listener, um alle runnable-Objekte auszulösen.

Gibt es einen anderen/effizienteren Weg dies zu tun?

Answer 1

Da wir nicht viel über den Hintergrund wissen, warum Sie das tun wollen, ist es schwer zu dem, was das Beste ist. Wenn Sie den ursprünglichen Listener unverändert/unberührt lassen möchten, könnten Sie ein Decorator/Wrapper-Muster verwenden.

Wikipedia Decorator Pattern

Im konkreten Fall bedeutet dies, ist es durchaus vergleichbar mit Ihrem Runnable Ansatz, aber Sie nicht auf einer anderen Schnittstelle abhängen. Everthing wird über die View.OnClickListener behandelt, die die folgenden Vorteile:

1. Es ist ein allgemeiner Ansatz, mit dem Sie auch „erweitern“ Zuhörer, zu denen Sie keine Quelle Zugriff haben oder die Sie nicht wollen, zu ändern.
2. Sie können die Dehnungsverhalten zur Laufzeit erstellen und Sie können bereits instanziiert Hörer erweitern (im Gegensatz zur Verwendung von Vererbung)

3. Die Erweiterungen müssen nicht wissen, dass sie Erweiterungen sind, sind sie OnClickListeners nur normal. In Ihrem Runnable Ansatz sind die Erweiterungen "speziell" und zum Beispiel erhalten sie nicht den View Parameter der onClick Methode übergeben.

   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); 
        } 
       } 
   } 
   

Und die Nutzung ist wie folgt:

DecoratorOnClickListener dl = new DecoratorOnClickListener(); 

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

    editText.setOnClickListener(dl); 

Answer 2

was ist so etwas wie

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

Ich denke, die Runnable Idee in Ordnung ist, auf das, was Sie hier gesagt haben. Da ich wirklich nicht wissen, warum Sie dynamische Klick-Handler müssen, denke ich eine mögliche Lösung wie folgt aussehen würde:

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(); 
     } 
    } 
} 

Und du würdest es wie folgt verwendet werden:

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);