如何保持onItemSelected从发射上一个新实例化的旋转器?

小开

最佳答案

我希望您的解决方案能够工作——我认为如果在设置侦听器之前设置适配器，则选择事件不会触发。

也就是说，一个简单的布尔标志将允许您检测到恶意的第一次选择事件并忽略它。

小开

我会尽量打电话的

spinner.setOnItemSelectedListener(new MyOnItemSelectedListener());

在调用setAdapter()之后。还可以尝试在适配器之前进行调用。

您总是有子类化的解决方案，在子类化中，您可以将一个布尔标志包装到覆盖的setAdapter方法以跳过事件。

小开

参考Dan Dyer的答案，尝试在post(Runnable)方法中注册OnSelectListener:

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

通过这样做，我所希望的行为终于发生了。

在本例中，它还意味着侦听器仅在更改的项上触发。

小开

布尔标志或计数器的解决方案没有帮助我，因为在方向变化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;
}

小开

我创建了一个小的实用工具方法，可以在不通知用户的情况下更改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线程是异步的，所以必须在连续的处理程序中执行。

小开

我也遇到过类似的情况，我有一个简单的解决办法。

setSelection(int position)和setSelected(int position, boolean animate)方法似乎有不同的内部实现。

当你使用带有false animate标志的第二个方法setSelected(int position, boolean animate)时，你可以在不触发onItemSelected侦听器的情况下获得选择。

小开

我找到了更优雅的解决方法。它包括计算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”条件来检查atapter被调用了多少次。在你的例子中，你只调用了一次:

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

小开

不幸的是，解决这个问题的两个最常见的建议解决方案，即统计回调发生次数和发布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(); }
}

小开

我的小贡献是对上面的一些已经适合我几次的变化。

声明一个整型变量作为默认值(或保存在首选项中的最后使用值)。使用spinner.setSelection(myDefault)在注册侦听器之前设置该值。在onItemSelected中，在运行任何进一步的代码之前，检查新的spinner值是否等于您分配的值

这样做的另一个好处是，如果用户再次选择相同的值，就不会运行代码。

小开

使用Runnables是完全错误的。

在setOnItemSelectedListener(listener)之前的初始选择中使用setSelection(position, false);

通过这种方式，您可以在没有动画的情况下设置您的选择，这将导致被选中的监听器被调用。但是监听器是空的，所以什么都没有运行。然后分配你的听众。

所以按照这个顺序来做吧:

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

小开

spinner.setSelection(Adapter.NO_SELECTION, false);

小开

我有很多问题与旋转发射时，我不想，所有的答案在这里是不可靠的。它们确实有效——但只是有时有效。您最终会遇到它们失败并将错误引入代码的情况。

对我来说，有效的方法是将最后选中的索引存储在一个变量中，并在侦听器中对其求值。如果它与新选定的索引相同，则不做任何操作并返回，否则继续使用侦听器。这样做:

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


}

相信我，这是目前为止最可靠的解决方案。一个黑客，但它工作!

小开

在遇到同样的问题后，我使用标签找到了这个解决方案。它背后的思想很简单:无论何时以编程方式更改旋转器，都要确保标记反映所选的位置。然后在侦听器中检查所选位置是否等于标记。如果是，则以编程方式更改旋转器选择

下面是我的新“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.
}

你还需要在你的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。

这个包装器还将处理在布局创建期间调用侦听器的问题。

< p >玩得开心, 延斯。< / p >

小开

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

小开

这也不是一个优雅的解决方案。事实上，这有点像鲁布-戈德堡，但似乎很有效。通过扩展数组适配器并覆盖其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) {


}
});

完成

小开

在抽出我的头发很长一段时间后，现在我已经创建了自己的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);

这样，就不会触发任何事件，用户交互也不会中断。这大大降低了我的代码复杂性。这应该包括在Android的股票，因为它确实是一个PITA。

小开

这不是一个特别优雅的解决方案，但我发现它工作可靠。简单地在onResume中设置一个延迟线程上的侦听器。然后你可以自由地做任何你喜欢的初始化，UI会做出任何布局的改变，然后设置监听器。

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

小开

如果你推迟添加监听器，直到布局完成，就不会有不必要的事件

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


});


}
});

小开

因为对我来说什么都没用，而且我的视图中有超过1个旋转器(以我个人的观点，持有bool地图是多余的)，我使用标签来计数点击:

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

小开

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


}
});

小开

只是为了补充使用onTouchListener来区分对setOnItemSelectedListener的自动调用(这是Activity初始化的一部分，等等)与实际用户交互触发的对它的调用之间的提示，在尝试了其他一些建议后，我做了以下工作，并发现它用最少的代码行就能很好地工作。

只需要为你的Activity/Fragment设置一个布尔字段:

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;

小开

设计一种通用旋流器，只需数据输入，由用户选择，优点:

1. 保持应用程序的转轮样式相同 2.
.在任意位置启动旋转器 3.易于处理链接转轮(重新启动ReuseSpinner与不同的数据).

< / p >

我的演示示例:ReuseSpinner
将数据传递给ReuseSpinner:

Intent intent = new Intent(MainActivity.this, SpinnerActivity.class);
intent.putExtra(SpinnerActivity.Extra_Resource, arrayList);
startActivityForResult(intent, mRequestCode_select_country_prompt);

获取用户选择:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// TODO Auto-generated method stub
super.onActivityResult(requestCode, resultCode, data);


if(requestCode == mRequestCode_select_country && resultCode == RESULT_OK){
if(data != null){
Map.Entry<String,String> entry = (Map.Entry<String,String>) data.getSerializableExtra(SpinnerActivity.Result_Data);
if(entry != null){
Log.i(TAG, String.format("get result -> key:%s , value:%s", entry.getKey(), entry.getValue()));


}
}
}
}

小开

我得到了一个非常简单的答案，百分百确定它有效:

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
}

小开

这是我最后的简单易用的解决方案:

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回调。

小开

我需要在ViewHolder中使用mSpinner，因此标记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
}
});

小开

如果你在代码中进行选择，就会发生这种情况;

   mSpinner.setSelection(0);

代替上述语句

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

编辑:此方法不适用于Mi Android版本的Mi UI。

小开

这不是一个完美的解决方案，但如果你喜欢将起始字符串作为一个占位符，你可以添加占位符弹簧值("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();
}




}
}

小开

我将在创建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，但不限制它的使用。如果需要，它会在设置onItemSelectedListener时为onTouchListener创建一个包装器。

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数据绑定库Android数据绑定实现了这一点。我创建了一个自定义绑定，以确保监听器不被调用，直到选定的项目被改变，所以即使用户选择相同的位置，一遍又一遍地事件不会被触发。

布局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自定义Setter

请注意

不要忘记在你的Gradle文件中启用数据绑定

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

Include your layout files in <layout> tags

小开

已经有很多答案了，这是我的。

我扩展了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);
}
}

它的用法示例，在Fragment中调用onCreateView()，例如:

    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
}