Czy można wywołać metodę zdefiniowaną w Activityfrom ListAdapter?

(Chcę zrobić wiersz Buttonw list'swierszu i po kliknięciu tego przycisku powinien wykonać metodę, która jest zdefiniowana w odpowiednim działaniu. Próbowałem ustawić onClickListenerw moim, ListAdapterale nie wiem, jak wywołać tę metodę, jaka jest jej ścieżka. ..)

kiedy użyłem Activity.this.method(), otrzymuję następujący błąd:

No enclosing instance of the type Activity is accessible in scope

Dowolny pomysł ?

Tak, możesz.

W adapterze Dodaj nowe pole:

private Context mContext;

W konstruktorze adaptera dodaj następujący kod:

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

W getView (...) adaptera:

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

zastąp własnymi nazwami klas, w których widzisz swój kod, aktywność itp.

Jeśli potrzebujesz użyć tego samego adaptera do więcej niż jednej czynności, to:

Utwórz interfejs

public interface IMethodCaller {
    void yourDesiredMethod();
}

Zaimplementuj ten interfejs w działaniach, których potrzebujesz, aby mieć tę funkcję wywoływania metody.

Następnie w adapterze getView () wywołaj:

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

Skończyłeś. Jeśli potrzebujesz użyć tego adaptera do działań, które nie wymagają tego mechanizmu wywołującego, kod nie zostanie wykonany (jeśli sprawdzenie nie powiedzie się).

Możesz to zrobić w ten sposób:

Zadeklaruj interfejs:

public interface MyInterface{
    public void foo();
}

Pozwól swojej aktywności to zrealizować:

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

Następnie przekaż swoją aktywność do ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

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

I gdzieś w adapterze, kiedy musisz wywołać tę metodę Activity:

listener.foo();

Oryginalny:

Rozumiem obecną odpowiedź, ale potrzebowałem wyraźniejszego przykładu. Oto przykład tego, co użyłem z Adapter(RecyclerView.Adapter) i plikiem Activity.

W Twojej aktywności:

Spowoduje to wdrożenie tego interface, co mamy w naszym Adapter. W tym przykładzie zostanie wywołana, gdy użytkownik kliknie element w 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);
    }
}

W Twoim adapterze:

W Activity, zainicjowaliśmy nasz Adapteri przekazaliśmy to jako argument konstruktorowi. Spowoduje to zainicjowanie naszej interfacemetody wywołania zwrotnego. Możesz zobaczyć, że używamy naszej metody wywołania zwrotnego dla kliknięć użytkowników.

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

Podstawowe i proste.

W swoim adapterze po prostu użyj tego.

((YourParentClass) context).functionToRun();

Jeszcze jeden sposób:

Napisz metodę w swoim adapterze, powiedzmy public void callBack () {}.

Teraz podczas tworzenia obiektu dla adaptera w aktywności należy zastąpić tę metodę. Metoda Override zostanie wywołana po wywołaniu metody w adapterze.

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

Kotlin:

Wystarczy zadzwonić w adapterze

(context as Your_Activity_Name).yourMethod()

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

ten warunek umożliwi ci wykonanie czegoś, jeśli działanie, które ma GroupViewżądające widoki z getView()twojej metody, adaptertoyourActivity

UWAGA: parentczy to GroupView

W Kotlinie jest teraz bardziej przejrzysty sposób dzięki wykorzystaniu funkcji lambda, bez konieczności stosowania interfejsów:

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

    }
}