android - item - Spinner: recibe estado o recibe una notificación cuando abre

spinner android developer

Question

¿Es posible saber si un Spinner está abierto o cerrado? Incluso sería mejor si hubiera algún tipo de OnOpenListener para Spinners.

He intentado usar un OnItemSelectedListener como este:

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

    });

Puedo saber que la ventana se cerrará si se selecciona algo (en executeSomething ()). Pero no me notifican si hago clic fuera del cuadro de diálogo, que también cierra el panel giratorio

Answer 1

Creo que la mejor manera de encontrar cuándo se abrió y cerró es de esta manera:

1. Si estaba cerrado, y ahora llama a "getDropDownView" en el adaptador, se puede suponer que se abrió.

2. Si se llama a "onItemSelected" o "onNothingSelected", ahora se cerró.

EDITAR: aquí hay un código de muestra

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

Answer 2

Hola amigos, estoy luchando con este tema en los últimos dos días y finalmente obtuve una solución que hizo mi trabajo. Lo intenté y funcionó perfectamente. Gracias

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

            });

Answer 3

No hay una función integrada, pero es bastante fácil de hacer con OnTouchListener y 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();
}

Y luego asigne los oyentes apropiados:

    OnOpenListener onOpenListener = new OnOpenListener(mySpinner) {

        @Override
        public void onOpen() {
            // spinner was opened
        }

        @Override
        public void onClose() {
            // spinner was closed
        }
    };

Answer 4

No pude encontrar una manera de obtener este comportamiento con el girador, así que lo único que funcionó para mí fue usar el adaptador giratorio (personalizado) en su lugar:

public interface SpinnerListener {

    void onSpinnerExpanded();   

    void onSpinnerCollapsed();
}

Luego se puede escribir un adaptador personalizado que solo agarra la vista "girada expandida" y le agrega un oyente para escuchar los eventos "expandir" y "colapsar". El adaptador personalizado que utilicé es:

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

Luego, cuando uso un spinner en mi actividad o fragmento, todo lo que tenía que hacer era configurar el adaptador giratorio al adaptador personalizado anterior:

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

Sé que esto es un poco complicado y un poco frágil, pero funcionó para mí. Sería mucho mejor si la clase Spinner tuviera toda esta funcionalidad incorporada y le permitiera configurar un oyente de expansión y colapso. Por el momento, tendré que ver con este truco.

Answer 5

Otra opción para ver esos eventos es extender la clase Spinner y usar uno de sus métodos ( performClick() que activará su diálogo / ventana emergente) seguido de la supervisión del foco de la ventana que contiene este Spinner personalizado. Esto debería proporcionarle el evento cerrado deseado para todas las posibilidades de acabado posibles (para el diálogo o el modo desplegable).

La clase personalizada de Spinner :

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

    /**
    * 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;
    }

    public void onWindowFocusChanged (boolean hasFocus) {
        if (hasBeenOpened() && hasFocus) {
            performClosedEvent();
        }
    }

}

Answer 6

basado en la maravillosa solución de @Luksprog, solo quiero agregar un pequeño cambio que será muy útil en caso de que alguien esté usando CustomSpinner dentro de un fragmento. en lugar de utilizar la función Activity.onWindowFocusChanged , reemplazamos la función View.onWindowFocusChanged . por lo tanto, toda la clase CustomSpinner se convierte

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