OnItemSelected को नए तात्कालिक स्पिनर पर फायरिंग से कैसे दूर रखें?

Question

मैंने इसे हल करने के लिए सुरुचिपूर्ण तरीकों से कुछ कम सोचा है, लेकिन मुझे पता है कि मुझे कुछ याद आ रहा है।

onItemSelectedउपयोगकर्ता के साथ किसी भी बातचीत के बिना मेरी आग तुरंत बंद हो जाती है, और यह अवांछित व्यवहार है। मैं यूआई के लिए इंतजार करना चाहता हूं जब तक कि उपयोगकर्ता कुछ भी करने से पहले उसका चयन न करे।

मैंने भी श्रोता को इसमें स्थापित करने की कोशिश की onResume(), उम्मीद है कि मदद मिलेगी, लेकिन यह नहीं करता है।

उपयोगकर्ता द्वारा नियंत्रण को छूने से पहले मैं इसे बंद करने से कैसे रोक सकता हूं?

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<CharSequence> 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.
    }
}
}

Comments

आप इस समाधान को देख सकते हैं, यह आसान और व्यावहारिक है। stackoverflow.com/a/10102356/621951

— गुने गुल्लेकिन

एक सरल उपाय यह होगा कि आप पहले आइटम को Spinnerखाली करें और अंदर onItemSelectedआप यह पता लगा सकते हैं कि स्ट्रिंग खाली नहीं है या नहीं startActivity!

— मुहम्मद बाबर

यह पैटर्न ठीक से काम करता है stackoverflow.com/questions/13397933/…

— saksham

Answer 1

मुझे आपके समाधान से काम करने की उम्मीद होगी - मैं हालांकि चयन कार्यक्रम में आग नहीं लगाऊंगा यदि आप श्रोता को स्थापित करने से पहले एडॉप्टर सेट करते हैं।

यह कहा जा रहा है, एक साधारण बूलियन ध्वज आपको बदमाश के पहले चयन कार्यक्रम का पता लगाने और इसे अनदेखा करने की अनुमति देगा।

Comments

उह, हाँ। Thats मुझे क्या मतलब है एक अशुभ समाधान द्वारा। लगता है कि एक बेहतर तरीका होना चाहिए। फिर भी आपका धन्यवाद।

— FauxReal

Dev ml पर इस थ्रेड के बारे में अधिक जानकारी है: group.google.com/group/android-developers/browse_thread/thread/… - दुर्भाग्य से इसका कोई समाधान नहीं दिया गया है ...

— BoD

घटकों को बिछाने की प्रक्रिया चयन श्रोता को निकालती है। इसलिए आपको लेआउट के पूरा होने के बाद श्रोता को जोड़ना होगा । मैं ऐसा करने के लिए एक उपयुक्त, सीधी जगह खोजने में असमर्थ रहा हूं क्योंकि लेआउट कुछ समय बाद onResume()और ऐसा लगता है onPostResume(), इसलिए लेआउट के होने तक सभी सामान्य हुक पूरा हो चुके होते हैं।

— डैन डायर

मैं इस बूलियन झंडे से दूर रहूंगा - जैसे कि भविष्य में व्यवहार में बदलाव होता है, यह बग का कारण बन सकता है। एक अधिक बुलेट प्रूफ समाधान "वर्तमान चयनित सूचकांक" के साथ एक चर रखने के लिए होगा, पहले चयनित आइटम के लिए प्रारंभिक। फिर चयन घटना पर - जांचें कि क्या यह नई स्थिति के बराबर है - वापस लौटें और कुछ भी न करें। निश्चित रूप से चयन पर चर को अद्यतन करें।

— daniel.gindi

यह काम नहीं करता। @Casanova द्वारा जवाब काम करता है। यही स्वीकृत उत्तर होना चाहिए।

— सिद्धार्थ

Answer 2

Runnables का उपयोग पूरी तरह से गलत है।

setSelection(position, false);पहले चयन में उपयोग करेंsetOnItemSelectedListener(listener)

