Als ich zum ersten Mal mit normalen Adaptern auf dieses Problem stieß, erstellte ich meine eigene benutzerdefinierte Ansichtsunterklasse und speicherte das benötigte Material darin. Ich mochte diese Lösung wirklich nicht und verbrachte viel Zeit damit, mir die großartigen Ideen anzusehen, die die Leute vorgeschlagen haben, und entschied, dass ich sie nicht besser mochte. Also habe ich alles zusammengefügt, eine Weile herumgeschüttelt und etwas Neues herausgebracht, das mir gefällt.
Wir beginnen mit ein paar Utility-Klassen. ContextMenuHandler ist eine Schnittstelle für jedes Objekt, das das Kontextmenü verarbeiten soll. In der Praxis wird dies eine ViewHolder-Unterklasse sein, aber theoretisch könnte es fast alles sein
/**
* Interface for objects that wish to create and handle selections from a context
* menu associated with a view
*/
public interface ContextMenuHandler extends View.OnCreateContextMenuListener {
boolean onContextItemSelected(MenuItem item);
}
Als nächstes folgt eine Schnittstelle, die von jeder Ansicht implementiert werden muss, die als unmittelbares untergeordnetes Element einer RecyclerView verwendet werden soll.
public interface ViewWithContextMenu {
public void setContextMenuHandler(FragmentWithContextMenu fragment, ContextMenuHandler handler);
public ContextMenuHandler getContextMenuHandler();
}
Als Nächstes muss jede Ansicht, die als untergeordnetes Element einer RecylcerView ein Kontextmenü erstellen soll, ViewWIthContextMenu implementieren. In meinem Fall brauchte ich nur eine Unterklasse von LinearLayout.
public class LinearLayoutWithContextMenu extends LinearLayout implements ViewWithContextMenu {
public LinearLayoutWithContextMenu(Context context) {
super(context);
}
public LinearLayoutWithContextMenu(Context context, AttributeSet attrs) {
super(context, attrs);
}
private ContextMenuHandler handler;
@Override
public void setContextMenuHandler(FragmentWithContextMenu fragment, ContextMenuHandler handler) {
this.handler = handler;
setOnCreateContextMenuListener(fragment);
}
@Override
public ContextMenuHandler getContextMenuHandler() {
return handler;
}
}
Und schließlich benötigen wir eine aufgemotzte Fragment-Klasse, um die Kontextmenü-Aufrufe abzufangen und an den entsprechenden Handler umzuleiten.
public class FragmentWithContextMenu extends Fragment {
ContextMenuHandler handler = null;
@Override
public void onCreateContextMenu(ContextMenu menu, View view, ContextMenu.ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, view, menuInfo);
handler = null;
if (view instanceof ViewWithContextMenu) {
handler = ((ViewWithContextMenu)view).getContextMenuHandler();
if (handler != null) handler.onCreateContextMenu(menu, view, menuInfo);
}
}
@Override
public boolean onContextItemSelected(MenuItem item) {
if (handler != null) {
if (handler.onContextItemSelected(item)) return true;
}
return super.onContextItemSelected(item);
}
}
Mit all dem ist die endgültige Implementierung ziemlich einfach. Das Hauptfragment muss FragmentWithContextMenu unterordnen. Es richtet das Haupt-RecylerWindow normal ein und übergibt sich selbst an die Adapter-Unterklasse. Die Adapter-Unterklasse sieht aus wie
public class Adapter extends RecyclerView.Adapter<Adapter.ViewHolder> {
private final FragmentWithContextMenu fragment;
Adapter(FragmentWithContextMenu fragment) {
this.fragment = fragment;
}
@Override
public Adapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = LayoutInflater.from(context)
.inflate(R.layout.child_view, parent, false);
return new ViewHolder(view);
}
@Override
public void onBindViewHolder(final Adapter.ViewHolder holder, int position) {
// Logic needed to bind holder to specific position
// ......
}
@Override
public int getItemCount() {
// Logic to return current item count
// ....
}
public class ViewHolder extends RecyclerView.ViewHolder implements ContextMenuHandler {
ViewHolder(View view) {
super(view);
((ViewWithContextMenu)view).setContextMenuHandler(fragment, this);
view.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// Do stuff to handle simple clicks on child views
// .......
}
});
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
// Logic to set up context menu goes here
// ....
}
@Override
public boolean onContextItemSelected(MenuItem item) {
// Logic to handle context menu item selections goes here
// ....
return true;
}
}
}
Das ist alles. Es scheint alles zu funktionieren. Alle Utility-Klassen wurden in ein separates Kontextmenü-Paket gestellt, sodass ich die Klassennamen hätte angeben können, die mit den dortigen Klassen übereinstimmen, aber ich dachte, das wäre verwirrender.
