É possível chamar o método definido em Activityfrom ListAdapter?

(Quero fazer um Buttonin list'srow e quando este botão for clicado deve executar o método, que está definido na Activity correspondente. Tentei setar onClickListenerno meu ListAdaptermas não sei como chamar esse método, qual é o seu caminho. ..)

quando usei Activity.this.method(), recebo o seguinte erro:

No enclosing instance of the type Activity is accessible in scope

Qualquer ideia ?

Sim você pode.

No adaptador, adicione um novo campo:

private Context mContext;

No construtor do adaptador, adicione o seguinte código:

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

No getView (...) do adaptador:

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

substitua por seus próprios nomes de classe onde você vê seu código, sua atividade etc.

Se você precisar usar este mesmo adaptador para mais de uma atividade:

Crie uma interface

public interface IMethodCaller {
    void yourDesiredMethod();
}

Implemente essa interface nas atividades de que você precisa para ter essa funcionalidade de chamada de método.

Então, em Adapter getView (), chame como:

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

Você terminou. Se você precisar usar este adaptador para atividades que não requerem este mecanismo de chamada, o código não será executado (se a verificação falhar).

Você pode fazer desta forma:

Interface de declaração:

public interface MyInterface{
    public void foo();
}

Deixe sua atividade implementá-la:

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

Em seguida, passe sua atividade para ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

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

E em algum lugar do adaptador, quando você precisar chamar esse método Activity:

listener.foo();

Original:

Eu entendo a resposta atual, mas precisava de um exemplo mais claro. Aqui está um exemplo do que usei com um Adapter(RecyclerView.Adapter) e um Activity.

Em sua atividade:

Isso implementará o interfaceque temos em nosso Adapter. Neste exemplo, ele será chamado quando o usuário clicar em um item no 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);
    }
}

Em seu adaptador:

No Activity, iniciamos nosso Adaptere passamos isso como um argumento para o construtor. Isso iniciará nosso interfacemétodo de retorno de chamada. Você pode ver que usamos nosso método de retorno de chamada para cliques do usuário.

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

Básico e simples.

Em seu adaptador, basta usar isso.

((YourParentClass) context).functionToRun();

Mais uma maneira é:

Escreva um método em seu adaptador, digamos public void callBack () {}.

Agora, ao criar um objeto para o adaptador na atividade, substitua este método. O método de substituição será chamado quando você chamar o método no adaptador.

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

Para Kotlin:

Em seu adaptador, basta ligar

(context as Your_Activity_Name).yourMethod()

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

esta condição irá permitir que você execute algo se a Activity que tem as GroupViewvisualizações solicitantes do getView()método de seu adapterforyourActivity

NOTA: parenté esse GroupView

Em Kotlin, agora existe uma maneira mais limpa de usar funções lambda, sem necessidade de 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) {

    }
}