Wie erstelle ich meine eigene Listener-Oberfläche in Android?

Könnte mir jemand helfen, eine benutzerdefinierte Listener-Oberfläche mit einigen Codefragmenten zu erstellen?

Erstellen Sie eine neue Datei:

MyListener.java::

public interface MyListener {
    // you can define any parameter as per your requirement
    public void callback(View view, String result);
}

Implementieren Sie in Ihrer Aktivität die Schnittstelle:

MyActivity.java::

public class MyActivity extends Activity implements MyListener {
   @override        
   public void onCreate(){
        MyButton m = new MyButton(this);
   }

    // method is invoked when MyButton is clicked
    @override
    public void callback(View view, String result) {   
        // do your stuff here
    }
}

Rufen Sie in Ihrer benutzerdefinierten Klasse bei Bedarf die Schnittstelle auf:

MyButton.java::

public class MyButton {
    MyListener ml;

    // constructor
    MyButton(MyListener ml) {
        //Setting the listener
        this.ml = ml;
    }

    public void MyLogicToIntimateOthers() {
        //Invoke the interface
        ml.callback(this, "success");
    }
}

Bitte lesen Sie das Beobachtermuster

Listener-Schnittstelle

public interface OnEventListener {
    void onEvent(EventResult er);
    // or void onEvent(); as per your need
}

dann sag in deiner Klasse EventKlasse

public class Event {
    private OnEventListener mOnEventListener;

    public void setOnEventListener(OnEventListener listener) {
        mOnEventListener = listener;
    }

    public void doEvent() {
        /*
         * code code code
         */

         // and in the end

         if (mOnEventListener != null)
             mOnEventListener.onEvent(eventResult); // event result object :)
    }
}

in Ihrer Fahrerklasse MyTestDriver

public class MyTestDriver {
    public static void main(String[] args) {
        Event e = new Event();
        e.setOnEventListener(new OnEventListener() {
             public void onEvent(EventResult er) {
                 // do your work. 
             }
        });
        e.doEvent();
    }
}

Ich habe einen generischen AsyncTask-Listener erstellt, der das Ergebnis der separaten AsycTask-Klasse abruft und CallingActivity mithilfe des Schnittstellenrückrufs übergibt.

new GenericAsyncTask(context,new AsyncTaskCompleteListener()
        {
             public void onTaskComplete(String response) 
             {
                 // do your work. 
             }
        }).execute();

Schnittstelle

interface AsyncTaskCompleteListener<T> {
   public void onTaskComplete(T result);
}

GenericAsyncTask

class GenericAsyncTask extends AsyncTask<String, Void, String> 
{
    private AsyncTaskCompleteListener<String> callback;

    public A(Context context, AsyncTaskCompleteListener<String> cb) {
        this.context = context;
        this.callback = cb;
    }

    protected void onPostExecute(String result) {
       finalResult = result;
       callback.onTaskComplete(result);
   }  
}

Werfen Sie einen Blick auf diese , diese Frage für weitere Details.

Es gibt 4 Schritte:

1.Schnittstellenklasse erstellen (Listener)

2. Verwenden Sie die Schnittstelle in Ansicht 1 (Variable definieren).

3. implementiert die Schnittstelle zu Ansicht 2 (Ansicht 1 wird in Ansicht 2 verwendet)

4. Übergeben Sie die Schnittstelle in Ansicht 1 an Ansicht 2

Beispiel:

Schritt 1: Sie müssen eine Schnittstelle erstellen und eine Funktion definieren

public interface onAddTextViewCustomListener {
    void onAddText(String text);
}

Schritt 2: Verwenden Sie diese Schnittstelle in der Ansicht

public class CTextView extends TextView {


    onAddTextViewCustomListener onAddTextViewCustomListener; //listener custom

    public CTextView(Context context, onAddTextViewCustomListener onAddTextViewCustomListener) {
        super(context);
        this.onAddTextViewCustomListener = onAddTextViewCustomListener;
        init(context, null);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context, attrs);
    }

    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context, attrs);
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public CTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init(context, attrs);
    }

    public void init(Context context, @Nullable AttributeSet attrs) {

        if (isInEditMode())
            return;

        //call listener
        onAddTextViewCustomListener.onAddText("this TextView added");
    }
}

Schritt 3,4: Implementiert die Aktivität

public class MainActivity extends AppCompatActivity implements onAddTextViewCustomListener {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //get main view from layout
        RelativeLayout mainView = (RelativeLayout)findViewById(R.id.mainView);

        //create new CTextView and set listener
        CTextView cTextView = new CTextView(getApplicationContext(), this);

