Come creare la nostra interfaccia Listener in Android?

Qualcuno potrebbe aiutarmi a creare un'interfaccia listener definita dall'utente con alcuni frammenti di codice?

Crea un nuovo file:

MyListener.java:

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

Nella tua attività, implementa l'interfaccia:

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

Nella tua classe personalizzata, invoca l'interfaccia quando necessario:

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

si prega di leggere il modello di osservatore

interfaccia di ascolto

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

poi nella tua classe dì Eventlezione

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

nella tua classe di guida 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();
    }
}

Ho creato un listener AsyncTask generico che ottiene il risultato dalla classe separata AsycTask e lo do a CallingActivity utilizzando l'interfaccia Callback.

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

Interfaccia

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

Date un'occhiata a questo , a questa domanda per maggiori dettagli.

Ci sono 4 passaggi:

1.creare la classe di interfaccia (listener)

2.utilizzare l'interfaccia nella vista 1 (definire la variabile)

Interfaccia 3.implements per visualizzare 2 (vista 1 utilizzata nella vista 2)

4.passare l'interfaccia nella vista 1 per visualizzare 2

Esempio:

Passaggio 1: è necessario creare l'interfaccia e la funzione definde

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

Passaggio 2: utilizzare questa interfaccia in vista

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

Step 3,4: implementa l'attività

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

Crea un'interfaccia listener.

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

E crea il metodo setOnCustomClick in un'altra attività (o frammento), in cui desideri applicare il tuo listener personalizzato ......

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

Chiama questo metodo dalla tua prima attività e passa l'interfaccia del listener ...

Nell'anno 2018 non sono necessarie interfacce per gli ascoltatori. Android LiveData è in grado di restituire il risultato desiderato ai componenti dell'interfaccia utente.

Se prenderò la risposta di Rupesh e la regolerò per usare LiveData, piacerà così:

public class Event {

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

         // and in the end

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

e ora nella tua classe di driver 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.
            }
        });
    }
}

Per ulteriori informazioni con esempi di codice puoi leggere il mio post al riguardo, così come i documenti ufficiali:

Quando e perché utilizzare LiveData

Documenti ufficiali

In Android, puoi creare un'interfaccia come Listener e la tua attività la implementa, ma non credo sia una buona idea. se abbiamo molti componenti per ascoltare i cambiamenti del loro stato, possiamo creare un BaseListener implementa l'interfaccia Listener e usare il codice di tipo per gestirli. possiamo associare il metodo quando creiamo un file XML, ad esempio:

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

e il codice sorgente:

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

ma non penso sia una buona idea ...

L'ho fatto come sotto per l'invio del mio modello di classe dalla Seconda attività alla prima attività. Ho usato LiveData per raggiungere questo obiettivo, con l'aiuto delle risposte di Rupesh e TheCodeFather.

Seconda attività

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

"liveSong" è AudioListModel dichiarato a livello globale

Chiama questo metodo nella prima attività

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

Possa questo aiuto per i nuovi esploratori come me.

Metodo semplice per fare questo approccio. Innanzitutto implementa il OnClickListenersnella tua classe Activity.

Codice:

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