इस तरह से आप अपना चयन बिना किसी एनीमेशन के करते हैं, जिसके कारण आइटम चयनित श्रोता को बुलाया जाता है। लेकिन सुनने वाला अशक्त है इसलिए कुछ भी नहीं चलाया जाता है। फिर आपका श्रोता असाइन किया गया है।

तो इस सटीक क्रम का पालन करें:

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

Comments

+1 छिपे मणि! "चेतन" पैरामीटर के रूप में गलत तरीके से पारित होने से श्रोता कॉलबैक नहीं कहते हैं। बहुत बढ़िया!

— पीकेके

+1 अजीब लेकिन सुरुचिपूर्ण समाधान :) सौभाग्य से, मुझे पहले से ही सेटसेलेक्शन को कभी भी कॉल करना था ...

— मार्टिन टी।

श्रोता अभी भी आग लगाएगा जब स्पिनर यूआई तत्व को इकट्ठा किया जाता है, इसलिए यह परवाह किए बिना आग देगा जो ओपी द्वारा वर्णित अवांछित व्यवहार को नहीं रोकता है। यह बहुत अच्छा काम करता है अगर onCreateView () के दौरान या उससे पहले घोषित नहीं किया जाता है, लेकिन यह वही नहीं है जो उन्होंने मांगा था।

— रूडी करशॉ

उपयोगी, लेकिन प्रस्तुत ओपी की तुलना में एक अलग समस्या है। ओपी एक चयन घटना को संदर्भित करता है जो (दुर्भाग्य से) स्वचालित रूप से आग लगती है जब दृश्य पहली बार दिखाई देता है भले ही प्रोग्रामर ने सेटिसलेशन नहीं किया था ।

— टूलमेकरसैट

SetSelection (..) पद्धति में "गलत" मान पैरामीटर मेरे लिए समाधान था। Ty!

— दानी

Answer 3

दान डायर के उत्तर का उल्लेख करते हुए, OnSelectListenerएक post(Runnable)विधि में पंजीकरण करने का प्रयास करें :

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

मेरे लिए वह कामना आखिरकार हुई।

इस मामले में इसका मतलब यह भी है कि श्रोता केवल बदले हुए आइटम पर फायर करता है।

Comments

मुझे यह कहते हुए एक त्रुटि मिलती है: प्रकार: AdapterView <SpinnerAdapter> टाइप करने के लिए विधि setOnItemSelectedListener (AdapterView.OnItemSelectedListener) तर्क के लिए लागू नहीं है (नया विवरण योग्य () {}) वह क्यों है?

— जैकब

क्या यह अनिवार्य रूप से रननेबल और यूआई थ्रेड के बीच एक दौड़ की स्थिति स्थापित नहीं कर रहा है?

— kenn_k

@theFunkyEngineer - इस कोड को मुख्य थ्रेड विधियों में से किसी एक से चलाया जाना चाहिएonCreate() , onResume()आदि। उस स्थिति में, यह एक शानदार चाल है, जिसमें रेस की स्थिति का कोई खतरा नहीं है। मैं आमतौर onCreate()पर लेआउट कोड के बाद इस ट्रिक का उपयोग करता हूं ।

— रिचर्ड ले मेसियर

यह एक महान समाधान है और निश्चित रूप से हैक नहीं है! इस प्रकार की कार्यक्षमता यह है कि कैसे रूपरेखा में चीजों को गहरा किया जाता है। यह शर्म की बात है कि स्पिनर आंतरिक रूप से ऐसा नहीं करते हैं। हालांकि, गतिविधि निर्माण के बाद चलाने के लिए कुछ कोड की गारंटी देने का यह सबसे साफ तरीका है। यह काम करता है क्योंकि श्रोता अभी तक स्पिनर पर सेट नहीं है जब गतिविधि उन्हें सूचित करने की कोशिश करती है।

— जोफडे

यह एक स्वीकार्य समाधान है । अंधा गोली नहीं। अन्य समाधान भविष्य में व्यवहार परिवर्तन समस्या के लिए अधिक प्रवण हैं।

— कुलदीप सिंह ढाका

Answer 4

मैंने Spinnerउपयोगकर्ता को सूचित किए बिना चयन बदलने के लिए एक छोटी उपयोगिता विधि बनाई :

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

