Spinner: obtenir l'état ou être averti quand ouvre
Est-il possible de savoir si une Spinner est ouverte ou fermée? Ce serait même mieux s'il y avait une sorte de onOpenListener pour Spinners.
J'ai essayé d'utiliser un OnItemSelectedListener comme ceci:
spinnerType.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
executeSomething();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
Log.d("nothing" , "selected");
}
});
Je peux savoir que la fenêtre se fermera si quelque chose est sélectionné (dans executeSomething ()). Mais je ne suis pas averti si je clique en dehors du dialogue, ce qui ferme également le disque.
Une autre option à surveiller pour ces événements consiste à étendre la classe Spinner et à utiliser l'une de ses méthodes (performClick() qui déclenchera sa boîte de dialogue/popup), suivie du contrôle du focus de la fenêtre contenant cette Spinner personnalisée. Cela devrait vous fournir l'événement fermé souhaité pour toutes les possibilités de finition possibles (pour le mode dialogue ou le menu déroulant).
La classe Spinner personnalisée:
public class CustomSpinner extends Spinner {
/**
* An interface which a client of this Spinner could use to receive
* open/closed events for this Spinner.
*/
public interface OnSpinnerEventsListener {
/**
* Callback triggered when the spinner was opened.
*/
void onSpinnerOpened(Spinner spinner);
/**
* Callback triggered when the spinner was closed.
*/
void onSpinnerClosed(Spinner spinner);
}
private OnSpinnerEventsListener mListener;
private boolean mOpenInitiated = false;
// implement the Spinner constructors that you need
@Override
public boolean performClick() {
// register that the Spinner was opened so we have a status
// indicator for when the container holding this Spinner may lose focus
mOpenInitiated = true;
if (mListener != null) {
mListener.onSpinnerOpened(this);
}
return super.performClick();
}
@Override
public void onWindowFocusChanged (boolean hasFocus) {
if (hasBeenOpened() && hasFocus) {
performClosedEvent();
}
}
/**
* Register the listener which will listen for events.
*/
public void setSpinnerEventsListener(
OnSpinnerEventsListener onSpinnerEventsListener) {
mListener = onSpinnerEventsListener;
}
/**
* Propagate the closed Spinner event to the listener from outside if needed.
*/
public void performClosedEvent() {
mOpenInitiated = false;
if (mListener != null) {
mListener.onSpinnerClosed(this);
}
}
/**
* A boolean flag indicating that the Spinner triggered an open event.
*
* @return true for opened Spinner
*/
public boolean hasBeenOpened() {
return mOpenInitiated;
}
}
sur la base de la merveilleuse solution @Luksprog, je souhaite simplement ajouter une petite modification qui sera très utile si quelqu'un utilise le CustomSpinner dans un fragment . au lieu d'utiliser la fonction Activity.onWindowFocusChanged, nous remplaçons la fonction View.onWindowFocusChanged. ainsi toute la classe CustomSpinner devient
import Android.content.Context;
import Android.util.AttributeSet;
import Android.widget.Spinner;
public class CustomSpinner extends Spinner {
private static final String TAG = "CustomSpinner";
private OnSpinnerEventsListener mListener;
private boolean mOpenInitiated = false;
public CustomSpinner(Context context, AttributeSet attrs, int defStyleAttr, int mode) {
super(context, attrs, defStyleAttr, mode);
}
public CustomSpinner(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
public CustomSpinner(Context context, AttributeSet attrs) {
super(context, attrs);
}
public CustomSpinner(Context context, int mode) {
super(context, mode);
}
public CustomSpinner(Context context) {
super(context);
}
public interface OnSpinnerEventsListener {
void onSpinnerOpened();
void onSpinnerClosed();
}
@Override
public boolean performClick() {
// register that the Spinner was opened so we have a status
// indicator for the activity(which may lose focus for some other
// reasons)
mOpenInitiated = true;
if (mListener != null) {
mListener.onSpinnerOpened();
}
return super.performClick();
}
public void setSpinnerEventsListener(OnSpinnerEventsListener onSpinnerEventsListener) {
mListener = onSpinnerEventsListener;
}
/**
* Propagate the closed Spinner event to the listener from outside.
*/
public void performClosedEvent() {
mOpenInitiated = false;
if (mListener != null) {
mListener.onSpinnerClosed();
}
}
/**
* A boolean flag indicating that the Spinner triggered an open event.
*
* @return true for opened Spinner
*/
public boolean hasBeenOpened() {
return mOpenInitiated;
}
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
Android.util.Log.d(TAG, "onWindowFocusChanged");
super.onWindowFocusChanged(hasWindowFocus);
if (hasBeenOpened() && hasWindowFocus) {
Android.util.Log.i(TAG, "closing popup");
performClosedEvent();
}
}
}
Salut les amis, je me bats sur cette question depuis deux jours et j'ai enfin la solution suivante qui a fait mon travail J'ai essayé et cela a fonctionné parfaitement. Merci
mSpinner.setOnTouchListener(new OnTouchListener(){
@Override
public boolean onTouch(View v, MotionEvent event) {
if(event.getAction() == MotionEvent.ACTION_DOWN){
Toast.makeText(MapActivity.this,"down",Toast.LENGTH_LONG).show();
// Load your spinner here
}
return false;
}
});
Il n'y a pas de fonction intégrée mais c'est assez facile à faire avec OnTouchListener et OnItemSelectedListener.
abstract class OnOpenListener implements OnTouchListener, OnItemSelectedListener {
public OnOpenListener(Spinner spinner) {
spinner.setOnTouchListener(this);
spinner.setOnItemSelectedListener(this);
}
@Override
public boolean onTouch(View v, MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_UP) {
onOpen();
}
return false;
}
@Override
public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
onClose();
}
@Override
public void onNothingSelected(AdapterView<?> arg0) {
onClose();
}
abstract public void onOpen();
abstract public void onClose();
}
Et ensuite, assignez les auditeurs appropriés:
OnOpenListener onOpenListener = new OnOpenListener(mySpinner) {
@Override
public void onOpen() {
// spinner was opened
}
@Override
public void onClose() {
// spinner was closed
}
};
Je pense que la meilleure façon de savoir quand il a été ouvert et fermé est la suivante:
S'il était fermé et qu'il appelle maintenant "getDropDownView" dans l'adaptateur, on peut supposer qu'il s'est ouvert.
Si "onItemSelected" ou "onNothingSelected" sont appelés, il est maintenant fermé.
EDIT: voici un exemple de code
public class MainActivity extends AppCompatActivity {
boolean isSpinnerClosed = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
AppCompatSpinner spinner2 = (AppCompatSpinner) findViewById(R.id.spinner2);
List<String> list = new ArrayList<String>();
list.add("list 1");
list.add("list 2");
list.add("list 3");
Log.d("AppLog", "started");
//spinner2.setondi
ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this, Android.R.layout.simple_spinner_item, list) {
@Override
public View getDropDownView(final int position, @Nullable final View convertView, @NonNull final ViewGroup parent) {
if (isSpinnerClosed) {
Log.d("AppLog", "closed->open");
isSpinnerClosed = false;
}
return super.getDropDownView(position, convertView, parent);
}
};
spinner2.setOnItemSelectedListener(new OnItemSelectedListener() {
@Override
public void onItemSelected(final AdapterView<?> adapterView, final View view, final int i, final long l) {
Log.d("AppLog", "onItemSelected");
if (!isSpinnerClosed) {
Log.d("AppLog", "open->closed");
isSpinnerClosed = true;
}
}
@Override
public void onNothingSelected(final AdapterView<?> adapterView) {
Log.d("AppLog", "onNothingSelected");
if (!isSpinnerClosed) {
Log.d("AppLog", "open->closed");
isSpinnerClosed = true;
}
}
});
dataAdapter.setDropDownViewResource(Android.R.layout.simple_spinner_dropdown_item);
spinner2.setAdapter(dataAdapter);
}
@Override
public void onWindowFocusChanged(final boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
if (hasFocus && isSpinnerClosed) {
Log.d("AppLog", "open->closed");
isSpinnerClosed = true;
}
}
}
Je ne pouvais pas trouver un moyen d'obtenir ce comportement avec spinner, donc la seule chose qui a fonctionné pour moi a été d'utiliser l'adaptateur spinner (personnalisé) à la place:
public interface SpinnerListener {
void onSpinnerExpanded();
void onSpinnerCollapsed();
}
Ensuite, un adaptateur personnalisé peut être écrit pour capturer simplement la vue «élargie» et y ajouter un écouteur pour écouter les événements «développer» et «réduire». L'adaptateur personnalisé que j'ai utilisé est:
public class ListeningArrayAdapter<T> extends ArrayAdapter<T> {
private ViewGroup itemParent;
private final Collection<SpinnerListener> spinnerListeners = new ArrayList<SpinnerListener>();
public ListeningArrayAdapter(Context context, int resource, T[] objects) {
super(context, resource, objects);
}
// Add the rest of the constructors here ...
// Just grab the spinner view (parent of the spinner item view) and add a listener to it.
@Override
public View getDropDownView(int position, View convertView, ViewGroup parent) {
if (isParentTheListView(parent)) {
itemParent = parent;
addFocusListenerAsExpansionListener();
}
return super.getDropDownView(position, convertView, parent);
}
// Assumes the item view parent is a ListView (which it is when a Spinner class is used)
private boolean isParentTheListView(ViewGroup parent) {
return (parent != itemParent && parent != null && ListView.class.isAssignableFrom(parent.getClass()));
}
// Add a focus listener to listen to spinner expansion and collapse events.
private void addFocusListenerAsExpansionListener() {
final View.OnFocusChangeListener listenerWrapper = new OnFocusChangeListenerWrapper(itemParent.getOnFocusChangeListener(), spinnerListeners);
itemParent.setOnFocusChangeListener(listenerWrapper);
}
// Utility method.
public boolean isExpanded() {
return (itemParent != null && itemParent.hasFocus());
}
public void addSpinnerListener(SpinnerListener spinnerListener) {
spinnerListeners.add(spinnerListener);
}
public boolean removeSpinnerListener(SpinnerListener spinnerListener) {
return spinnerListeners.remove(spinnerListener);
}
// Listener that listens for 'expand' and 'collapse' events.
private static class OnFocusChangeListenerWrapper implements View.OnFocusChangeListener {
private final Collection<SpinnerListener> spinnerListeners;
private final View.OnFocusChangeListener originalFocusListener;
private OnFocusChangeListenerWrapper(View.OnFocusChangeListener originalFocusListener, Collection<SpinnerListener> spinnerListeners) {
this.spinnerListeners = spinnerListeners;
this.originalFocusListener = originalFocusListener;
}
@Override
public void onFocusChange(View view, boolean hasFocus) {
if (originalFocusListener != null) {
originalFocusListener.onFocusChange(view, hasFocus); // Preserve the pre-existing focus listener (if any).
}
callSpinnerListeners(hasFocus);
}
private void callSpinnerListeners(boolean hasFocus) {
for (SpinnerListener spinnerListener : spinnerListeners) {
if (spinnerListener != null) {
callSpinnerListener(hasFocus, spinnerListener);
}
}
}
private void callSpinnerListener(boolean hasFocus, SpinnerListener spinnerListener) {
if (hasFocus) {
spinnerListener.onSpinnerExpanded();
}
else {
spinnerListener.onSpinnerCollapsed();
}
}
}
}
Ensuite, lorsque j’utilise un spinner dans mon activité ou mon fragment, tout ce que je devais faire était de régler l’adaptateur spinner sur l’adaptateur personnalisé ci-dessus:
private ListeningArrayAdapter<CharSequence> adapter;
private Spinner buildSpinner() {
final CharSequence[] items = {"One", "Two", "Three"};
final Spinner spinner = (Spinner)getActivity().getLayoutInflater().inflate(R.layout.item_spinner, null);
adapter = new ListeningArrayAdapter<CharSequence>(getActivity(), R.layout.item_spinner_item, items);
adapter.setDropDownViewResource(Android.R.layout.simple_spinner_dropdown_item);
adapter.addSpinnerListener(new TestSpinnerListener(getActivity())); // Add your own spinner listener implementation here.
spinner.setAdapter(adapter);
return spinner;
}
Je sais que c'est un peu un bidouillage et un peu fragile, mais cela a fonctionné pour moi. Il serait bien mieux que la classe Spinner intègre toutes ces fonctionnalités et vous permette de définir un écouteur expand-collapse. Pour le moment, je vais devoir faire avec ce hack.