Android AutoCompleteTextView结果出现，然后消失

我有一个

AutoCompleteTextView

，它使用自定义布局并从web服务器检索数据。我将其设置为，在用户停止键入EditText字段500毫秒后，应用程序仅从服务器请求数据

唯一的问题是，当我在

AutoCompleteTextView

中键入文本时，结果会显示500毫秒，然后消失（只显示一个空下拉列表）。我不确定是什么原因造成的

这是我的片段：

public class MyFragment extends Fragment {

    private AutoCompleteTextView autoCompleteField;

    private Timer timer;

    // 500 millisecond delay before showing the results
    private TextWatcher textWatcher = new TextWatcher() {
        @Override
        public void afterTextChanged(Editable arg0) {
            timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    String autoCompleteText = autoCompleteField.getText().toString();

                    if (!autoCompleteText.isEmpty()) {
                        getResultsFromServer(autoCompleteText);
                    }
                }
            }, 500);
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            //
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            // Reset the timer
            if (timer != null) {
                timer.cancel();
            }
        }
    };

    public MyFragment() {
        // Required empty public constructor
    }

    public static MyFragment newInstance() {
        MyFragment fragment = new MyFragment();

        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_dog, container, false);
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        autoCompleteField = (AutoCompleteTextView) view.findViewById(R.id.autoCompleteField);

        autoCompleteField.addTextChangedListener(textWatcher);
    }

    public void getResultsFromServer(String query) {
        ApiInterface apiService = ApiClient.createService(ApiInterface.class);

        Call<List<Dog>> call = apiService.getDogBreeds(query);
        call.enqueue(new Callback<List<Dog>>() {
            @Override
            public void onResponse(Call<List<Dog>> call, Response<List<Dog>> response) {
                List<Dog> dogs = response.body();

                CustomAutoCompleteAdapter adapter = new CustomAutoCompleteAdapter(getContext(), dogs);
                autoCompleteField.setAdapter(adapter);
            }

            @Override
            public void onFailure(Call<List<Dog>> call, Throwable t) {
                //
            }
        });
    }
}

公共类MyFragment扩展了片段{
私有自动完成文本视图自动完成字段；
私人定时器；
//显示结果前延迟500毫秒
私有TextWatcher TextWatcher=新的TextWatcher（）{
@凌驾
public void PostTextChanged（可编辑arg0）{
定时器=新定时器（）；
timer.schedule（新TimerTask（）{
@凌驾
公开募捐{
字符串autoCompleteText=autoCompleteField.getText（）.toString（）；
如果（！autoCompleteText.isEmpty（））{
getResultsFromServer（自动完成文本）；
}
}
}, 500);
}
@凌驾
更改前文本之前的公共void（字符序列s、int start、int count、int after）{
//
}
@凌驾
public void onTextChanged（字符序列、int start、int before、int count）{
//重置计时器
如果（计时器！=null）{
timer.cancel（）；
}
}
};
公共MyFragment（）{
//必需的空公共构造函数
}
公共静态MyFragment newInstance（）{
MyFragment fragment=新的MyFragment（）；
返回片段；
}
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
}
@凌驾
创建视图上的公共视图（布局、充气机、视图组容器、，
Bundle savedInstanceState）{
返回充气机。充气（R.layout.fragment_dog，容器，假）；
}
@凌驾
已创建视图上的公共void（视图，捆绑保存状态）{
autoCompleteField=（AutoCompleteTextView）view.findViewById（R.id.autoCompleteField）；
autoCompleteField.addTextChangedListener（textWatcher）；
}
public void getResultsFromServer（字符串查询）{
ApiInterface apiService=ApiClient.createService（ApiInterface.class）；
Call Call=apiService.getdogbrides（查询）；
call.enqueue（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
List dogs=response.body（）；
CustomAutoCompleteAdapter=新的CustomAutoCompleteAdapter（getContext（），dogs）；
autoCompleteField.setAdapter（适配器）；
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
//
}
});
}
}

这是我的适配器：

public class CustomAutoCompleteAdapter extends ArrayAdapter<Dog>
{
    private List<Dog> dogs;
    private List<Dog> filteredDogs = new ArrayList<>();

    public CustomAutoCompleteAdapter(Context context, List<Dog> dogs) {
        super(context, 0, dogs);
        this.dogs = dogs;
    }

    @Override
    public int getCount()
    {
        return filteredDogs.size();
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        Dog dog = filteredDogs.get(position);

        LayoutInflater inflater = LayoutInflater.from(getContext());
        convertView = inflater.inflate(R.layout.custom_autocomplete_layout, parent, false);

        ImageView image = (ImageView) convertView.findViewById(R.id.image);
        TextView text = (TextView) convertView.findViewById(R.id.text);

        // Set the breed's image
        Glide.with(context)
            .load("http://www.website.com/dogs/" + dog.getId() + ".png")
            .into(image);

        // Set the breed name
        text.setText(dog.getBreedName());

        return convertView;
    }