        //add cTextView to mainView
        mainView.addView(cTextView);
    }

    @Override
    public void onAddText(String text) {
        Log.i("Message ", text);
    }
}

Listener-Schnittstelle erstellen.

public interface YourCustomListener
{
    public void onCustomClick(View view);
            // pass view as argument or whatever you want.
}

Erstellen Sie die Methode setOnCustomClick in einer anderen Aktivität (oder einem Fragment), in der Sie Ihren benutzerdefinierten Listener anwenden möchten.

  public void setCustomClickListener(YourCustomListener yourCustomListener)
{
    this.yourCustomListener= yourCustomListener;
}

Rufen Sie diese Methode aus Ihrer ersten Aktivität auf und übergeben Sie die Listener-Oberfläche ...

Im Jahr 2018 sind keine Hörerschnittstellen erforderlich. Sie haben Android LiveData, um sicherzustellen, dass das gewünschte Ergebnis an die UI-Komponenten zurückgegeben wird.

Wenn ich Rupeshs Antwort nehme und sie an die Verwendung von LiveData anpasse, wird es so aussehen:

public class Event {

    public LiveData<EventResult> doEvent() {
         /*
          * code code code
          */

         // and in the end

         LiveData<EventResult> result = new MutableLiveData<>();
         result.setValue(eventResult);
         return result;
    }
}

und jetzt in Ihrer Treiberklasse MyTestDriver:

public class MyTestDriver {
    public static void main(String[] args) {
        Event e = new Event();
        e.doEvent().observe(this, new  Observer<EventResult>() {
            @Override
            public void onChanged(final EventResult er) {
                // do your work.
            }
        });
    }
}

Für weitere Informationen zusammen mit Codebeispielen können Sie meinen Beitrag darüber sowie die offiziellen Dokumente lesen:

Wann und warum LiveData verwenden?

Offizielle Dokumente

In Android können Sie eine Benutzeroberfläche wie Listener erstellen, die von Ihrer Aktivität implementiert wird. Ich halte dies jedoch nicht für eine gute Idee. Wenn wir viele Komponenten haben, um die Änderungen ihres Status abzuhören, können wir einen BaseListener-Implementierungsschnittstellen-Listener erstellen und Typcode verwenden, um sie zu verarbeiten. Wir können die Methode binden, wenn wir eine XML-Datei erstellen, zum Beispiel:

<Button  
        android:id="@+id/button4"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:text="Button4"  
        android:onClick="Btn4OnClick" />

und der Quellcode:

 public void Btn4OnClick(View view) {  
        String strTmp = "点击Button04";  
        tv.setText(strTmp);  
    }  

aber ich denke nicht, dass es eine gute Idee ist ...

Ich habe es wie folgt gemacht, um meine Modellklasse von der zweiten Aktivität zur ersten Aktivität zu senden. Ich habe LiveData verwendet, um dies mithilfe von Antworten von Rupesh und TheCodeFather zu erreichen.

Zweite Aktivität

public static MutableLiveData<AudioListModel> getLiveSong() {
        MutableLiveData<AudioListModel> result = new MutableLiveData<>();
        result.setValue(liveSong);
        return result;
    }

"liveSong" ist AudioListModel, das global deklariert ist

Rufen Sie diese Methode in der ersten Aktivität auf

PlayerActivity.getLiveSong().observe(this, new Observer<AudioListModel>() {
            @Override
            public void onChanged(AudioListModel audioListModel) {
                if (PlayerActivity.mediaPlayer != null && PlayerActivity.mediaPlayer.isPlaying()) {
                    Log.d("LiveSong--->Changes-->", audioListModel.getSongName());
                }
            }
        });

Möge dies neuen Entdeckern wie mir helfen.

Einfache Methode, um diesen Ansatz zu tun. Implementiert zunächst das OnClickListenersin Ihrer Aktivitätsklasse.

Code:

class MainActivity extends Activity implements OnClickListeners{

protected void OnCreate(Bundle bundle)
{    
    super.onCreate(bundle);    
    setContentView(R.layout.activity_main.xml);    
    Button b1=(Button)findViewById(R.id.sipsi);    
    Button b2=(Button)findViewById(R.id.pipsi);    
    b1.SetOnClickListener(this);    
    b2.SetOnClickListener(this);    
}

public void OnClick(View V)    
{    
    int i=v.getId();    
    switch(i)    
    {    
        case R.id.sipsi:
        {
            //you can do anything from this button
            break;
        }
        case R.id.pipsi:
        {    
            //you can do anything from this button       
            break;
        }
    }
}