¿Cómo mantener onItemSelected activado en un Spinner recién instanciado?

He pensado en algunas formas menos que elegantes para resolver esto, pero sé que debo estar perdiendo algo.

Mi onItemSelected desactiva inmediatamente sin ninguna interacción con el usuario, y este es un comportamiento no deseado. Deseo que la IU espere hasta que el usuario seleccione algo antes de que haga algo.

Incluso intenté configurar el oyente en onResume() , esperando que eso ayudara, pero no es así.

¿Cómo puedo evitar que esto se dispare antes de que el usuario pueda tocar el control?

 public class CMSHome extends Activity { private Spinner spinner; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Heres my spinner /////////////////////////////////////////// spinner = (Spinner) findViewById(R.id.spinner); ArrayAdapter adapter = ArrayAdapter.createFromResource( this, R.array.pm_list, android.R.layout.simple_spinner_item); adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); spinner.setAdapter(adapter); }; public void onResume() { super.onResume(); spinner.setOnItemSelectedListener(new MyOnItemSelectedListener()); } public class MyOnItemSelectedListener implements OnItemSelectedListener { public void onItemSelected(AdapterView parent, View view, int pos, long id) { Intent i = new Intent(CMSHome.this, ListProjects.class); i.putExtra("bEmpID", parent.getItemAtPosition(pos).toString()); startActivity(i); Toast.makeText(parent.getContext(), "The pm is " + parent.getItemAtPosition(pos).toString(), Toast.LENGTH_LONG).show(); } public void onNothingSelected(AdapterView parent) { // Do nothing. } } } 

Hubiera esperado que tu solución funcionara, aunque el evento de selección no se activará si configuras el adaptador antes de configurar el oyente.

Dicho esto, un simple indicador booleano le permitiría detectar el primer evento de selección deshonesto e ignorarlo.

El uso de Runnables es completamente incorrecto.

Use setSelection(position, false); en la selección inicial antes de setOnItemSelectedListener(listener)

De esta forma, configura su selección sin animación, lo que hace que se llame al elemento seleccionado oyente seleccionado. Pero el oyente es nulo, por lo que no se ejecuta nada. Entonces tu oyente está asignado.

Entonces sigue esta secuencia exacta:

 Spinner s = (Spinner)Util.findViewById(view, R.id.sound, R.id.spinner); s.setAdapter(adapter); s.setSelection(position, false); s.setOnItemSelectedListener(listener); 

Refiriéndose a la respuesta de Dan Dyer, intente registrar OnSelectListener en un método de post(Runnable) :

 spinner.post(new Runnable() { public void run() { spinner.setOnItemSelectedListener(listener); } }); 

Al hacer eso para mí, finalmente se produjo el comportamiento deseado.

En este caso, también significa que el oyente solo dispara sobre un elemento modificado.

Creé un pequeño método de utilidad para cambiar la selección de Spinner sin notificar al usuario:

 private void setSpinnerSelectionWithoutCallingListener(final Spinner spinner, final int selection) { final OnItemSelectedListener l = spinner.getOnItemSelectedListener(); spinner.setOnItemSelectedListener(null); spinner.post(new Runnable() { @Override public void run() { spinner.setSelection(selection); spinner.post(new Runnable() { @Override public void run() { spinner.setOnItemSelectedListener(l); } }); } }); } 

Deshabilita el oyente, cambia la selección y vuelve a habilitar al oyente después de eso.

El truco es que las llamadas son asíncronas al subproceso de interfaz de usuario, por lo que debe hacerlo en las publicaciones consecutivas del controlador.

Desafortunadamente, parece que las dos soluciones más comúnmente sugeridas para este problema, como contar las repeticiones de callback y publicar Runnable para establecer la callback en un momento posterior, pueden fallar cuando, por ejemplo, se habilitan las opciones de accesibilidad. Aquí hay una clase de ayuda que soluciona estos problemas. Más explicación está en el bloque de comentarios.

 import android.view.View; import android.widget.AdapterView; import android.widget.AdapterView.OnItemSelectedListener; import android.widget.Spinner; import android.widget.SpinnerAdapter; /** * Spinner Helper class that works around some common issues * with the stock Android Spinner * * A Spinner will normally call it's OnItemSelectedListener * when you use setSelection(...) in your initialization code. * This is usually unwanted behavior, and a common work-around * is to use spinner.post(...) with a Runnable to assign the * OnItemSelectedListener after layout. * * If you do not call setSelection(...) manually, the callback * may be called with the first item in the adapter you have * set. The common work-around for that is to count callbacks. * * While these workarounds usually *seem* to work, the callback * may still be called repeatedly for other reasons while the * selection hasn't actually changed. This will happen for * example, if the user has accessibility options enabled - * which is more common than you might think as several apps * use this for different purposes, like detecting which * notifications are active. * * Ideally, your OnItemSelectedListener callback should be * coded defensively so that no problem would occur even * if the callback was called repeatedly with the same values * without any user interaction, so no workarounds are needed. * * This class does that for you. It keeps track of the values * you have set with the setSelection(...) methods, and * proxies the OnItemSelectedListener callback so your callback * only gets called if the selected item's position differs * from the one you have set by code, or the first item if you * did not set it. * * This also means that if the user actually clicks the item * that was previously selected by code (or the first item * if you didn't set a selection by code), the callback will * not fire. * * To implement, replace current occurrences of: * * Spinner spinner = * (Spinner)findViewById(R.id.xxx); * * with: * * SpinnerHelper spinner = * new SpinnerHelper(findViewById(R.id.xxx)) * * SpinnerHelper proxies the (my) most used calls to Spinner * but not all of them. Should a method not be available, use: * * spinner.getSpinner().someMethod(...) * * Or just add the proxy method yourself :) * * (Quickly) Tested on devices from 2.3.6 through 4.2.2 * * @author Jorrit "Chainfire" Jongma * @license WTFPL (do whatever you want with this, nobody cares) */ public class SpinnerHelper implements OnItemSelectedListener { private final Spinner spinner; private int lastPosition = -1; private OnItemSelectedListener proxiedItemSelectedListener = null; public SpinnerHelper(Object spinner) { this.spinner = (spinner != null) ? (Spinner)spinner : null; } public Spinner getSpinner() { return spinner; } public void setSelection(int position) { lastPosition = Math.max(-1, position); spinner.setSelection(position); } public void setSelection(int position, boolean animate) { lastPosition = Math.max(-1, position); spinner.setSelection(position, animate); } public void setOnItemSelectedListener(OnItemSelectedListener listener) { proxiedItemSelectedListener = listener; spinner.setOnItemSelectedListener(listener == null ? null : this); } public void onItemSelected(AdapterView parent, View view, int position, long id) { if (position != lastPosition) { lastPosition = position; if (proxiedItemSelectedListener != null) { proxiedItemSelectedListener.onItemSelected( parent, view, position, id ); } } } public void onNothingSelected(AdapterView parent) { if (-1 != lastPosition) { lastPosition = -1; if (proxiedItemSelectedListener != null) { proxiedItemSelectedListener.onNothingSelected( parent ); } } } public void setAdapter(SpinnerAdapter adapter) { if (adapter.getCount() > 0) { lastPosition = 0; } spinner.setAdapter(adapter); } public SpinnerAdapter getAdapter() { return spinner.getAdapter(); } public int getCount() { return spinner.getCount(); } public Object getItemAtPosition(int position) { return spinner.getItemAtPosition(position); } public long getItemIdAtPosition(int position) { return spinner.getItemIdAtPosition(position); } public Object getSelectedItem() { return spinner.getSelectedItem(); } public long getSelectedItemId() { return spinner.getSelectedItemId(); } public int getSelectedItemPosition() { return spinner.getSelectedItemPosition(); } public void setEnabled(boolean enabled) { spinner.setEnabled(enabled); } public boolean isEnabled() { return spinner.isEnabled(); } } 

He tenido MUCHOS problemas con el disparo del girador cuando no quería, y todas las respuestas aquí son poco confiables. Ellos trabajan, pero solo algunas veces. Eventualmente se encontrará con escenarios donde fallarán e introducirán errores en su código.

Lo que funcionó para mí fue almacenar el último índice seleccionado en una variable y evaluarlo en el oyente. Si es lo mismo que el nuevo índice seleccionado, no haga nada y vuelva, de lo contrario continúe con el oyente. Hacer esto:

 //Declare a int member variable and initialize to 0 (at the top of your class) private int mLastSpinnerPosition = 0; //then evaluate it in your listener @Override public void onItemSelected(AdapterView adapterView, View view, int i, long l) { if(mLastSpinnerPosition == i){ return; //do nothing } mLastSpinnerPosition = i; //do the rest of your code now } 

Confíe en mí cuando digo esto, esta es de lejos la solución más confiable. Un truco, pero funciona!

Estaba en una situación similar, y tengo una solución simple que funciona para mí.

Parece que los métodos setSelection(int position) y setSelected(int position, boolean animate) tienen una implementación interna diferente.

Cuando utiliza el segundo método setSelected(int position, boolean animate) con indicador animado falso, obtiene la selección sin onItemSelected oyente onItemSelected .

Para dar pistas sobre el uso del onTouchListener para distinguir entre las llamadas automáticas al setOnItemSelectedListener (que son parte de la inicialización de la actividad, etc.) y las llamadas desencadenadas por la interacción real del usuario, hice lo siguiente después de probar algunas otras sugerencias aquí y encontró que funcionó bien con la menor cantidad de líneas de código.

Simplemente configure un campo Booleano para su Actividad / Fragmento como:

 private Boolean spinnerTouched = false; 

Luego, justo antes de establecer el setOnItemSelectedListener de su spinner, establezca un onTouchListener:

  spinner.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { System.out.println("Real touch felt."); spinnerTouched = true; return false; } }); spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { ... if (spinnerTouched){ //Do the stuff you only want triggered by real user interaction. } spinnerTouched = false; 
 spinner.setSelection(Adapter.NO_SELECTION, false); 

Después de sacarme el pelo por un largo tiempo, ahora he creado mi propia clase de Spinner. Le agregué un método que desconecta y conecta apropiadamente al oyente.

 public class SaneSpinner extends Spinner { public SaneSpinner(Context context) { super(context); } public SaneSpinner(Context context, AttributeSet attrs) { super(context, attrs); } public SaneSpinner(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); } // set the ceaseFireOnItemClickEvent argument to true to avoid firing an event public void setSelection(int position, boolean animate, boolean ceaseFireOnItemClickEvent) { OnItemSelectedListener l = getOnItemSelectedListener(); if (ceaseFireOnItemClickEvent) { setOnItemSelectedListener(null); } super.setSelection(position, animate); if (ceaseFireOnItemClickEvent) { setOnItemSelectedListener(l); } } } 

Úselo en su XML así:

  

Todo lo que tiene que hacer es recuperar la instancia de SaneSpinner después del inflado y seleccionar el conjunto de llamadas de esta manera:

 mMySaneSpinner.setSelection(1, true, true); 

Con esto, no se dispara ningún evento y la interacción del usuario no se interrumpe. Esto redujo mucho la complejidad de mi código. Esto debería incluirse en stock de Android ya que realmente es un PITA.

No hay eventos no deseados desde la fase de diseño si pospone la adición del oyente hasta que finalice el diseño:

 spinner.getViewTreeObserver().addOnGlobalLayoutListener( new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { // Ensure you call it only once works for JELLY_BEAN and later spinner.getViewTreeObserver().removeOnGlobalLayoutListener(this); // add the listener spinner.setOnItemSelectedListener(new OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View view, int pos, long id) { // check if pos has changed // then do your work } @Override public void onNothingSelected(AdapterView arg0) { } }); } }); 

Tengo una respuesta muy simple, 100% seguro de que funciona:

 boolean Touched=false; // this aa global variable public void changetouchvalue() { Touched=true; } // this code is written just before onItemSelectedListener spinner.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { System.out.println("Real touch felt."); changetouchvalue(); return false; } }); //inside your spinner.SetonItemSelectedListener , you have a function named OnItemSelected iside that function write the following code if(Touched) { // the code u want to do in touch event } 

He encontrado una solución mucho más elegante para esto. Implica contar cuántas veces se ha invocado ArrayAdapter (en su caso “adaptador”). Digamos que tienes 1 spinner y llamas:

 int iCountAdapterCalls = 0; ArrayAdapter adapter = ArrayAdapter.createFromResource( this, R.array.pm_list, android.R.layout.simple_spinner_item); adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); spinner.setAdapter(adapter); 

Declare un int contador después de que el método onCreate y luego el método onItemSelected () pongan una condición “if” para verificar cuántas veces se ha llamado al atapter. En su caso, lo llamaron solo una vez, así que:

 if(iCountAdapterCalls < 1) { iCountAdapterCalls++; //This section executes in onCreate, during the initialization } else { //This section corresponds to user clicks, after the initialization } 

Mi pequeña contribución es una variación de algunas de las anteriores que me ha parecido un par de veces.

Declare una variable entera como un valor predeterminado (o el último valor utilizado guardado en preferencias). Use spinner.setSelection (myDefault) para establecer ese valor antes de que el oyente esté registrado. En la verificación onItemSelected, compruebe si el nuevo valor de giro equivale al valor asignado antes de ejecutar cualquier otro código.

Esto tiene la ventaja adicional de no ejecutar el código si el usuario vuelve a seleccionar el mismo valor.

Después de haber tenido el mismo problema, llegué a esta solución usando tags. La idea detrás de esto es simple: cada vez que se cambie programáticamente la ruleta, asegúrese de que la etiqueta refleje la posición seleccionada. En el oyente, entonces verifica si la posición seleccionada es igual a la etiqueta. Si lo hace, la selección del selector se cambió programáticamente.

Debajo está mi nueva clase de “spinner proxy”:

 package com.samplepackage; import com.samplepackage.R; import android.widget.Spinner; public class SpinnerFixed { private Spinner mSpinner; public SpinnerFixed(View spinner) { mSpinner = (Spinner)spinner; mSpinner.setTag(R.id.spinner_pos, -2); } public boolean isUiTriggered() { int tag = ((Integer)mSpinner.getTag(R.id.spinner_pos)).intValue(); int pos = mSpinner.getSelectedItemPosition(); mSpinner.setTag(R.id.spinner_pos, pos); return (tag != -2 && tag != pos); } public void setSelection(int position) { mSpinner.setTag(R.id.spinner_pos, position); mSpinner.setSelection(position); } public void setSelection(int position, boolean animate) { mSpinner.setTag(R.id.spinner_pos, position); mSpinner.setSelection(position, animate); } // If you need to proxy more methods, use "Generate Delegate Methods" // from the context menu in Eclipse. } 

También necesitará un archivo XML con la configuración de la etiqueta en su directorio de Values . Llamé a mi archivo spinner_tag.xml , pero eso depende de ti. Se parece a esto:

    

Ahora reemplace

 Spinner myspinner; ... myspinner = (Spinner)findViewById(R.id.myspinner); 

en tu código con

 SpinnerFixed myspinner; ... myspinner = new SpinnerFixed(findViewById(R.id.myspinner)); 

Y haz que tu controlador se vea así:

 myspinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View view, int position, long id) { if (myspinner.isUiTriggered()) { // Code you want to execute only on UI selects of the spinner } } @Override public void onNothingSelected(AdapterView parent) { } }); 

La función isUiTriggered() devolverá verdadero si y solo si el spinner ha sido cambiado por el usuario. Tenga en cuenta que esta función tiene un efecto secundario: establecerá la etiqueta, por lo que una segunda llamada en la misma llamada siempre devolverá false .

Este contenedor también manejará el problema con el oyente al que se llama durante la creación del diseño.

Diviértete, Jens.

Como nada funcionó para mí, y tengo más de 1 spinner en mi opinión (y en mi humilde opinión contener un mapa bool es excesivo) uso la etiqueta para contar los clics:

 spinner.setTag(0); spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View view, int position, long id) { Integer selections = (Integer) parent.getTag(); if (selections > 0) { // real selection } parent.setTag(++selections); // (or even just '1') } @Override public void onNothingSelected(AdapterView parent) { } }); 

Esto sucederá si está seleccionando en el código como;

  mSpinner.setSelection(0); 

En lugar de usar el enunciado anterior

  mSpinner.setSelection(0,false);//just simply do not animate it. 

Editar: Este método no funciona para mi interfaz de usuario Mi versión Mi.

Muchas respuestas, esta es mía.

AppCompatSpinner y agrego un método pgmSetSelection(int pos) que permite la configuración de selección programática sin activar una callback de selección. He codificado esto con RxJava para que los eventos de selección se entreguen a través de un Observable .

 package com.controlj.view; import android.content.Context; import android.util.AttributeSet; import android.view.View; import android.widget.AdapterView; import io.reactivex.Observable; /** * Created by clyde on 22/11/17. */ public class FilteredSpinner extends android.support.v7.widget.AppCompatSpinner { private int lastSelection = INVALID_POSITION; public void pgmSetSelection(int i) { lastSelection = i; setSelection(i); } /** * Observe item selections within this spinner. Events will not be delivered if they were triggered * by a call to setSelection(). Selection of nothing will return an event equal to INVALID_POSITION * * @return an Observable delivering selection events */ public Observable observeSelections() { return Observable.create(emitter -> { setOnItemSelectedListener(new OnItemSelectedListener() { @Override public void onItemSelected(AdapterView adapterView, View view, int i, long l) { if(i != lastSelection) { lastSelection = i; emitter.onNext(i); } } @Override public void onNothingSelected(AdapterView adapterView) { onItemSelected(adapterView, null, INVALID_POSITION, 0); } }); }); } public FilteredSpinner(Context context) { super(context); } public FilteredSpinner(Context context, int mode) { super(context, mode); } public FilteredSpinner(Context context, AttributeSet attrs) { super(context, attrs); } public FilteredSpinner(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); } public FilteredSpinner(Context context, AttributeSet attrs, int defStyleAttr, int mode) { super(context, attrs, defStyleAttr, mode); } } 

Un ejemplo de su uso, llamado onCreateView() en un Fragment por ejemplo:

  mySpinner = view.findViewById(R.id.history); mySpinner.observeSelections() .subscribe(this::setSelection); 

donde setSelection() es un método en la vista setSelection() que se parece a esto, y que se llama tanto de eventos de selección de usuario a través de Observable como de otros Observable mediante progtwigción, por lo que la lógica para manejar selecciones es común para ambos métodos de selección.

 private void setSelection(int position) { if(adapter.isEmpty()) position = INVALID_POSITION; else if(position >= adapter.getCount()) position = adapter.getCount() - 1; MyData result = null; mySpinner.pgmSetSelection(position); if(position != INVALID_POSITION) { result = adapter.getItem(position); } display(result); // show the selected item somewhere } 

Yo trataría de llamar

 spinner.setOnItemSelectedListener(new MyOnItemSelectedListener()); 

después de llamar a setAdapter (). Pruebe también llamar antes del adaptador.

Siempre tiene la solución para ir con la creación de subclases, donde puede ajustar una bandera booleana a su método overriden setAdapter para omitir el evento.

La solución con una bandera booleana o un contador no me ayudó, porque durante el cambio de orientación onItemSelected () las llamadas “sobrevolaron” la bandera o el contador.

Subclassed android.widget.Spinner e hice pequeñas adiciones. Las partes relevantes están debajo. Esta solución funcionó para mí.

 private void setHandleOnItemSelected() { final StackTraceElement [] elements = Thread.currentThread().getStackTrace(); for (int index = 1; index < elements.length; index++) { handleOnItemSelected = elements[index].toString().indexOf("PerformClick") != -1; //$NON-NLS-1$ if (handleOnItemSelected) { break; } } } @Override public void setSelection(int position, boolean animate) { super.setSelection(position, animate); setHandleOnItemSelected(); } @Override public void setSelection(int position) { super.setSelection(position); setHandleOnItemSelected(); } public boolean shouldHandleOnItemSelected() { return handleOnItemSelected; } 

Esta tampoco es una solución elegante. De hecho, es más bien Rube-Goldberg, pero parece funcionar. Me aseguro de que el spinner se haya utilizado al menos una vez extendiendo el adaptador de matriz y anulando su getDropDownView. En el nuevo método getDropDownView, tengo un indicador booleano configurado para mostrar que el menú desplegable se ha utilizado al menos una vez. Ignoro las llamadas al oyente hasta que se establezca la bandera.

MainActivity.onCreate ():

 ActionBar ab = getActionBar(); ab.setDisplayShowTitleEnabled(false); ab.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST); ab.setListNavigationCallbacks(null, null); ArrayList abList = new ArrayList(); abList.add("line 1"); ... ArAd abAdapt = new ArAd (this , android.R.layout.simple_list_item_1 , android.R.id.text1, abList); ab.setListNavigationCallbacks(abAdapt, MainActivity.this); 

adaptador de matriz invalidado:

 private static boolean viewed = false; private class ArAd extends ArrayAdapter { private ArAd(Activity a , int layoutId, int resId, ArrayList list) { super(a, layoutId, resId, list); viewed = false; } @Override public View getDropDownView(int position, View convertView, ViewGroup parent) { viewed = true; return super.getDropDownView(position, convertView, parent); } } 

oyente modificado:

 @Override public boolean onNavigationItemSelected( int itemPosition, long itemId) { if (viewed) { ... } return false; } 

si necesita recrear la actividad sobre la marcha, por ejemplo: cambiar los temas, una simple bandera / contador no funcionará

use la función UserInteraction () para detectar la actividad del usuario,

referencia: https://stackoverflow.com/a/25070696/4772917

Lo he hecho de la manera más simple:

 private AdapterView.OnItemSelectedListener listener; private Spinner spinner; 

onCreate ();

 spinner = (Spinner) findViewById(R.id.spinner); listener = new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView adapterView, View view, int position, long l) { Log.i("H - Spinner selected position", position); } @Override public void onNothingSelected(AdapterView adapterView) { } }; spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView adapterView, View view, int i, long l) { spinner.setOnItemSelectedListener(listener); } @Override public void onNothingSelected(AdapterView adapterView) { } }); 

Hecho

 if () { spinner.setSelection(0);// No reaction to create spinner !!! } else { spinner.setSelection(intPosition); } spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View view, int position, long id) { if (position > 0) { // real selection } } @Override public void onNothingSelected(AdapterView parent) { } }); 

Esa es mi solución final y fácil de usar:

 public class ManualSelectedSpinner extends Spinner { //get a reference for the internal listener private OnItemSelectedListener mListener; public ManualSelectedSpinner(Context context) { super(context); } public ManualSelectedSpinner(Context context, AttributeSet attrs) { super(context, attrs); } public ManualSelectedSpinner(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); } @Override public void setOnItemSelectedListener(@Nullable OnItemSelectedListener listener) { mListener = listener; super.setOnItemSelectedListener(listener); } public void setSelectionWithoutInformListener(int position){ super.setOnItemSelectedListener(null); super.setSelection(position); super.setOnItemSelectedListener(mListener); } public void setSelectionWithoutInformListener(int position, boolean animate){ super.setOnItemSelectedListener(null); super.setSelection(position, animate); super.setOnItemSelectedListener(mListener); } } 

Utilice la configuración predeterminada setSelection(...) para el comportamiento predeterminado o use setSelectionWithoutInformListener(...) para seleccionar un elemento en la ruleta sin activar la callback OnItemSelectedListener.

Necesito usar mSpinner en ViewHolder, por lo que la bandera mOldPosition se establece en la clase interna anónima.

 mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { int mOldPosition = mSpinner.getSelectedItemPosition(); @Override public void onItemSelected(AdapterView parent, View view, int position, long l) { if (mOldPosition != position) { mOldPosition = position; //Do something } } @Override public void onNothingSelected(AdapterView adapterView) { //Do something } }); 

Guardaría el índice inicial durante la creación del objeto onClickListener.

  int thisInitialIndex = 0;//change as needed myspinner.setSelection(thisInitialIndex); myspinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { int initIndex = thisInitialIndex; @Override public void onItemSelected(AdapterView parent, View view, int position, long id) { if (id != initIndex) { //if selectedIndex is the same as initial value // your real onselecteditemchange event } } @Override public void onNothingSelected(AdapterView parent) { } }); 

Mi solución se usa en onTouchListener pero no restringe su uso. Crea un contenedor para onTouchListener si es necesario donde se configura onItemSelectedListener .

 public class Spinner extends android.widget.Spinner { /* ...constructors... */ private OnTouchListener onTouchListener; private OnItemSelectedListener onItemSelectedListener; @Override public void setOnItemSelectedListener(OnItemSelectedListener listener) { onItemSelectedListener = listener; super.setOnTouchListener(wrapTouchListener(onTouchListener, onItemSelectedListener)); } @Override public void setOnTouchListener(OnTouchListener listener) { onTouchListener = listener; super.setOnTouchListener(wrapTouchListener(onTouchListener, onItemSelectedListener)); } private OnTouchListener wrapTouchListener(final OnTouchListener onTouchListener, final OnItemSelectedListener onItemSelectedListener) { return onItemSelectedListener != null ? new OnTouchListener() { @Override public boolean onTouch(View view, MotionEvent motionEvent) { Spinner.super.setOnItemSelectedListener(onItemSelectedListener); return onTouchListener != null && onTouchListener.onTouch(view, motionEvent); } } : onTouchListener; } } 

Es posible que esté respondiendo demasiado tarde sobre la publicación, sin embargo, logré lograr esto usando la biblioteca de enlace de datos de Android, enlace de datos de Android . I created a custom binding to make sure listener is not called until selected item is changed so even if user is selecting same position over and over again event is not fired.

Layout xml file

       

app:position is where you are passing position to be selected.

Custom binding

  @BindingAdapter(value={ "position"}, requireAll=false) public static void setSpinnerAdapter(Spinner spinner, int selected) { final int [] selectedposition= new int[1]; selectedposition[0]=selected; // custom adapter or you can set default adapter CustomSpinnerAdapter customSpinnerAdapter = new CustomSpinnerAdapter(spinner.getContext(), ); spinner.setAdapter(customSpinnerAdapter); spinner.setSelection(selected,false); spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View view, int position, long id) { String item = parent.getItemAtPosition(position).toString(); if( position!=selectedposition[0]) { selectedposition[0]=position; // do your stuff here } } @Override public void onNothingSelected(AdapterView parent) { } }); } 

You can read more about custom data binding here Android Custom Setter

NOTA

  1. Don’t forget to enable databinding in your Gradle file

      android { .... dataBinding { enabled = true } } 
  2. Include your layout files in tags

 mYear.setOnItemSelectedListener(new OnItemSelectedListener() { @Override public void onItemSelected(AdapterView parent, View arg1, int item, long arg3) { if (mYearSpinnerAdapter.isEnabled(item)) { } } @Override public void onNothingSelected(AdapterView parent) { } });