यह श्रोता को निष्क्रिय कर देता है, चयन बदल देता है और उसके बाद श्रोता को फिर से सक्षम बनाता है।

चाल यह है कि कॉल यूआई थ्रेड के लिए अतुल्यकालिक हैं, इसलिए आपको इसे लगातार हैंडलर पोस्ट में करना होगा।

Comments

बहुत बढ़िया। मेरे पास कई स्पिनर थे और अपने मूल्यों को स्थापित करने से पहले अपने सभी श्रोताओं को अशक्त करने की कोशिश की, फिर मैंने उन सभी को वापस सेट कर दिया जो वे होने वाले थे, लेकिन किसी कारण से जो काम नहीं किया। इसके बजाय इस समारोह की कोशिश की और यह काम किया। मुझे नहीं पता कि मेरा काम क्यों नहीं हुआ, लेकिन यह काम करता है इसलिए मुझे परवाह नहीं है: D

— JStephen

ध्यान दें: यदि आप setSpinnerSelectionWithoutCallingListenerदो बार तेजी से कॉल करते हैं , ताकि दूसरी कॉल हो जाए जबकि पहले वाले ने पहले से ही श्रोता को सेट कर दिया है null, तो आपका स्पिनर nullहमेशा के लिए श्रोता से चिपक जाएगा। मैं निम्नलिखित फिक्स का प्रस्ताव करता हूं: if (listener == null) return;बाद में जोड़ें spinner.setSelection(selection)।

— वायलेट जिराफ

Answer 5

दुर्भाग्य से ऐसा लगता है कि इस मुद्दे के दो सबसे अधिक सुझाए गए समाधान, अर्थात् कॉलबैक घटनाओं की गणना करना और कॉलबैक को बाद के समय पर सेट करने के लिए एक रनवेबल को पोस्ट करना दोनों उदाहरण विफलता विकल्प सक्षम होने पर विफल हो सकते हैं। यहाँ एक सहायक वर्ग है जो इन मुद्दों पर काम करता है। आगे की खोज टिप्पणी ब्लॉक में है।

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

Comments

यह सबसे अधिक मतदान का जवाब होना चाहिए। यह सरल अभी तक शानदार है। यह आपको अपने सभी मौजूदा कार्यान्वयन को समान रखने की अनुमति देता है, एक पंक्ति को छोड़कर जहां आप आरंभ करते हैं। निश्चित रूप से रेट्रो-फिटिंग पुरानी परियोजनाएं काफी आसान हैं। उसके शीर्ष पर, मैंने स्पिनर के खुलने पर कीबोर्ड को बंद करने के लिए OnTouchLisener इंटरफ़ेस को लागू करके एक पत्थर से दो पक्षियों को मार दिया। अब मेरे सभी स्पिनर बिल्कुल वैसा ही व्यवहार करते हैं जैसा मैं चाहता हूं।

— user3829751

सुंदर जवाब। एडेप्टर में एडऑल () जोड़ने पर यह अभी भी 0 वें तत्व को ट्रिगर कर रहा है, लेकिन मेरा 0 वां तत्व न्यूट्रल (कुछ भी नहीं) व्यवहार के लिए एक दीर्घवृत्त है।

— jwehrle

Answer 6

जब मैं नहीं करना चाहता था, तो मैंने स्पिनर की गोलीबारी के साथ बहुत सारे मुद्दों का सामना किया है और यहां सभी उत्तर अविश्वसनीय हैं। वे काम करते हैं - लेकिन कभी-कभी ही। आप अंततः उन परिदृश्यों में भाग लेंगे जहां वे विफल हो जाएंगे और आपके कोड में बगों को पेश करेंगे।

मेरे लिए जो काम किया गया था वह अंतिम चयनित सूचकांक को एक चर में संग्रहीत करना और श्रोता में इसका मूल्यांकन करना था। यदि यह नया चयनित इंडेक्स कुछ भी नहीं करता है और वापस आता है, तो श्रोता के साथ जारी रखें। यह करो:

//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

}

मेरा विश्वास करो जब मैं यह कहता हूं, यह अब तक का सबसे विश्वसनीय समाधान है। एक हैक, लेकिन यह काम करता है!

