새로 인스턴스화 된 스피너에서 onItemSelected가 실행되지 않도록하는 방법은 무엇입니까?

나는 이것을 해결할 수있는 우아한 방법보다 덜 생각했지만, 뭔가 빠진 것이 틀림 없다는 것을 안다.

나의 onItemSelected 사용자와의 상호 작용없이 즉시 꺼 화재, 이것은 바람직하지 않은 동작입니다. UI가 사용자가 무언가를 선택할 때까지 기다렸다가 아무것도하지 않기를 바랍니다.

나는 심지어 청취자를 설정하려고 시도했다. 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.
    }
}
}

솔루션이 작동 할 것으로 예상했을 것입니다. 리스너를 설정하기 전에 어댑터를 설정하면 선택 이벤트가 실행되지 않습니다.

즉, 간단한 부울 플래그를 사용하면 악성 첫 번째 선택 이벤트를 감지하고 무시할 수 있습니다.

Runnables 사용이 완전히 잘못되었습니다.

setSelection(position, false);초기 선택에서 사용setOnItemSelectedListener(listener)

이 방법으로 선택한 항목 리스너가 호출되게하는 애니메이션없이 선택을 설정합니다. 그러나 리스너가 null이므로 아무것도 실행되지 않습니다. 그런 다음 청취자가 할당됩니다.

따라서이 정확한 순서를 따르십시오.

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

댄 다이어의 대답을 참조하면, 등록하려고 OnSelectListenerA의 post(Runnable)방법 :

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

그렇게함으로써 원하는 행동이 마침내 일어났습니다.

이 경우에도 리스너가 변경된 항목에서만 실행됨을 의미합니다.

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

리스너를 비활성화하고 선택을 변경 한 후 리스너를 다시 활성화합니다.

트릭은 호출이 UI 스레드와 비동기 적이므로 연속 처리기 포스트에서 호출해야합니다.

불행히도이 문제에 대해 가장 일반적으로 제안되는 두 가지 솔루션, 즉 콜백 발생 수를 계산하고 나중에 콜백을 설정하기 위해 Runnable을 게시하면 접근성 옵션이 활성화 된 경우 모두 실패 할 수 있습니다. 이러한 문제를 해결하는 도우미 클래스가 있습니다. 추가 설명은 주석 블록에 있습니다.

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

원치 않을 때 스피너 발사와 관련된 많은 문제가 있었으며 여기에있는 모든 대답은 신뢰할 수 없습니다. 그들은 때때로 작동합니다. 결국 시나리오가 실패하고 코드에 버그가 생길 수 있습니다.

나를 위해 일한 것은 마지막으로 선택한 인덱스를 변수에 저장하고 리스너에서 평가하는 것이 었습니다. 새로 선택한 색인과 동일한 경우 아무 것도 수행하지 않고 리스너를 계속하십시오. 이 작업을 수행:

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

}

내가 이것을 말할 때 나를 믿어 라. 이것은 지금까지 가장 신뢰할만한 해결책이다. 해킹이지만 작동합니다!

나는 비슷한 상황에 있었고, 나를 위해 일하는 간단한 해결책이 있습니다.

이 방법처럼 보인다 setSelection(int position)및 setSelected(int position, boolean animate)다른 내부 구현이있다.

setSelected(int position, boolean animate)false 애니메이션 플래그와 함께 두 번째 방법을 사용하면 onItemSelected리스너를 시작 하지 않고 선택을 얻을 수 있습니다.

onTouchListener를 사용하여 setOnItemSelectedListener에 대한 자동 호출 (활동 초기화 등의 일부 임)과 실제 사용자 상호 작용에 의해 트리거 된 호출을 구별하는 힌트를 살리기 위해 여기에 다른 제안을 시도한 후 다음을 수행했습니다. 가장 적은 코드 줄에서도 잘 작동한다는 것을 알았습니다.

다음과 같이 액티비티 / 프레임에 부울 필드를 설정하십시오.

private Boolean spinnerTouched = false;

그런 다음 스피너의 setOnItemSelectedListener를 설정하기 직전에 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);

오랫동안 머리카락을 뽑은 후 나는 내 자신의 Spinner 클래스를 만들었습니다. 리스너를 적절히 연결 해제하고 연결하는 메소드를 추가했습니다.

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

이를 통해 이벤트가 발생하지 않으며 사용자 상호 작용이 중단되지 않습니다. 이것은 내 코드 복잡성을 크게 줄였습니다. 실제 PITA이므로 Android에 재고가 포함되어야합니다.

레이아웃이 끝날 때까지 리스너 추가를 연기하면 레이아웃 단계에서 원하지 않는 이벤트가 발생하지 않습니다.

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

            });

        }
    });

코드에서 다음과 같이 선택하면 발생합니다.

   mSpinner.setSelection(0);

