Est-il possible d'appeler une méthode définie dans Activityfrom ListAdapter?

(Je veux faire Buttonen list'sligne et lorsque ce bouton est cliqué, il est conseillé d' effectuer la méthode, qui est définie dans l' activité correspondante. J'essayé de mettre onClickListenerdans mon ListAdaptermais je ne sais pas comment appeler cette méthode, ce qui est son chemin. ..)

quand j'ai utilisé, Activity.this.method()j'obtiens l'erreur suivante:

No enclosing instance of the type Activity is accessible in scope

Une idée ?

Oui, vous pouvez.

Dans l'adaptateur, ajoutez un nouveau champ:

private Context mContext;

Dans le constructeur de l'adaptateur, ajoutez le code suivant:

public AdapterName(......, Context context) {
  //your code.
  this.mContext = context;
}

Dans le getView (...) de l'adaptateur:

Button btn = (Button) convertView.findViewById(yourButtonId);
btn.setOnClickListener(new Button.OnClickListener() {
  @Override
  public void onClick(View v) {
    if (mContext instanceof YourActivityName) {
      ((YourActivityName)mContext).yourDesiredMethod();
    }
  }
});

remplacez par vos propres noms de classe là où vous voyez votre code, votre activité, etc.

Si vous devez utiliser ce même adaptateur pour plusieurs activités, alors:

Créer une interface

public interface IMethodCaller {
    void yourDesiredMethod();
}

Implémentez cette interface dans les activités dont vous avez besoin pour avoir cette fonctionnalité d'appel de méthode.

Ensuite, dans Adapter getView (), appelez comme:

Button btn = (Button) convertView.findViewById(yourButtonId);
btn.setOnClickListener(new Button.OnClickListener() {
    @Override
    public void onClick(View v) {
        if (mContext instanceof IMethodCaller) {
            ((IMethodCaller) mContext).yourDesiredMethod();
        }
    }
});

Vous avez terminé. Si vous devez utiliser cet adaptateur pour des activités qui ne nécessitent pas ce mécanisme d'appel, le code ne s'exécutera pas (si la vérification échoue).

Vous pouvez le faire de cette façon:

Déclarer l'interface:

public interface MyInterface{
    public void foo();
}

Laissez votre activité l'imlement:

public class MyActivity extends Activity implements MyInterface{
    public void foo(){
        //do stuff
    }
}

Puis transmettez votre activité à ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

    public MyAdapter(MyInterface listener){
        this.listener = listener;
    }
}

Et quelque part dans l'adaptateur, lorsque vous devez appeler cette méthode Activity:

listener.foo();

Original:

Je comprends la réponse actuelle mais j'avais besoin d'un exemple plus clair. Voici un exemple de ce que j'ai utilisé avec un Adapter(RecyclerView.Adapter) et un Activity.

Dans votre activité:

Cela implémentera le interfaceque nous avons dans notre Adapter. Dans cet exemple, il sera appelé lorsque l'utilisateur cliquera sur un élément dans le RecyclerView.

public class MyActivity extends Activity implements AdapterCallback {

    private MyAdapter myAdapter;

    @Override
    public void onMethodCallback() {
       // do something
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        myAdapter = new MyAdapter(this);
    }
}

Dans votre adaptateur:

Dans le Activity, nous avons lancé notre Adapteret l' avons passé en argument au constructeur. Cela lancera interfacenotre méthode de rappel. Vous pouvez voir que nous utilisons notre méthode de rappel pour les clics des utilisateurs.

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolder> {

    private AdapterCallback adapterCallback;

    public MyAdapter(Context context) {
        try {
            adapterCallback = ((AdapterCallback) context);
        } catch (ClassCastException e) {
            throw new ClassCastException("Activity must implement AdapterCallback.", e);
        }
    }

    @Override
    public void onBindViewHolder(MyAdapter.ViewHolder viewHolder, int position) {
        // simple example, call interface here
        // not complete
        viewHolder.itemView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View view) {
                try {
                    adapterCallback.onMethodCallback();
                } catch (ClassCastException e) {
                   // do something
                }
            }
        });
    }

    public static interface AdapterCallback {
        void onMethodCallback();
    }
}

Basique et simple.

Dans votre adaptateur, utilisez simplement ceci.

((YourParentClass) context).functionToRun();

Une autre façon est:

Écrivez une méthode dans votre adaptateur, disons public void callBack () {}.

Maintenant, lors de la création d'un objet pour l'adaptateur en activité, remplacez cette méthode. La méthode de remplacement sera appelée lorsque vous appelez la méthode dans l'adaptateur.

Myadapter adapter = new Myadapter() {
  @Override
  public void callBack() {
    // dosomething
  }
};

Pour Kotlin:

Dans votre adaptateur, appelez simplement

(context as Your_Activity_Name).yourMethod()

if (parent.getContext() instanceof yourActivity) {
  //execute code
}

cette condition vous permettra d'exécuter quelque chose si l'activité qui a les GroupViewvues qui demandent de la getView()méthode de votre adapterestyourActivity

REMARQUE: parentest-ce que GroupView

Dans Kotlin, il existe maintenant un moyen plus propre en utilisant des fonctions lambda, pas besoin d'interfaces:

class MyAdapter(val adapterOnClick: (Any) -> Unit) {
    fun setItem(item: Any) {
        myButton.setOnClickListener { adapterOnClick(item) }
    }
}

class MyActivity {
    override fun onCreate(savedInstanceState: Bundle?) {
        var myAdapter = MyAdapter { item -> doOnClick(item) }
    }


    fun doOnClick(item: Any) {

    }
}