Comments

क्या यह भी काम करेगा यदि आप मूल्य को बदलने की कोशिश कर रहे हैं? मेरे मामले में मैं 3 की तरह कुछ को मान सेट करने की कोशिश कर रहा हूं जब यह वास्तव में 0 होता है जो परिवर्तन श्रोताओं को ट्रिगर किए बिना होता है। क्या आप यह कह रहे हैं कि यदि मैं उपयोगकर्ता का चयन कर रहा हूं तो मैं केवल एक अलग मूल्य देता है?

— जस्तेफेन

हाय JStephen, मुझे 100% यकीन नहीं है कि आपका क्या मतलब है। लेकिन जब भी onItemSelected ट्रिगर हो जाएगा int मैं स्पिनर की स्थिति हो जाएगा। समस्या यह है कि onItemSelected को ट्रिगर किया जाता है जब भी स्पिनर पहली बार लोड होता है, बिना किसी वास्तविक उपयोगकर्ता सहभागिता के, इस मामले में अवांछित व्यवहार के लिए अग्रणी होता है। int मैं इस प्रारंभिक बिंदु पर 0 के बराबर होगा क्योंकि यह पहली बार शुरू होने वाला इंडेक्स है जब स्पिनर पहली बार लोड होता है। इसलिए मेरा समाधान यह सुनिश्चित करने के लिए जांचता है कि वर्तमान में चयनित आइटम के बदले वास्तविक वास्तविक आइटम का चयन किया गया है ... क्या यह आपके प्रश्न का उत्तर देता है?

— क्रिस

हाय क्रिस, मेरे पास एक पेज है जो उपयोगकर्ता को संपादित करने के लिए डेटाबेस से जानकारी खींचता है। जब पृष्ठ खुलता है तो मैं स्पिनरों को आबाद करता हूं, और फिर डेटाबेस में मौजूद मूल्यों पर अपनी स्थिति निर्धारित करता हूं। इसलिए यदि मैं उदाहरण के लिए उनकी स्थिति 3 पर सेट करता हूं, तो इसके कारण iIemSelected को i 3 से सेट करना होगा जो प्रारंभिक से अलग है। मैं सोच रहा था कि आप कह रहे हैं मैं केवल सेट है अगर उपयोगकर्ता वास्तव में खुद को बदल दिया है।

— जस्तेफन

क्या होगा यदि उपयोगकर्ता स्थिति 0 का चयन करता है? उनकी अनदेखी की जाएगी।

— यति

मुझे नहीं लगता कि अंतिम स्थिति तरीका अच्छा विचार है। मैं SharedPreferences से लोडिंग स्थिति और setSelection का उपयोग करके स्पिनरों को init करता हूं। बहुत बार शेयर्डप्रेफ में मानों को डिफ़ॉल्ट मान के समान नहीं किया जाता है जब स्पिनर बनाए जाते हैं, इसलिए onItemSelected को दीक्षा पर ट्रिगर किया जाएगा।

— Arthez

Answer 7

मैं इसी तरह की स्थिति में था, और मेरे पास मेरे लिए एक सरल उपाय है।

यह तरीकों की तरह लगता है setSelection(int position)और setSelected(int position, boolean animate)अलग-अलग आंतरिक कार्यान्वयन है।

जब आप setSelected(int position, boolean animate)झूठी चेतन ध्वज के साथ दूसरी विधि का उपयोग करते हैं , तो आपको onItemSelectedसुनने वाले को बिना फायरिंग के चयन मिलता है।

Comments

बेहतर तरीका यह है कि onItemSelected को अतिरिक्त कॉल के बारे में चिंता न करें, लेकिन यह सुनिश्चित करने के लिए कि यह सही चयन दिखाता है। इसलिए, श्रोता को जोड़ने से पहले स्पिनर.सेट्स सेलेक्शन (चयनितइंडेक्स) को कॉल करना मेरे लिए लगातार काम कर गया।

— andude

स्पिनर के लिए कोई सेट नहीं किया गया है (अंतर स्थिति, बूलियन चेतन) विधि