    @Override
    public Filter getFilter() {
        return new DogsFilter(this, dogs);
    }

    class DogsFilter extends Filter {
        CustomAutoCompleteAdapter adapter;
        List<Dog> originalList;
        List<Dog> filteredList;

        public DogsFilter(CustomAutoCompleteAdapter adapter, List<Dog> originalList) {
            super();
            this.adapter = adapter;
            this.originalList = originalList;
            this.filteredList = new ArrayList<>();
        }

        @Override
        protected FilterResults performFiltering(CharSequence constraint) {
            filteredList.clear();
            final FilterResults results = new FilterResults();

            if (constraint == null || constraint.length() == 0) {
                filteredList.addAll(originalList);
            } else {
                final String filterPattern = constraint.toString().toLowerCase().trim();

                // Your filtering logic goes in here
                for (final Dog dog : originalList) {
                    if (dog.getBreedName().toLowerCase().contains(filterPattern)) {
                        filteredList.add(dog);
                    }
                }
            }

            results.values = filteredList;
            results.count = filteredList.size();

            return results;
        }

        @Override
        protected void publishResults(CharSequence constraint, FilterResults results) {
            adapter.filteredDogs.clear();
            adapter.filteredDogs.addAll((List) results.values);
            adapter.notifyDataSetChanged();
        }
    }
}

公共类CustomAutoCompleteAdapter扩展了ArrayAdapter
{
私人名单狗只；
private List filteredDogs=new ArrayList（）；
公共CustomAutoCompleteAdapter（上下文，列表狗）{
超级（上下文，0，狗）；
这个。狗=狗；
}
@凌驾
public int getCount（）
{
返回filteredDogs.size（）；
}
@凌驾
公共视图getView（int位置、视图转换视图、视图组父视图）{
Dog Dog=filteredDogs.get（位置）；
LayoutInflater充气器=LayoutInflater.from（getContext（））；
convertView=充气机。充气（R.layout.custom\u autocomplete\u布局，父级，false）；
ImageView image=（ImageView）convertView.findViewById（R.id.image）；
TextView text=（TextView）convertView.findViewById（R.id.text）；
//设置品种的形象
带（上下文）滑动
.加载（“http://www.website.com/dogs/“+dog.getId（）+”.png”）
.进入（图像）；
//设置品种名称
text.setText（dog.getBreedName（））；
返回视图；
}
@凌驾
公共过滤器getFilter（）{
返回新的狗过滤器（此，狗）；
}
类DogsFilter扩展了过滤器{
自定义自动完成适配器；
列表原创者；
列表过滤器列表；
公用狗过滤器（自定义自动完成适配器，列表原始列表）{
超级（）；
this.adapter=适配器；
this.originalist=originalist；
this.filteredList=新的ArrayList（）；
}
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
filteredList.clear（）；
最终FilterResults结果=新的FilterResults（）；
if（constraint==null | | constraint.length（）==0）{
filteredList.addAll（原始列表）；
}否则{
final String filterPattern=constraint.toString（）.toLowerCase（）.trim（）；
//你的过滤逻辑在这里
for（最后一只狗：原创者）{
if（dog.getBreedName（）.toLowerCase（）.contains（filterPattern））{
filteredList.add（狗）；
}
}
}
results.values=filteredList；
results.count=filteredList.size（）；
返回结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
adapter.filteredDogs.clear（）；
adapter.filteredogs.addAll（（列表）results.values）；
adapter.notifyDataSetChanged（）；
}
}
}

---

是什么原因导致结果显示500毫秒（恰好等于AutoCompleteTextView延迟），然后消失？

这是因为您使用的是

Tim
    CustomAutoCompleteAdapter adapter;  //declare globally

@Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        autoCompleteField = (AutoCompleteTextView) view.findViewById(R.id.autoCompleteField);

        String autoCompleteText = autoCompleteField.getText().toString();
        if (!autoCompleteText.isEmpty()) {
            getResultsFromServer(autoCompleteText);
        }
        autoCompleteField.addTextChangedListener(textWatcher);
    }



private TextWatcher textWatcher = new TextWatcher() {

    long lastPress = 0l;
    @Override
    public void afterTextChanged(Editable arg0) {
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        //
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        if (System.currentTimeMillis() - lastPress > 1000) {
                lastPress = System.currentTimeMillis();
                adapter.getFilter().filter(s.toString());   //filter adpater data
            }
    }
};