Método de actividad de llamada desde el adaptador

¿Es posible llamar al método que está definido en Activity from ListAdapter ?

(Quiero hacer un Button en list's fila de list's y cuando se hace clic en este botón, debe realizar el método, que se define en la actividad correspondiente. Intenté configurar onClickListener en mi ListAdapter pero no sé cómo llamar a este método, cuál es su camino …)

cuando utilicé Activity.this.method() aparece 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 necesita para tener esta funcionalidad de llamada de método.

Luego, en Adapter getView (), llame al:

 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 utilizar este adaptador para actividades que no requieren este mecanismo de llamada, el código no se ejecutará (si falla la comprobación).

Puedes hacerlo de esta manera:

Declarar interfaz:

 public interface MyInterface{ public void foo(); } 

Deje que su actividad lo implique:

 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:

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

En tu actividad:

Esto implementará la interface que tenemos en nuestro Adapter . En este ejemplo, se llamará cuando el usuario haga clic en un elemento en RecyclerView .

 public class MyActivity extends Activity implements AdapterCallback { private MyAdapter mMyAdapter; @Override public void onMethodCallback() { // do something } @Override protected void onCreate(final Bundle savedInstanceState) { super.onCreate(savedInstanceState); this.mMyAdapter = new MyAdapter(this); } } 

En tu adaptador:

En la Activity , iniciamos nuestro Adapter y pasamos esto como un argumento para el constructor. Esto iniciará nuestra interface para nuestro método de callback. Puede ver que usamos nuestro método de callback para los clics del usuario.

 public class MyAdapter extends RecyclerView.Adapter { private AdapterCallback mAdapterCallback; public MyAdapter(Context context) { try { this.mAdapterCallback = ((AdapterCallback) context); } catch (ClassCastException e) { throw new ClassCastException("Activity must implement AdapterCallback."); } } @Override public void onBindViewHolder(final MyAdapter.ViewHolder viewHolder, final int i) { // simple example, call interface here // not complete viewHolder.itemView.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { try { mAdapterCallback.onMethodCallback(); } catch (ClassCastException exception) { // do something } } }); } public static interface AdapterCallback { void onMethodCallback(); } } 

Básico y simple.

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, al crear un objeto para adaptador en actividad anula 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 } }; 
 if(parent.getContext() instanceof yourActivity){ //execute code } 

Esta condición le permitirá ejecutar algo si la actividad que tiene el GroupView que solicita vistas desde el método getView() de su adapter es su yourActivity

NOTA: el parent es ese GroupView

Para Kotlin:

En tu adaptador, simplemente llama

 (context as Your_Activity_Name).your_method_name() 
Intereting Posts