Ist es möglich, eine Methode aufzurufen, die in Activityfrom definiert ist ListAdapter?

(Ich will ein , um Buttonin list'sReihe und wenn diese Taste angeklickt wird, soll es das Verfahren durchführt, die in entsprechender Aktivität definiert ist. Ich habe versucht, Satz onClickListenerin meiner , ListAdapteraber ich weiß nicht , wie diese Methode nennen, was sein Weg ist. ..)

Wenn ich verwendet Activity.this.method()habe, erhalte ich die folgende Fehlermeldung:

No enclosing instance of the type Activity is accessible in scope

Irgendeine Idee ?

Ja, du kannst.

Im Adapter Neues Feld hinzufügen:

private Context mContext;

Fügen Sie im Adapterkonstruktor den folgenden Code hinzu:

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

In der getView (...) des Adapters:

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

Ersetzen Sie durch Ihre eigenen Klassennamen, in denen Sie Ihren Code, Ihre Aktivität usw. sehen.

Wenn Sie denselben Adapter für mehr als eine Aktivität verwenden müssen, gehen Sie wie folgt vor:

Erstellen Sie eine Schnittstelle

public interface IMethodCaller {
    void yourDesiredMethod();
}

Implementieren Sie diese Schnittstelle in Aktivitäten, für die Sie diese Funktion zum Aufrufen von Methoden benötigen.

Rufen Sie dann in Adapter getView () wie folgt auf:

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

Du bist fertig. Wenn Sie diesen Adapter für Aktivitäten verwenden müssen, für die dieser Aufrufmechanismus nicht erforderlich ist, wird der Code nicht ausgeführt (wenn die Prüfung fehlschlägt).

Sie können es so machen:

Schnittstelle deklarieren:

public interface MyInterface{
    public void foo();
}

Lassen Sie Ihre Aktivität es umsetzen:

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

Übergeben Sie dann Ihre Aktivität an ListAdater:

public MyAdapter extends BaseAdater{
    private MyInterface listener;

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

Und irgendwo im Adapter, wenn Sie diese Aktivitätsmethode aufrufen müssen:

listener.foo();

Original:

Ich verstehe die aktuelle Antwort, brauchte aber ein klareres Beispiel. Hier ist ein Beispiel dafür, was ich mit einem Adapter(RecyclerView.Adapter) und einem verwendet habe Activity.

In Ihrer Aktivität:

Dies wird das implementieren interface, was wir in unserem haben Adapter. In diesem Beispiel wird es aufgerufen, wenn der Benutzer auf ein Element im Feld klickt 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);
    }
}

In Ihrem Adapter:

In der Activityhaben wir unsere initiiert Adapterund dies als Argument an den Konstruktor weitergegeben. Dies wird interfaceunsere Rückrufmethode einleiten . Sie sehen, dass wir unsere Rückrufmethode für Benutzerklicks verwenden.

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

Einfach und einfach.

Verwenden Sie dies in Ihrem Adapter einfach.

((YourParentClass) context).functionToRun();

Ein weiterer Weg ist ::

Schreiben Sie eine Methode in Ihren Adapter, sagen wir public void callBack () {}.

Wenn Sie jetzt ein Objekt für den Adapter in der Aktivität erstellen, überschreiben Sie diese Methode. Die Override-Methode wird aufgerufen, wenn Sie die Methode im Adapter aufrufen.

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

Für Kotlin:

Rufen Sie in Ihrem Adapter einfach an

(context as Your_Activity_Name).yourMethod()

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

Diese Bedingung ermöglicht es Ihnen, etwas auszuführen, wenn die Aktivität, die die GroupViewanfordernden Ansichten von der getView()Methode von Ihnen hat, adapteristyourActivity

HINWEIS: parentIst das GroupView

In Kotlin gibt es jetzt eine sauberere Möglichkeit, Lambda-Funktionen zu verwenden, ohne dass Schnittstellen erforderlich sind:

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

    }
}