android - english - प्राकृतिक दृश्य फोटो डाउनलोड




एक बंद(परिपत्र) सूची दृश्य कैसे बनाएं? (4)

जिस समाधान का आप उल्लेख करते हैं वह वह है जिसे मैंने अतीत में उपयोग करने के लिए अन्य डेवलपर्स को बताया था। GetCount () में, बस Integer.MAX_VALUE लौटाएं, यह आपको लगभग 2 बिलियन आइटम देगा, जो पर्याप्त होना चाहिए।

मैं एक अनुकूलित सूची दृश्य (या समान) बनाना चाहता हूं जो एक बंद (परिपत्र) की तरह व्यवहार करेगा:

  1. नीचे स्क्रॉल करना - अंतिम आइटम पहुंचने के बाद पहली बार शुरू हुआ (.., एन -1, एन, 1, 2, ..)
  2. ऊपर स्क्रॉलिंग - पहली वस्तु के आखिरी शुरू होने के बाद (.., 2, 1, एन, एन -1, ..)

यह सरल रूप से सरल लगता है लेकिन जाहिर है, ऐसा करने के लिए कोई सीधा दृष्टिकोण नहीं है। क्या कोई मुझे सही समाधान के लिए इंगित कर सकता है? धन्यवाद !

मुझे पहले से ही एक उत्तर मिला है (एंड्रॉइड डेवलपर्स Google समूह पर बोस्टन के सड़कों से), लेकिन यह किसी भी तरह बदसूरत लगता है :) -

मैंने अपनी खुद की सूची-एडाप्टर (बेसएडाप्टर से उप-वर्गीकृत) बनाकर ऐसा किया।

मैंने अपनी खुद की सूची-एडाप्टर को इस तरह से कोड किया कि इसकी getCount () विधि एक ह्यूयूज संख्या लौटाती है।

और यदि आइटम 'x' चुना गया है, तो यह आइटम एडाप्टर स्थिति = 'adapter.getCount () / 2 + x' से मेल खाता है

और मेरे एडाप्टर की विधि getItem (int position) के लिए, मैं अपनी सरणी में देखता हूं जो एडाप्टर का बैक अप लेता है और आइटम को इंडेक्स पर लाता है: (position-getCount () / 2)% myDataItems.length

आपको इसे और अधिक सही तरीके से काम करने के लिए कुछ और 'विशेष' सामान करने की आवश्यकता है, लेकिन आपको विचार मिलता है।

सिद्धांत रूप में, सूची के अंत या शुरुआत तक पहुंचना अभी भी संभव है, लेकिन यदि आप getCount () को लगभग दस लाख या उससे भी अधिक तक सेट करते हैं, तो यह करना मुश्किल है :-)


मेरे पास है, या मुझे लगता है कि मैंने उपरोक्त उत्तरों के आधार पर इसे सही किया है। आशा है कि यह आपकी मदद करेगा।

private static class RecipeListAdapter extends BaseAdapter {
    private static LayoutInflater   mInflater;
    private Integer[]               mCouponImages;
    private static ImageView        viewHolder;
    public RecipeListAdapter(Context c, Integer[] coupomImages) {
        RecipeListAdapter.mInflater = LayoutInflater.from(c);
        this.mCouponImages = coupomImages;
    }
    @Override
    public int getCount() {
        return Integer.MAX_VALUE;
    }

    @Override
    public Object getItem(int position) {
       // you can do your own tricks here. to let it display the right item in your array.
        return position % mCouponImages.length;
    }

    @Override
    public long getItemId(int position) {
        return position;
        // return position % mCouponImages.length;
    }

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

        if (convertView == null) {
            convertView = mInflater.inflate(R.layout.coupon_list_item, null);
            viewHolder = (ImageView) convertView.findViewById(R.id.item_coupon);
            convertView.setTag(viewHolder);
        } else {
            viewHolder = (ImageView) convertView.getTag();
        }

        viewHolder.setImageResource(this.mCouponImages[position %     mCouponImages.length]);
        return convertView;
    }

}

और यदि आप सूची को स्क्रॉल करना चाहते हैं तो आप ऐसा करना चाहते हैं। आम तौर पर हम बस स्क्रॉल कर सकते हैं और सूची नीचे स्क्रॉल कर सकते हैं।

// देखें कि हम कितनी वस्तुओं को स्क्रॉल करना चाहते हैं। इस मामले में, Integer.MAX_VALUE

int listViewLength = adapter.getCount();

// see how many items a screen can dispaly, I use variable "span"
    final int span = recipeListView.getLastVisiblePosition() - recipeListView.getFirstVisiblePosition();

// देखें कि हमारे पास कितने पेज हैं

int howManySpans = listViewLength / span;

// देखें कि सूचीदृश्य शुरू करते समय आप कहां बनना चाहते हैं। आपको "-3" सामान नहीं करना है। यह मेरे ऐप के लिए सही काम करने के लिए है।

recipeListView.setSelection((span * (howManySpans / 2)) - 3);

