1

例如：-如果我加载列表中的前 5 个项目，然后向下滚动加载接下来的五个项目

并且因为它是一个无限的适配器，所以这个过程必须无休止地重复这就是我尝试的方式--> foliowing 是我的演示适配器代码：-

   public class MyDemoAdapter extends EndlessAdapter {

private static int cutting_int =5;
public static int batch_repeat = 0;
public int check_batch = 0;
private Context mcontxt;
private RotateAnimation rotate = null;
ArrayList<DownloadOffersClass> tempList = new ArrayList<DownloadOffersClass>();
private static int mLastOffset = 0;
private ArrayList<DownloadOffersClass> list = new ArrayList<DownloadOffersClass>();
private int LIST_SIZE;


public MyDemoAdapter(Context context, int textViewResourceId,
        ArrayList<DownloadOffersClass> list, int lIST_SIZE) {
    super(new DownloadedOffersAdapter(context,
            R.layout.offer_listview_item, list));
    this.mcontxt = context;
    this.list = list;
    this.LIST_SIZE = lIST_SIZE;
    rotate = new RotateAnimation(0f, 360f, Animation.RELATIVE_TO_SELF,
            0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
    rotate.setDuration(600);
    rotate.setRepeatMode(Animation.RESTART);
    rotate.setRepeatCount(Animation.INFINITE);
}

@Override
protected View getPendingView(ViewGroup parent) {
    LayoutInflater inflater = (LayoutInflater) mcontxt
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

    View row = inflater.inflate(R.layout.row, null);

    View child = row.findViewById(android.R.id.text1);

    child.setVisibility(View.GONE);

    child = row.findViewById(R.id.throbber);
    child.setVisibility(View.VISIBLE);
    child.startAnimation(rotate);

    return (row);
}

@Override
protected boolean cacheInBackground() {
    SystemClock.sleep(2000);

    if (check_batch != batch_repeat) {
        tempList.clear();
        int lastOffset = getLastOffset();
        if (lastOffset < LIST_SIZE) {
            int limit = lastOffset + cutting_int;
            for (int i = (lastOffset + 1); (i <= limit && i < LIST_SIZE); i++) {
                tempList.add(list.get(i));
            }
            setLastOffset(limit);

            if (limit < 50) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    } else {
        return false;
    }
}

@Override
protected void appendCachedData() {
    if (getWrappedAdapter().getCount() < 50) {
        @SuppressWarnings("unchecked")
        DownloadedOffersAdapter a = (DownloadedOffersAdapter) getWrappedAdapter();

        check_batch = check_batch + 1;
        Log.v("Check", " " + check_batch);
        for (int i = cutting_int; i < cutting_int + cutting_int; i++) {
            a.add(list.get(i));
        }
    }
}

public static void setLastOffset(int i) {
    mLastOffset = i; 
}

private int getLastOffset() {
    return mLastOffset;
}

}

4

3 回答 3

3

修改你的 cacheInBackground()

if (check_batch != batch_repeat) {
            tempList.clear();
            int lastOffset = getLastOffset();
            if (lastOffset < LIST_SIZE) {
                int limit = lastOffset + cutting_int;
                for (int i = (lastOffset + 1); (i <= limit && i <                                           LIST_SIZE); i++) {
                    tempList.add(list.get(i));
                }
                setLastOffset(limit);

                if (limit <= 50) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } else {
            if (!firstTry) {// use this boolean to do it only once
                tempList.clear();
                int notDivisible = LIST_SIZE % cutting_int;
                if (!(notDivisible == 0)) {
                    firstTry = true;
                    return true;
                } else {
                    return false;
                }
            }
            return false;
        }

并将您的 appendCachedData() 方法替换为：

  protected void appendCachedData() {

        DownloadedOffersAdapter a = (DownloadedOffersAdapter) getWrappedAdapter();
        if (check_batch != batch_repeat) {
            if (getWrappedAdapter().getCount() <= 50) {
                check_batch = check_batch + 1;
                Log.v("Check", "append chk_batch " + check_batch);
                for (int i = cutting_int; i < cutting_int + cutting_int; i++) {
                    a.add(list.get(i));
                }
            }
        } else {// Append extra entries to list i.e less than cutting_int
            int notDivisible = LIST_SIZE % cutting_int;
            for (int i = (LIST_SIZE - notDivisible); i < LIST_SIZE - 1; i++) {
                a.add(list.get(i));
            }
            return;
        }
    }
于 2013-04-19T13:39:23.083 回答
0

您将在列表适配器上为 ImageLoader 创建对象。

ImageLoader lazyload = new ImageLoader(context);

public ImageLoader(Context context) {
        FileCache fileCache = new FileCache(context);
        ExecutorService executorService = Executors.newFixedThreadPool(5);
    }

然后像这样将图像设置为您的适配器 getView() 。 

  ImageView image = (ImageView) view.findViewById(R.id.yourImage);

    lazyload.displayImage(image);

加载你的图片

public void displayImage(String url, ImageView imageView) {
    if (bitmap != null)
        imageView.setImageBitmap(bitmap);
于 2013-04-19T11:04:04.530 回答
0

例如：-如果我加载列表中的前 5 个项目，然后向下滚动加载接下来的五个项目

您负责用足够的项目填充适配器以保证滚动，而 5 不太可能就足够了。

当您被告知要加载额外数据时，您有责任确定要加载多少额外项目。

并且因为它是一个无限的适配器，所以这个过程必须无休止地重复

或者直到您告诉EndlessAdapter没有更多数据，例如false从cacheInBackground(). 这里的想法是，当您执行 Web 服务调用以获取下一组数据时，您还应该确定您是否已到达可用数据的末尾。

于 2013-04-19T11:32:52.353 回答