¿Es posible llamar al método que se define en Activitydesde ListAdapter?

(Quiero hacer una Buttonen la list'sfila y cuando se hace clic en este botón, se debería realizar el procedimiento, que se define en la actividad correspondiente. Traté de conjunto onClickListeneren mi ListAdapter, pero no sé cómo llamar a este método, ¿cuál es su camino. ..)

cuando lo usé Activity.this.method(), obtengo el siguiente error:

No enclosing instance of the type Activity is accessible in scope

Alguna idea ?

Sí tu puedes.

En el adaptador, agregue un nuevo campo:

private Context mContext;

En el adaptador Constructor agregue el siguiente código:

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

En el getView (...) de Adapter:

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

reemplace con sus propios nombres de clase donde vea su código, su actividad, etc.

Si necesita usar este mismo adaptador para más de una actividad, entonces:

Crea una interfaz

public interface IMethodCaller {
    void yourDesiredMethod();
}

Implemente esta interfaz en las actividades que necesite para tener esta funcionalidad de llamada al método.

Luego, en Adapter getView (), llame 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();
        }
    }
});

Estás listo. Si necesita usar este adaptador para actividades que no requieren este mecanismo de llamada, el código no se ejecutará (si la verificación falla).

Puedes hacerlo de esta manera:

Declarar interfaz:

public interface MyInterface{
    public void foo();
}

Deje que su actividad la complemente:

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

Luego, pase su actividad a ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

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

Y en algún lugar del adaptador, cuando necesite llamar a ese método de actividad:

listener.foo();

Original:

Entiendo la respuesta actual, pero necesitaba un ejemplo más claro. Aquí hay un ejemplo de lo que usé con un Adapter(RecyclerView.Adapter) y un Activity.

En tu actividad:

Esto implementará lo interfaceque tenemos en nuestro Adapter. En este ejemplo, se llamará cuando el usuario haga clic en un elemento del archivo 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);
    }
}

En su adaptador:

En Activity, iniciamos nuestro Adaptery pasamos esto como argumento al constructor. Esto iniciará nuestro interfacemétodo de devolución de llamada. Puede ver que usamos nuestro método de devolución de llamada para los clics de los usuarios.

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 y sencillo.

En su adaptador, simplemente use esto.

((YourParentClass) context).functionToRun();

Una forma más es:

Escriba un método en su adaptador, digamos public void callBack () {}.

Ahora, mientras crea un objeto para el adaptador en la actividad, anule este método. Se llamará al método de anulación cuando llame al método en el adaptador.

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

Para Kotlin:

En su adaptador, simplemente llame

(context as Your_Activity_Name).yourMethod()

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

esta condición le permitirá ejecutar algo si la Actividad que tiene la GroupViewsolicitud de vistas del getView()método de su adapteresyourActivity

NOTA: parentes que GroupView

En Kotlin ahora hay una forma más limpia mediante el uso de funciones lambda, sin necesidad 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) {

    }
}