मैं इसके लिए कुछ अच्छे जवाब देख सकता था, मेरे एक friend ने इसे सरल समाधान के माध्यम से हासिल करने का प्रयास किया है। github परियोजना की जांच करें।


यदि लोडर्स कॉलबैक का उपयोग करते हुए मैंने MyCircularCursor क्लास बनाया है जो इस तरह के सामान्य कर्सर को लपेटता है:

@Override
public void onLoadFinished(Loader<Cursor> pCursorLoader, Cursor pCursor) {
        mItemListAdapter.swapCursor(new MyCircularCursor(pCursor));
}

सजावटी वर्ग कोड यहां है:

public class MyCircularCursor implements Cursor {

private Cursor mCursor;

public MyCircularCursor(Cursor pCursor) {
    mCursor = pCursor;
}

@Override
public int getCount() {
    return mCursor.getCount() == 0 ? 0 : Integer.MAX_VALUE;
}

@Override
public int getPosition() {
    return mCursor.getPosition();
}

@Override
public boolean move(int pOffset) {
    return mCursor.move(pOffset);
}

@Override
public boolean moveToPosition(int pPosition) {
    int position = MathUtils.mod(pPosition, mCursor.getCount());
    return mCursor.moveToPosition(position);
}

@Override
public boolean moveToFirst() {
    return mCursor.moveToFirst();
}

@Override
public boolean moveToLast() {
    return mCursor.moveToLast();
}

@Override
public boolean moveToNext() {
    if (mCursor.isLast()) {
        mCursor.moveToFirst();
        return true;
    } else {
        return mCursor.moveToNext();
    }
}

@Override
public boolean moveToPrevious() {
    if (mCursor.isFirst()) {
        mCursor.moveToLast();
        return true;
    } else {
        return mCursor.moveToPrevious();
    }
}

@Override
public boolean isFirst() {
    return false;
}

@Override
public boolean isLast() {
    return false;
}

@Override
public boolean isBeforeFirst() {
    return false;
}

@Override
public boolean isAfterLast() {
    return false;
}

@Override
public int getColumnIndex(String pColumnName) {
    return mCursor.getColumnIndex(pColumnName);
}

@Override
public int getColumnIndexOrThrow(String pColumnName) throws IllegalArgumentException {
    return mCursor.getColumnIndexOrThrow(pColumnName);
}

@Override
public String getColumnName(int pColumnIndex) {
    return mCursor.getColumnName(pColumnIndex);
}

@Override
public String[] getColumnNames() {
    return mCursor.getColumnNames();
}

@Override
public int getColumnCount() {
    return mCursor.getColumnCount();
}

@Override
public byte[] getBlob(int pColumnIndex) {
    return mCursor.getBlob(pColumnIndex);
}

@Override
public String getString(int pColumnIndex) {
    return mCursor.getString(pColumnIndex);
}

@Override
public short getShort(int pColumnIndex) {
    return mCursor.getShort(pColumnIndex);
}

@Override
public int getInt(int pColumnIndex) {
    return mCursor.getInt(pColumnIndex);
}

@Override
public long getLong(int pColumnIndex) {
    return mCursor.getLong(pColumnIndex);
}

@Override
public float getFloat(int pColumnIndex) {
    return mCursor.getFloat(pColumnIndex);
}

@Override
public double getDouble(int pColumnIndex) {
    return mCursor.getDouble(pColumnIndex);
}

@Override
public int getType(int pColumnIndex) {
    return 0;
}

@Override
public boolean isNull(int pColumnIndex) {
    return mCursor.isNull(pColumnIndex);
}

@Override
public void deactivate() {
    mCursor.deactivate();
}

@Override
@Deprecated
public boolean requery() {
    return mCursor.requery();
}

@Override
public void close() {
    mCursor.close();
}

@Override
public boolean isClosed() {
    return mCursor.isClosed();
}

@Override
public void registerContentObserver(ContentObserver pObserver) {
    mCursor.registerContentObserver(pObserver);
}

@Override
public void unregisterContentObserver(ContentObserver pObserver) {
    mCursor.unregisterContentObserver(pObserver);
}

@Override
public void registerDataSetObserver(DataSetObserver pObserver) {
    mCursor.registerDataSetObserver(pObserver);
}

@Override
public void unregisterDataSetObserver(DataSetObserver pObserver) {
    mCursor.unregisterDataSetObserver(pObserver);
}

@Override
public void setNotificationUri(ContentResolver pCr, Uri pUri) {
    mCursor.setNotificationUri(pCr, pUri);
}

@Override
public boolean getWantsAllOnMoveCalls() {
    return mCursor.getWantsAllOnMoveCalls();
}

@Override
public Bundle getExtras() {
    return mCursor.getExtras();
}

@Override
public Bundle respond(Bundle pExtras) {
    return mCursor.respond(pExtras);
}

@Override
public void copyStringToBuffer(int pColumnIndex, CharArrayBuffer pBuffer) {
    mCursor.copyStringToBuffer(pColumnIndex, pBuffer);
}
}




circular-buffer