La première fois que j'ai rencontré ce problème avec des adaptateurs normaux, j'ai fini par créer ma propre sous-classe View personnalisée et y stocker les éléments dont j'avais besoin. Je n'aimais vraiment pas cette solution et j'ai passé beaucoup de temps à regarder les bonnes idées que les gens avaient proposées, et j'ai décidé que je ne les aimais pas mieux. Alors j'ai en quelque sorte tout mis ensemble, je l'ai secoué pendant un moment et je suis sorti avec quelque chose de nouveau que j'aime.
Nous commençons avec quelques classes d'utilité. ContextMenuHandler est une interface pour n'importe quel objet qui va gérer le menu contextuel. En pratique, cela va être une sous-classe ViewHolder, mais en théorie, cela pourrait être à peu près n'importe quoi
/**
* 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);
}
Vient ensuite une interface qui doit être implémentée par toute vue qui sera utilisée comme enfant immédiat d'un RecyclerView.
public interface ViewWithContextMenu {
public void setContextMenuHandler(FragmentWithContextMenu fragment, ContextMenuHandler handler);
public ContextMenuHandler getContextMenuHandler();
}
Ensuite, toute vue qui va créer un menu contextuel en tant qu'enfant d'un RecylcerView doit implémenter ViewWIthContextMenu. Dans mon cas, je n'avais besoin que d'une sous-classe de 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;
}
}
Et enfin, nous avons besoin d'une classe Fragment renforcée pour intercepter les appels du menu contextuel et les rediriger vers le gestionnaire approprié.
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);
}
}
Avec tout cela en place, la mise en œuvre finale est assez simple. Le fragment principal doit sous-classer FragmentWithContextMenu. Il configure normalement la RecylerWindow principale et passe à la sous-classe Adapter. La sous-classe Adapter ressemble à
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;
}
}
}
C'est à peu près ça. Tout semble fonctionner. Il a mis toutes les classes d'utilitaires dans un package contextmenu séparé afin que j'aie pu donner les noms de classes qui correspondent aux classes qu'il y a sous-classer, mais j'ai pensé que ce serait plus déroutant.
