A primeira vez que tive esse problema com adaptadores normais, acabei criando minha própria subclasse de Visualização personalizada e armazenando o material de que precisava. Eu realmente não gostei dessa solução e passei muito tempo olhando as grandes ideias que as pessoas propuseram e decidi que não gostava mais delas. Então eu meio que juntei tudo, balancei por um tempo e criei algo novo que eu gosto.
Começamos com algumas classes de utilitários. ContextMenuHandler é uma interface para qualquer objeto que manipulará o menu de contexto. Na prática, esta será uma subclasse ViewHolder, mas em teoria pode ser qualquer coisa
/**
* 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);
}
Em seguida, está uma Interface que deve ser implementada por qualquer View que será usada como filho imediato de um RecyclerView.
public interface ViewWithContextMenu {
public void setContextMenuHandler(FragmentWithContextMenu fragment, ContextMenuHandler handler);
public ContextMenuHandler getContextMenuHandler();
}
Em seguida, qualquer visualização que criará um menu de contexto como filho de um RecylcerView deve implementar ViewWIthContextMenu. No meu caso, eu só precisava de uma subclasse 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;
}
}
E, finalmente, precisamos de uma classe Fragment aprimorada para interceptar as chamadas do menu de contexto e redirecioná-las para o manipulador apropriado.
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);
}
}
Com tudo isso instalado, a implementação final é muito simples. O fragmento principal deve ser subclasse FragmentWithContextMenu. Ele configura a RecylerWindow principal normalmente e passa para a subclasse Adapter. A subclasse Adapter parece
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;
}
}
}
É sobre isso. Tudo parece estar funcionando. Ele colocou todas as classes de utilitários em um pacote de menu de contexto separado para que eu pudesse dar nomes às classes que correspondiam às classes que existem como subclasses, mas achei que seria mais confuso.
