Comment créer notre propre interface d'écoute sous Android?

Quelqu'un pourrait-il m'aider à créer une interface d'écoute définie par l'utilisateur avec des extraits de code?

Créez un nouveau fichier:

MyListener.java:

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

Dans votre activité, implémentez l'interface:

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

Dans votre classe personnalisée, appelez l'interface si nécessaire:

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

Veuillez lire le modèle d'observateur

interface d'écoute

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

alors dans ta classe dis Eventclasse

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

dans votre classe de conducteur 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();
    }
}

J'ai créé un écouteur AsyncTask générique qui obtient le résultat de la classe séparée AsycTask et le donne à CallingActivity en utilisant le rappel d'interface.

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

Interface

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

Jetez un oeil à cette , cette question pour plus de détails.

Il y a 4 étapes:

1. créer une classe d'interface (auditeur)

2. utiliser l'interface dans la vue 1 (définir la variable)

3. implémente l'interface pour la vue 2 (vue 1 utilisée dans la vue 2)

4. passer l'interface de la vue 1 à la vue 2

Exemple:

Étape 1: vous devez créer une interface et définir une fonction

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

Étape 2: utilisez cette interface en vue

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

Étape 3, 4: implémente l'activité

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

Créez une interface d'écoute.

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

Et créez la méthode setOnCustomClick dans une autre activité (ou fragment), où vous souhaitez appliquer votre écouteur personnalisé ......

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

Appelez cette méthode à partir de votre première activité et passez l'interface d'écoute ...

En 2018, plus besoin d'interfaces d'écoute. Vous disposez d'Android LiveData pour vous permettre de renvoyer le résultat souhaité aux composants de l'interface utilisateur.

Si je vais prendre la réponse de Rupesh et l'ajuster pour utiliser LiveData, cela ressemblera à ceci:

public class Event {

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

         // and in the end

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

et maintenant dans votre classe de pilote 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.
            }
        });
    }
}

Pour plus d'informations ainsi que des exemples de code, vous pouvez lire mon article à ce sujet, ainsi que la documentation officielle:

Quand et pourquoi utiliser LiveData

Documents officiels

Sous Android, vous pouvez créer une interface telle que Listener et votre activité l'implémente, mais je ne pense pas que ce soit une bonne idée. si nous avons de nombreux composants pour écouter les changements de leur état, nous pouvons créer un écouteur d'interface d'implémentation BaseListener, et utiliser le code de type pour les gérer. nous pouvons lier la méthode lorsque nous créons un fichier XML, par exemple:

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

et le code source:

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

mais je ne pense pas que ce soit une bonne idée ...

J'ai fait quelque chose comme ci-dessous pour envoyer ma classe modèle de la deuxième activité à la première activité. J'ai utilisé LiveData pour y parvenir, avec l'aide des réponses de Rupesh et TheCodeFather.

Deuxième activité

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

"liveSong" est AudioListModel déclaré globalement

Appelez cette méthode dans la première activité

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

Puisse cela aider les nouveaux explorateurs comme moi.

Méthode simple pour faire cette approche. Implémente d'abord le OnClickListenersdans votre classe d'activité.

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