— शिफ्ट66

आपको जिस वास्तविक कॉल की आवश्यकता है, वह हैsetSelection(int position, boolean animate);

— ब्रैड

आपके लिए +1। यह एक अधिक सामान्य समस्या को हल करता है जब कोड को अधिक बार संशोधित किया जाता है स्पिनर सामग्री और चयन को केवल उपयोगकर्ता सहभागिता के लिए रखा जाता है

— alrama

दुख की बात है कि झूठा एनीमेशन झंडा अभी भी onItemSelected

— एपीआई

Answer 8

बस onTouchListener का उपयोग करने के लिए setOnItemSelectedListener (जो गतिविधि आरंभीकरण का हिस्सा हैं, आदि) के बीच अंतर करने के लिए केवल मांस को बाहर निकालने के लिए। बनाम कॉल यह वास्तविक उपयोगकर्ता बातचीत द्वारा ट्रिगर किया जाता है, मैंने यहां कुछ अन्य सुझावों की कोशिश करने के बाद निम्नलिखित किया और पाया कि इसने कोड की सबसे कम लाइनों के साथ अच्छा काम किया।

अपनी गतिविधि के लिए बस एक बूलियन फ़ील्ड सेट करें जैसे:

private Boolean spinnerTouched = false;

फिर इससे पहले कि आप अपने स्पिनर का सेटऑन इटेम सेलेक्टेड लिस्टनर को सेट करें, एक ऑन-लाइन लिस्टनर सेट करें:

    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;

Comments

यह बढ़िया काम करता है, और Android 6+ के बाद से, यह एकमात्र तरीका है जो काम करता है। लेकिन, आपको setOnKeyListener () के साथ भी ऐसा ही करना होगा, या यह तब काम नहीं करेगा जब उपयोगकर्ता कीबोर्ड के साथ नेविगेट करेगा।

— स्टीफन

महान काम करता है, अन्य सभी समाधानों में विभिन्न फोन के साथ कुछ समस्या होती है।

— ज़िवी ज़ेंग

यह सरल और बिल्कुल सही है! किसी अतिरिक्त बकवास की आवश्यकता नहीं है, बस तर्क को ध्यान में रखें। मुझे खुशी है कि मैंने यहाँ तक सभी तरह से नीचे स्क्रॉल किया!

— user3833732

SetOnKeyListener () के बजाय, आप स्पिनर को उपवर्गित कर सकते हैं और ध्वजांकित स्पिनर को सेट कर सकते हैं = ओवरराइड प्रीफ़ॉर्मक्लिक () विधि में सच है, जिसे दोनों मामलों (टच / की) में कहा जाता है। बाकी वही है।

— सर्वशक्तिमान

बस यह उल्लेख करना चाहता था कि ड्रॉपडाउनप्रायफ्रेंस के साथ एक ही बग को हल करने के लिए मैं यहां हाल ही में पोस्ट किया गया: stackoverflow.com/questions/61867118/… ... मैं नहीं कर सकता * cking यह विश्वास tbh: D

— डैनियल विल्सन

Answer 9

spinner.setSelection(Adapter.NO_SELECTION, false);

Comments

कोड खुद के लिए बोल सकता है, लेकिन थोड़ा सा स्पष्टीकरण एक लंबा रास्ता तय करता है :)

— नार्मन

Answer 10

लंबे समय तक अपने बालों को बाहर निकालने के बाद अब मैंने अपना खुद का स्पिनर वर्ग बनाया है। मैंने इसके लिए एक विधि जोड़ी है जो श्रोता को उचित रूप से डिस्कनेक्ट करता है और जोड़ता है।

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

इसे अपने XML में इस तरह उपयोग करें:

<my.package.name.SaneSpinner
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/mySaneSpinner"
    android:entries="@array/supportedCurrenciesFullName"
    android:layout_weight="2" />

आपको महंगाई और कॉल सेट के चयन के बाद SaneSpinner का उदाहरण प्राप्त करना होगा:

mMySaneSpinner.setSelection(1, true, true);