위의 진술 대신에

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

편집 :이 방법은 Mi Android 버전 Mi UI에서 작동하지 않습니다.

나는 매우 간단한 대답을 얻었습니다 .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
}

나는 이것에 대해 훨씬 더 우아한 해결책을 찾았습니다. ArrayAdapter (여러분의 경우 "어댑터")가 몇 번이나 호출되었는지 계산합니다. 하나의 스피너가 있고 전화한다고 가정 해 봅시다.

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"조건을 지정하여 어댑터가 호출 된 횟수를 확인하십시오. 귀하의 경우에는 한 번만 호출하면됩니다.

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

내 작은 기여는 위의 일부 중 몇 가지에 적합한 변형입니다.

정수 변수를 기본값 (또는 환경 설정에 마지막으로 저장된 값)으로 선언하십시오. 리스너가 등록되기 전에 spinner.setSelection (myDefault)을 사용하여 해당 값을 설정하십시오. onItemSelected에서 새 스피너 값이 추가 코드를 실행하기 전에 지정한 값과 같은지 확인하십시오.

사용자가 동일한 값을 다시 선택하면 코드를 실행하지 않는 이점이 있습니다.

같은 문제가 있었지만 태그를 사용 하여이 솔루션에 왔습니다. 기본 개념은 간단합니다. 스피너가 프로그래밍 방식으로 변경 될 때마다 태그가 선택한 위치를 반영하는지 확인하십시오. 리스너에서 선택한 위치가 태그와 같은지 확인합니다. 그렇다면 스피너 선택이 프로그래밍 방식으로 변경되었습니다.

아래는 새로운 "스피너 프록시"클래스입니다.

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()는 사용자가 스피너를 변경 한 경우에만 true를 반환합니다. 이 함수는 부작용이 있습니다. 태그를 설정하므로 동일한 리스너 호출에서 두 번째 호출은 항상을 반환 false합니다.

이 래퍼는 레이아웃 생성 중에 리스너가 호출되는 문제도 처리합니다.

젠스

나를 위해 아무것도 효과가 없었으며 내 견해로는 1 회 이상의 스피너가 있으며 (BOHO지도를 보유하는 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) {
        }
    });

이미 많은 답변이 있습니다.

선택 콜백을 트리거하지 않고 프로그래밍 방식의 선택 설정을 허용 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()A의 Fragment예를 들면 :

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

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

전화하려고

spinner.setOnItemSelectedListener(new MyOnItemSelectedListener());

setAdapter ()를 호출 한 후 또한 어댑터 전에 전화를 걸어보십시오.

이벤트를 건너 뛰기 위해 부울 플래그를 재정의 된 setAdapter 메소드로 랩핑 할 수있는 서브 클래 싱을 사용하는 솔루션이 항상 있습니다.

부울 플래그 또는 카운터가있는 솔루션은 방향 변경 중에 onItemSelected () 호출이 플래그 또는 카운터를 "오버 플라잉"했기 때문에 도움이되지 않았습니다.

나는 하위 클래스 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;
}

이것은 우아한 해결책이 아닙니다. 사실 그것은 오히려 Rube-Goldberg이지만 작동하는 것 같습니다. 배열 어댑터를 확장하고 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;
}

즉시 활동을 다시 작성해야하는 경우 (예 : 테마 변경) 간단한 플래그 / 카운터가 작동하지 않습니다.

onUserInteraction () 함수를 사용하여 사용자 활동을 감지하고

참조 : https://stackoverflow.com/a/25070696/4772917

내가 한 일 간단한 방법으로 :

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

        }
    });

끝난

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

     }
});

그것이 나의 최종적이고 사용하기 쉬운 솔루션입니다.

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 콜백을 트리거하지 않고 스피너에서 항목을 선택하는 데 사용 하십시오.

내가 사용에 필요한 mSpinner플래그가 있으므로, ViewHolder에 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
            }
        });

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

내 솔루션은 사용 onTouchListener하지만 사용을 제한하지는 않습니다. onTouchListener필요한 경우 setup에 대한 랩퍼를 작성합니다 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;
    }
}

게시물에 너무 늦게 응답 할 수는 있지만 Android Data binding 라이브러리 Android Databinding을 사용하여이를 달성 했습니다. . 선택한 항목이 변경 될 때까지 리스너가 호출되지 않도록 사용자 정의 바인딩을 만들었으므로 사용자가 동일한 위치를 반복해서 선택하더라도 이벤트가 시작되지 않습니다.

레이아웃 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 Custom Setter를 참조하십시오.

노트

1. Gradle 파일에서 데이터 바인딩을 활성화하는 것을 잊지 마십시오

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

2. 레이아웃 파일을 <layout>태그에 포함

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