Android:AutoCompleteTextView listview滚动监听器（用于无限滚动）

我正在使用一个自动完成文本视图让我的android应用程序的用户使用自定义Web服务搜索内容：它按预期工作，但目前我找不到在下拉列表视图上实现“无止境滚动”的方法。

现在，我的AutoCompleteTextView适配器是一个ArrayAdapter，它实现了可过滤接口；每当用户更改AutoCompleteTextView的文本时，我的筛选器的performFiltering（）方法就会被触发，我可以向我的自定义Web服务发出HTTP请求以显示适当的内容。但我想在用户滚动下拉列表时加载更多内容，这是一个分页系统，这样我就可以避免一次加载上百个结果。。。我不知道该怎么做

• 如何获取与AutoCompleteTextView关联的ListView 要实现我自己的OnScrollListener/EndlessScrollListener
• 还有别的办法吗

谢谢大家：）

我的片段代码

AutoCompleteTextView search = (AutoCompleteTextView) view.findViewById(R.id.search);

SearchAdapter searchAdapter = new SearchAdapter(getActivity(), 0);

search.setAdapter(searchAdapter);

我的适配器代码（已编辑）

class SearchAdapter扩展ArrayAdapter实现可过滤{
整数倍=10；
布尔值moreDataIsAvailable=false；
碎片活动；
public ArrayList items=new ArrayList（）；
公共搜索适配器（FragmentActivity a，int textViewResourceId）{
super（a，textViewResourceId）；
活动=a；
}
@凌驾
public int getCount（）{
返回items.size（）；
}
@凌驾
公共包裹物品（国际索引）{
if（items.size（）>索引）{
返回项目。获取（索引）；
}否则{
返回null；
}
}
@凌驾
公共过滤器getFilter（）{
过滤器过滤器=新过滤器（）{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
FilterResults FilterResults=新的FilterResults（）；
if（constraint！=null&&constraint.toString（）.length（）>=3）{
自动完成（constraint.toString（），items）；
filterResults.count=items.size（）；
filterResults.values=项目；
}否则{
items.clear（）；
filterResults.count=items.size（）；
filterResults.values=项目；
}
返回过滤器结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
if（results！=null&&results.count>0）{
notifyDataSetChanged（）；
}否则{
notifyDataSetionValidated（）；
}
}
};
回流过滤器；
}
静态类视窗夹{
}
@凌驾
公共视图getView（int位置、视图转换视图、视图组父视图）{
ViewHolder=null；
视图行视图=转换视图；
if（rowView==null）{
rowView=LayoutFlater.from（活动）。充气（R.layout.search\u行，父项，false）；
holder=新的ViewHolder（）；
rowView.setTag（支架）；
}否则{
holder=（ViewHolder）rowView.getTag（）；
}
//设置我的行数据
返回行视图；
}
私有void自动完成（字符串输入、ArrayList项）{
ArrayList数据=新的ArrayList（）；
试一试{
RequestHandler请求=新的RequestHandler（）；
JSONObject requestParameters=新的JSONObject（）；
requestParameters.put（“偏移量”，0）；
requestParameters.put（“关键字”，输入）；
requestParameters.put（“limit”，numberpage）；
ResponseDescription response=request.request（活动，requestParameters）；
如果（！response.error）{
JSONArray searchedItems=response.getJSONArray（“items”）；
if（searchedItems.length（）==numberPage）{
moreDataIsAvailable=true；
}否则{
moreDataIsAvailable=false；
}
对于（int i=0；i

不幸的是，没有用于自动完成的

OnScrollListener

接口，但我认为您可能能够绕过这个问题

以下是我认为的食谱：

• 将另一个参数添加到偏移量的

  autocomplete

  方法中

我注意到您对偏移量进行了“0”硬编码。您需要能够调用

autocomplete

，并为其指定一个值。在

autocomplete

的末尾还有

items.clear（）

，您只需要在偏移量为零时执行此操作

• 为自动完成方法制作一个

  AsyncTask

或者除了

过滤器中的
性能过滤
方法之外，您还可以在后台运行
自动完成
。此异步任务需要访问适配器，以便它可以将其结果添加到
项
列表中，并像过滤器一样调用
notifyDataSetChanged（）

您的适配器需要保留对此任务的引用，以便在用户再次开始键入时可以取消该任务


将一些逻辑添加到
getView（）
以执行异步任务

我们没有一个
OnScrollListener
，所以我们将
class SearchAdapter extends ArrayAdapter<Parcelable> implements Filterable {

    Integer numberPerPage = 10;
    Boolean moreDataIsAvailable = false;

    FragmentActivity activity;
    public ArrayList<Parcelable> items = new ArrayList<Parcelable>();

    public SearchAdapter(FragmentActivity a, int textViewResourceId) {
        super(a, textViewResourceId);
        activity = a;
    }

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

    @Override
    public Parcelable getItem(int index) {
        if(items.size() > index) {
            return items.get(index);
        } else {
            return null;
        }
    }

    @Override
    public Filter getFilter() {
        Filter filter = new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence constraint) {
                FilterResults filterResults = new FilterResults();
                if (constraint != null && constraint.toString().length() >= 3) {
                    autocomplete(constraint.toString(), items);
                    filterResults.count = items.size();
                    filterResults.values = items;
                } else {
                    items.clear();
                    filterResults.count = items.size();
                    filterResults.values = items;
                }
                return filterResults;
            }

            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {
                if (results != null && results.count > 0) {
                    notifyDataSetChanged();
                } else {
                    notifyDataSetInvalidated();
                }
            }
        };
        return filter;
    }

    static class ViewHolder {
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        ViewHolder holder = null;

        View rowView = convertView;

        if (rowView == null) {

            rowView = LayoutInflater.from(activity).inflate(R.layout.search_row, parent, false);
            holder = new ViewHolder();
            rowView.setTag(holder);

        } else {

            holder = (ViewHolder) rowView.getTag();

        }

        // Setting my row data

        return rowView;

    }

    private void autocomplete(String input, ArrayList<Parcelable> items) {

        ArrayList<Parcelable> data = new ArrayList<Parcelable>();

        try {

            RequestHandler request = new RequestHandler();

            JSONObject requestParameters = new JSONObject();
            requestParameters.put("offset", 0);
            requestParameters.put("keyword", input);
            requestParameters.put("limit", numberPerPage);

            ResponseDescription response = request.request(activity, requestParameters);

            if(!response.error) {

                JSONArray searchedItems = response.getJSONArray("items");

                if(searchedItems.length() == numberPerPage) {
                    moreDataIsAvailable = true;
                } else {
                    moreDataIsAvailable = false;
                }

                for(int i = 0 ; i < searchedItems.length(); i++) {

                    JSONObject searchedItem = searchedItems.getJSONObject(i);

                    MyObject object = new MyObject();
                    object.initWithJSONObject(searchedItem);
                    data.add(object);

                }
            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        items.clear();
        items.addAll(data);

    }

}