इसके साथ, किसी भी घटना को निकाल नहीं दिया जाता है और उपयोगकर्ता सहभागिता बाधित नहीं होती है। इससे मेरी कोड जटिलता बहुत कम हो गई। यह स्टॉक Android में शामिल किया जाना चाहिए क्योंकि यह वास्तव में एक PITA है।

Comments

यह मेरे लिए काम नहीं करता है, यह अभी भी onItemSelected चलाता है।

— Arthez

यदि आप वास्तव में तीसरे तर्क के लिए सच हो रहे हैं, तो कृपया Arthez को दोबारा जांचें। अगर हाँ यहाँ कुछ और गलत है। यदि संभव हो तो अपना कोड पोस्ट करें।

— संलयन44

Answer 11

यदि आप लेआउट समाप्त होने तक श्रोता को जोड़ना स्थगित करते हैं तो लेआउट चरण से कोई अवांछित घटना नहीं है:

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

            });

        }
    });

Comments

यह काम करता है, और IMO यह ओपी के विशिष्ट मुद्दे का सबसे साफ समाधान है। मैं यह नोट करना चाहता हूं कि आप ViewTreeObserver.OnGlobalLayoutListenerकॉल करके जे के नीचे के संस्करणों को हटा सकते हैं ViewTreeObserver.removeGlobalOnLayoutListener, जो कि पदावनत है और इस उत्तर का उपयोग करने की विधि के समान नाम है।

— जैक मिस्टर

Answer 12

ऐसा तब होगा जब आप कोड में चयन कर रहे हैं;

   mSpinner.setSelection(0);

उपर्युक्त कथन उपयोग के बजाय

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

संपादित करें: यह विधि Mi Android संस्करण Mi UI के लिए काम नहीं करती है।

Comments

इससे निश्चित रूप से मेरे लिए समस्या हल हो गई। मैंने स्पिनर विजेट के बारे में प्रलेखन पढ़ा .. यह अंतर समझने के लिए बिल्कुल मुश्किल है: सेटसेलेक्शन (इंट पोज़िशन, बूलियन चेतन) -> एडेप्टर डेटा में एक विशेष आइटम पर सीधे कूदें। setSelection (int स्थिति) -> वर्तमान में चयनित आइटम सेट करता है।

— मैट

Answer 13

मुझे बहुत सरल उत्तर मिला, 100% यकीन है कि यह काम करता है:

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
}

Answer 14

मुझे इसका बहुत अधिक सुरुचिपूर्ण समाधान मिला है। इसमें यह गिनना शामिल है कि ArrayAdapter (आपके मामले में "एडेप्टर") को कितनी बार पकड़ा गया है। मान लीजिए कि आपके पास 1 स्पिनर है और आप कॉल करते हैं:

int iCountAdapterCalls = 0;

ArrayAdapter<CharSequence> 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);

OnCreate के बाद एक int काउंटर घोषित करें और फिर onItemSelected () मेथड में एक "if" कंडीशन डालकर यह चेक करने के लिए कि कितनी बार atapter कहा गया है। आपके मामले में आपने इसे केवल एक बार बुलाया है:

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

Answer 15

मेरा छोटा सा योगदान उपरोक्त में से कुछ पर एक बदलाव है जिसने मुझे कुछ समय के लिए अनुकूल किया है।

एक पूर्णांक चर को डिफ़ॉल्ट मान (या वरीयताओं में सहेजे गए अंतिम उपयोग किए गए मान) के रूप में घोषित करें। श्रोता पंजीकृत होने से पहले उस मान को सेट करने के लिए spinner.setSelection (myDefault) का उपयोग करें। OnItemSelected जाँच में कि क्या नया स्पिनर मूल्य आपके द्वारा निर्दिष्ट कोड चलाने से पहले आपके द्वारा दिए गए मूल्य के बराबर है।

यदि उपयोगकर्ता फिर से समान मूल्य का चयन करता है तो कोड नहीं चलने का यह अतिरिक्त लाभ है।

Answer 16

