Comment garder onItemSelected de tirer sur un nouvellement instancié Spinner?

Je me serais attendu à votre solution de travail, j'ai bien l'événement de sélection ne serait pas de feu si vous définissez l'adaptateur avant l'installation de l'auditeur.

Cela étant dit, un simple indicateur booléen vous permettra de détecter les voyous de la première sélection de l'événement et de l'ignorer.

Se référant à la réponse de Dan Dyer, essayez d'enregistrer le OnSelectListener dans un post(Runnable) méthode:

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

Par le fait que pour moi, le comportement souhaité finalement eu lieu.

Dans ce cas, il signifie également que l'auditeur ne se déclenche sur un élément modifié.

Malheureusement, il semble que les deux plus couramment proposé des solutions à ce problème, à savoir le comptage de rappel occurrences et l'affichage d'un Exécutable pour définir la fonction de rappel à une date ultérieure peut à la fois d'échouer lorsque, par exemple, les options d'accessibilité sont activés. Voici une classe d'assistance qui fonctionne autour de ces questions. En outre explenation est dans le bloc de commentaire.

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

J'ai été dans une situation similaire, et j'ai une solution simple de travailler pour moi.

Il semble que les méthodes de setSelection(int position) et setSelected(int position, boolean animate) ont différentes internes de mise en œuvre.

Lorsque vous utilisez la deuxième méthode setSelected(int position, boolean animate) avec de faux animer drapeau, vous obtiendrez la sélection sans cuisson onItemSelected auditeur.

spinner.setSelection(Adapter.NO_SELECTION, false);

Pas d'événements indésirables à partir de la mise en page de phase si vous vous en remettez l'ajout de l'écouteur jusqu'à la mise en page est terminée:

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

J'ai eu une réponse très simple , sûr à 100% ça marche:

boolean Touched=false; //this a a 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
}

Ma petite contribution, est une variation sur certains de ce qui précède que l'a faite pour moi un peu de temps.

Déclarer une variable de type entier comme valeur par défaut (ou la dernière valeur utilisée enregistrés dans les préférences).
Utilisation spinner.setSelection(myDefault) pour définir la valeur avant de l'auditeur est enregistré.
Dans le onItemSelected vérifier si le nouveau spinner valeur est égale à la valeur attribuée avant l'exécution de tout autre code.

Cela a l'avantage de ne pas exécuter du code si l'utilisateur sélectionne la même valeur à nouveau.

Depuis rien n'a fonctionné pour moi, et j'ai plus de 1 spinner, à mon avis (et à mon humble avis, la tenue d'un bool carte est inutile) j'utilise la balise de compter les 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) {
}
});

Je voudrais essayer d'appeler

spinner.setOnItemSelectedListener(new MyOnItemSelectedListener());

après l'appel de setAdapter(). Essayez également de téléphoner avant de l'adaptateur.

Vous avez toujours la solution d'aller avec sous-classement, où vous pouvez l'envelopper d'un indicateur booléen à votre remplacé setAdapter méthode d'ignorer l'événement.

Ce n'est pas une solution élégante soit. En fait, c'est plutôt Rube-Goldberg, mais il semble fonctionner. I assurez-vous que le compteur a été utilisé au moins une fois par l'extension de l'adaptateur tableau et surchargeant ses getDropDownView. Dans la nouvelle getDropDownView méthode que j'ai un indicateur booléen qui est configuré pour afficher le menu déroulant a été utilisé au moins une fois. - Je ignorer les appels à l'auditeur jusqu'à ce que le drapeau est réglé.

MainActivity.onCreate():

ActionBar ab = getActionBar();
ab.setDisplayShowTitleEnabled(false);
ab.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST);
ab.setListNavigationCallbacks(null, null);
ArrayList<String> abList = new ArrayList<String>();
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);

remplacé adaptateur tableau:

private static boolean viewed = false;
private class ArAd extends ArrayAdapter<String> {
private ArAd(Activity a
, int layoutId, int resId, ArrayList<String> 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);
}
}

modifié auditeur:

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

J'ai fait avec la façon la plus 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) {
}
});

Fait

C'est ma dernière et facile à utiliser la solution :

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

Utiliser la valeur par défaut setSelection(...) pour le comportement par défaut ou utiliser setSelectionWithoutInformListener(...) pour la sélection d'un élément dans la casserole sans déclencher OnItemSelectedListener de rappel.

Je voudrais stocker l'index initial lors de la création de la onClickListener objet.

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

J'ai peut-être répondu trop tard sur le post, mais j'ai réussi à atteindre cet objectif en utilisant Android de liaison de Données de la bibliothèque Android Databinding . J'ai créé une liaison personnalisée à assurez-vous que l'auditeur n'est pas appelé jusqu'à ce que l'élément sélectionné est modifié de sorte que même si l'utilisateur choisit même position plus et plus encore, l'événement n'est pas déclenché.

Mise en page fichier xml

    <layout>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="@dimen/activity_vertical_margin"
xmlns:app="http://schemas.android.com/apk/res-auto">
<Spinner
android:id="@+id/spinner"
android:layout_width="150dp"
android:layout_height="wrap_content"
android:spinnerMode="dropdown"
android:layout_below="@id/member_img"
android:layout_marginTop="@dimen/activity_vertical_margin"
android:background="@drawable/member_btn"
android:padding="@dimen/activity_horizontal_margin"
android:layout_marginStart="@dimen/activity_horizontal_margin"
android:textColor="@color/colorAccent"
app:position="@{0}"
/>
</RelativeLayout>
</layout>

app:position est l'endroit où vous êtes de passage à la position d'être sélectionné.

Liaison personnalisée

  @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(), <arraylist you want to add to spinner>);
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) {
}
});
}

Vous pouvez en lire plus sur la coutume de la liaison de données ici Android Personnalisé Setter

NOTE

1. N'oubliez pas d'activer la liaison de données dans votre Gradle fichier

      android {
   ....
   dataBinding {
   enabled = true
   }
   }

2. Inclure vos fichiers de mise en <layout> tags

Il n'est pas particulièrement élégant solution, mais je trouve qu'il fonctionne de manière fiable. Il suffit de définir les auditeurs sur un retard de filetage à partir de l'intérieur de onResume. Vous êtes ensuite libre de faire tout d'initialisation que vous aimez, et l'INTERFACE utilisateur pourra alors effectuer toutes les modifications de mise en page, puis définissez les auditeurs.

Thread t = new Thread(){
public void run() {
try{                
Thread.sleep(1000);
getActivity().runOnUiThread(new Runnable() {                        
@Override
public void run() {
setSpinnerListeners();
}
});
}
catch(Exception e){
e.printStackTrace();
}
};
};
t.start();

Pas un préfet de la solution, mais si votre heureux avec le départ de la chaîne comme une place de titulaire, vous pouvez ajouter un lieu porteur de printemps de la valeur ("Day_of_Work_Out")

  @Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
String name = (String) parent.getItemAtPosition(position);
if (name.equals("Day_of_Work_Out")) {
}else {
workOutD = name;
Intent intent = new Intent();
workOutNam = workOutName.getText().toString();
if (workOutNam == null) {
startActivity(intent);
Log.i("NewWorkOutActivity","Name is null");
}else {
Log.i("NewWorkOutActivity","Name Not null");
Toast.makeText(NewWorkOutActivity.this, "Please Select a Day", Toast.LENGTH_LONG).show();
}
}
}