È possibile chiamare un metodo definito in Activityfrom ListAdapter?

(Voglio fare un Buttonin list'sfila e quando questo pulsante viene premuto, si deve eseguire il metodo, che è definito in corrispondenti attività. Ho cercato di serie onClickListenernel mio ListAdapter, ma non so come chiamare questo metodo, qual è il suo percorso. ..)

quando l'ho usato Activity.this.method()ottengo il seguente errore:

No enclosing instance of the type Activity is accessible in scope

Qualche idea ?

Si, puoi.

Nell'adattatore Aggiungi un nuovo campo:

private Context mContext;

Nel costruttore dell'adattatore aggiungere il codice seguente:

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

Nel getView (...) di 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();
    }
  }
});

sostituisci con i tuoi nomi di classe in cui vedi il tuo codice, la tua attività ecc.

Se è necessario utilizzare lo stesso adattatore per più di un'attività, allora:

Crea un'interfaccia

public interface IMethodCaller {
    void yourDesiredMethod();
}

Implementa questa interfaccia nelle attività necessarie per avere questa funzionalità di chiamata del metodo.

Quindi in Adapter getView (), chiama come:

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

Hai fatto. Se è necessario utilizzare questo adattatore per attività che non richiedono questo meccanismo di chiamata, il codice non verrà eseguito (se il controllo non riesce).

Puoi farlo in questo modo:

Dichiara l'interfaccia:

public interface MyInterface{
    public void foo();
}

Lascia che la tua attività lo realizzi:

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

Quindi passa la tua attività a ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

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

E da qualche parte nell'adattatore, quando è necessario chiamare quel metodo Activity:

listener.foo();

Originale:

Capisco la risposta attuale ma avevo bisogno di un esempio più chiaro. Ecco un esempio di ciò che ho usato con un Adapter(RecyclerView.Adapter) e un file Activity.

Nella tua attività:

Questo implementerà interfaceciò che abbiamo nel nostro Adapter. In questo esempio, verrà chiamato quando l'utente fa clic su un elemento nel file 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);
    }
}

Nel tuo adattatore:

In Activity, abbiamo avviato il nostro Adaptere lo abbiamo passato come argomento al costruttore. Questo avvierà il interfacenostro metodo di callback. Come puoi vedere, utilizziamo il nostro metodo di callback per i clic degli utenti.

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

Di base e semplice.

Nel tuo adattatore usa semplicemente questo.

((YourParentClass) context).functionToRun();

Un altro modo è:

Scrivi un metodo nel tuo adattatore diciamo public void callBack () {}.

Ora, durante la creazione di un oggetto per l'adattatore in attività, sovrascrivere questo metodo. Il metodo Override verrà chiamato quando si chiama il metodo nell'adattatore.

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

Per Kotlin:

Nel tuo adattatore, chiama semplicemente

(context as Your_Activity_Name).yourMethod()

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

questa condizione ti consentirà di eseguire qualcosa se l'Attività che ha le GroupViewviste richieste dal getView()tuo metodo adapterèyourActivity

NOTA: parentè quel GroupView

In Kotlin ora esiste un modo più pulito utilizzando le funzioni lambda, senza bisogno di interfacce:

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) {

    }
}