एक ही समस्या होने के बाद, मैं टैग का उपयोग करके इस समाधान पर आया था। इसके पीछे का विचार सरल है: जब भी स्पिनर को प्रोग्राम में बदला जाता है, तो सुनिश्चित करें कि टैग चयनित स्थिति को दर्शाता है। श्रोता में, आप जांच लें कि चयनित स्थिति टैग के बराबर है या नहीं। यदि ऐसा होता है, तो स्पिनर चयन को कार्यक्रम में बदल दिया गया था।

नीचे मेरा नया "स्पिनर प्रॉक्सी" वर्ग है:

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

आपको अपनी Valuesनिर्देशिका में टैग सेटअप के साथ XML फ़ाइल की भी आवश्यकता होगी । मैंने अपनी फ़ाइल का नाम दिया है spinner_tag.xml, लेकिन यह आपके ऊपर है। यह इस तरह दिख रहा है:

<resources xmlns:android="http://schemas.android.com/apk/res/android">
  <item name="spinner_pos" type="id" />
</resources>

अब प्रतिस्थापित करें

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

के साथ अपने कोड में

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

और अपने हैंडलर को कुछ इस तरह बनाएं:

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

isUiTriggered()यदि उपयोगकर्ता द्वारा स्पिनर को बदल दिया गया है तो केवल और तभी फ़ंक्शन सही होगा। ध्यान दें कि इस फ़ंक्शन का साइड इफेक्ट है - यह टैग सेट करेगा, इसलिए समान श्रोता कॉल में एक दूसरा कॉल हमेशा वापस आएगा false।

यह आवरण लेआउट निर्माण के दौरान श्रोता के साथ समस्या को भी हल करेगा।

मज़े करो, जेन्स।

Answer 17

चूँकि मेरे लिए कुछ भी काम नहीं किया गया था, और मेरे विचार में मेरे पास 1 से अधिक स्पिनर हैं (और IMHO एक बूल मैप को पकड़े हुए एक ओवरकिल है) मैं टैग का उपयोग करके क्लिकों की गणना करता हूं:

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

Answer 18

जवाब पहले से ही, यहाँ मेरा है।

मैं विस्तार करता हूं AppCompatSpinnerऔर एक विधि जोड़ता हूं pgmSetSelection(int pos)जो चयन कॉलबैक को ट्रिगर किए बिना प्रोग्रामेटिक चयन सेटिंग की अनुमति देता है। मैंने इसे RxJava के साथ कोडित किया है ताकि चयन घटनाओं को एक के माध्यम से वितरित किया जा सके 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<Integer> 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);
    }
}

इसके उपयोग, में कहा जाता है का एक उदाहरण onCreateView()एक में Fragmentउदाहरण के लिए:

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

जहाँ setSelection()इस तरह दिखने वाले एन्कोडिंग दृश्य में एक विधि है, और जिसे Observableप्रोग्राम के माध्यम से उपयोगकर्ता चयन की घटनाओं से और कहीं और प्रोग्राम के रूप में भी कहा जाता है , इसलिए चयन को संभालने के लिए तर्क दोनों चयन विधियों के लिए आम है।

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
}

Answer 19

मैं फोन करने की कोशिश करूंगा

spinner.setOnItemSelectedListener(new MyOnItemSelectedListener());

आपके द्वारा setAdapter () कॉल करने के बाद। एडॉप्टर से पहले कॉलिंग का भी प्रयास करें।

आपके पास हमेशा उपवर्ग के साथ जाने का समाधान होता है, जहां आप ईवेंट को छोड़ने के लिए अपने ओवरराइड सेट एडेप्टर पद्धति में बूलियन ध्वज को लपेट सकते हैं।

Answer 20

बूलियन फ्लैग या काउंटर के साथ समाधान ने मेरी मदद नहीं की, 'अभिविन्यास परिवर्तन के दौरान इसका कारण यह है कि फ्लैग या काउंटर "ओवरफ्लव" कहता है।

मैंने उपविभाजित किया android.widget.Spinnerऔर छोटे परिवर्धन किए। संबंधित भाग नीचे हैं। इस समाधान ने मेरे लिए काम किया।

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

Answer 21

यह एक सुंदर समाधान भी नहीं है। वास्तव में यह बल्कि रुब-गोल्डबर्ग है लेकिन यह काम करने लगता है। मुझे लगता है कि स्पिन एडॉप्टर का विस्तार करके और इसके getDropDownView को ओवरराइड करके स्पिनर का कम से कम एक बार उपयोग किया गया है। नई getDropDownView पद्धति में मेरे पास एक बूलियन ध्वज है जो ड्रॉपडाउन मेनू को दिखाने के लिए सेट किया गया है कम से कम एक बार उपयोग किया गया है। मैं ध्वज को सेट करने तक श्रोता को कॉल अनदेखा करता हूं।

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

ओवरराइड सरणी एडाप्टर:

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

संशोधित श्रोता:

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

Answer 22

यदि आपको मक्खी पर गतिविधि को फिर से बनाने की आवश्यकता है जैसे: बदलते विषय, एक साधारण ध्वज / काउंटर अभ्यस्त काम

उपयोगकर्ता गतिविधि का पता लगाने के लिए onUserInteraction () फ़ंक्शन का उपयोग करें,

संदर्भ: https://stackoverflow.com/a/25070696/4772917

Answer 23

मैं है किया सबसे आसान तरीका है के साथ:

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

        }
    });

किया हुआ

Comments

इसका एक दिलचस्प उपाय है। अधिक स्पष्टीकरण का उपयोग कर सकता है। मूल रूप से इसके जानबूझकर पहले onItemSelected घटना की अनदेखी। वे कुछ मामलों में अच्छा काम कर सकते हैं लेकिन अन्य नहीं जैसे कि एक्सेसिबिलिटी विकल्प सक्षम होने पर (जोर का स्पष्टीकरण देखें) ।

— jk7

Answer 24

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

     }
});

Answer 25

यह मेरा अंतिम और समाधान का उपयोग करने के लिए आसान है:

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

सामान्य का उपयोग करें setSelection(...)डिफ़ॉल्ट व्यवहार या उपयोग के लिए setSelectionWithoutInformListener(...)OnItemSelectedListener कॉलबैक ट्रिगर किए बिना स्पिनर में एक आइटम का चयन करने के लिए।

Answer 26

मुझे mSpinnerViewHolder में उपयोग करने की आवश्यकता है , इसलिए झंडा mOldPositionअनाम आंतरिक वर्ग में सेट किया गया है।

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

Answer 27

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

Answer 28

मेरा समाधान उपयोग करता है onTouchListenerलेकिन इसके उपयोग से प्रतिबंधित नहीं करता है। onTouchListenerयदि आवश्यक हो तो सेटअप के लिए यह एक आवरण बनाता है 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;
    }
}

Answer 29

मैं पोस्ट पर बहुत देर से जवाब दे सकता हूं, हालांकि मैं एंड्रॉइड डेटा बाइंडिंग लाइब्रेरी एंड्रॉइड डेटाबाइंडिंग का उपयोग करके इसे हासिल करने में कामयाब रहा । मैंने यह सुनिश्चित करने के लिए एक कस्टम बाइंडिंग बनाई कि श्रोता को तब तक नहीं बुलाया जाए जब तक चयनित आइटम को बदल न दिया जाए, भले ही उपयोगकर्ता एक ही स्थिति का चयन कर रहा हो और फिर से ईवेंट को निकाल नहीं दिया गया हो।

लेआउट 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 वह जगह है जहां आप चयनित होने के लिए स्थिति से गुजर रहे हैं।

कस्टम बाइंडिंग

  @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) {

        }
    });
}

आप यहां कस्टम डेटा बाइंडिंग के बारे में अधिक पढ़ सकते हैं Android कस्टम सेटर

ध्यान दें

1. अपनी ग्रेड फ़ाइल में डेटाबाइंडिंग सक्षम करना न भूलें

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

2. अपनी लेआउट फ़ाइलों को <layout>टैग में शामिल करें

Answer 30

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

Comments

1) कृपया अपने कोड को ठीक से प्रारूपित करें। 2) आपका कोड क्या कर रहा है, इस पर एक स्पष्टीकरण भी सराहना की जाएगी। कोड पढ़ते समय सभी कोड स्निपेट तुरंत समझ में नहीं आते हैं।

— माइक कोच 20