कैसे एंड्रॉयड

Question

में LoaderManager में दो Cursors और CursorJoiner उपयोग करने के लिए मैं एक ContentProvider है, यह दो तालिकाओं 1. OnlineContacts 2. AllContacts होने है। तब मेरे पास एक तरीका है जिसमें मैं दोनों टेबलों से पूछताछ कर रहा हूं और उनके परिणामस्वरूप cursors अलग-अलग प्राप्त कर रहा हूं। और फिर वहाँ मिलती CursorJoiner का उपयोग करने और Contacts की एक सूची बना रही है। इस सूची को मेरे CustomAdapter extending BaseAdapter पर पास करना, मैं अपना listview पॉप्युलेट कर रहा हूं। जैसा:

public static List<Contact> getContacts(Context context){ 
    List<Contact> contactList = new ArrayList<Contact>(); 

// Getting First Cursor 
    String URL = xyz; 
    Uri baseUri1 = Uri.parse(URL); 
    String[] select = xyz; 
    String where =xyz; 
    Cursor cursor = context.getContentResolver().query(baseUri1, select, where, null, "pid"); 

// Getting 2nd Cursor 
    Uri baseUri = xyz; 
    String[] projection =xyz; 
    String selection =xyz; 
    String[] selectionArgs = null; 
    String sortOrder = xyz; 

    Cursor mCursor= context.getContentResolver().query(baseUri, projection, selection, selectionArgs, sortOrder); 

    // Joinging Both Cursors 

    CursorJoiner joiner = new CursorJoiner(cursor, new String[] {MyContentProvider.PHONE_ID} , mCursor, new String[] {MyContentProvider.Phone._ID}); 
    for (CursorJoiner.Result joinerResult : joiner) { 
     Contact cont = new Contact(); 

     switch (joinerResult) { 
     case LEFT: 
      // handle case where a row in cursorA is unique 
      break; 
     case RIGHT: 
      // handle case where a row in cursorB is unique 

     case BOTH: 
      // handle case where a row with the same key is in both cursors 
      cont.setID(xyz); 
      cont.setName(xyz); 
      cont.setPhoneNumber(xyz); 
      cont.setStatus("0"); 
      contactList.add(cont); 
      break; 
     } 
    } 
    mCursor.close(); 
    cursor.close(); 
    return contactList; 
} 

और यहाँ मेरी CustomAdapter है:

private class CustomAdapter extends BaseAdapter { 

     List<Contact> contactsList ; 
     public CustomAdapter(List<Contact> contactsList){ 
      this.contactsList = contactsList; 
     } 

     public List<Contact> contacts() { 
      return this.contactsList;  
     } 

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

     @Override 
     public Contact getItem(int arg0) { 
      return contactsList.get(arg0); 
     } 

     @Override 
     public long getItemId(int arg0) { 
      return arg0; 
     } 

     @Override 
     public View getView(int position, View view, ViewGroup viewGroup) { 

      SimpleViewHolder viewHolder; 
      if(view==null) 
      { 
       LayoutInflater inflater = (LayoutInflater) getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
       view = inflater.inflate(R.layout.list_item, viewGroup,false); 
       viewHolder = new SimpleViewHolder(view); 
       view.setTag(viewHolder); 
      } 

      viewHolder = (SimpleViewHolder) view.getTag(); 

      TextView contName = (TextView) viewHolder.get(R.id.nameText); 
      ImageView image = (ImageView) viewHolder.get(R.id.contact_image); 

      Contact contact = contactsList.get(position); 
      image.setBackgroundResource(R.drawable.person_empty_offline); 

      contName.setText(contact.getName()); 
      return view; 
     } 

    } 

अब, मैं LoaderManager का उपयोग कर यह करने के लिए की जरूरत है। मुझे पता है, कुछ हद तक, इसका कार्यान्वयन। मैं जानता हूँ कि, onCreateLoader कृत्यों की तरह:

public Loader<Cursor> onCreateLoader(int id, Bundle args) { 

     Uri baseUri = xyz; 
     String[] projection = xyz; 
     String selection = xyz; 
     String[] selectionArgs = null; 
     String sortOrder = xyz; 
     return new CursorLoader(getActivity(), baseUri, projection, selection, selectionArgs, sortOrder); 
} 

और OnCreate में, अगर मैं MyCursorAdapter extending CursorAdapter उपयोग करें, हम कुछ ऐसा कार्य करें:

mAdapter = new MyCursorAdapter(getActivity(), null, 0); 
     setListAdapter(mAdapter); 
     getLoaderManager().initLoader(0, null, this); 

अब, मैं क्या करने की जरूरत है कि कैसे कर सकते हैं मैं LoaderManager का उपयोग कर उपरोक्त कार्यान्वयन को प्राप्त करें। मुझे नहीं पता था कि यह कैसे पूछना है कि यह भी व्याख्यात्मक क्यों है।

Answer 1

प्रत्येक कर्सर के लिए दो लोडर का उपयोग करें। जब कोई भी लोडिंग समाप्त करता है, तो दूसरी विधि को कॉल करें जो दोनों में शामिल हो जाएंगे यदि दोनों लोड हो गए हैं।

// Loader IDs. You could also generate unique R.id values via XML 
private static final int LOADER_ID_CURSOR_1 = 1; 
private static final int LOADER_ID_CURSOR_2 = 2; 

private Cursor cursor1 = null; 
private Cursor cursor2 = null; 

// return loader for cursor 1 
private CusorLoader getCursor1Loader() { 
    Uri uri = Uri.parse(abc); 
    String[] select = abc; 
    String where = abc; 
    String[] whereArgs = abc; 
    String sortOrder = abc; 
    return new CursorLoader(uri, select, where, whereArgs, sortOrder); 
} 

// return loader for cursor 2 
private CusorLoader getCursor2Loader() { 
    // same as above but with different values 
    return new CursorLoader(uri, select, where, whereArgs, sortOrder); 
} 

// to start loading, ... 
LoaderManager lm = getLoaderManager(); 
lm.initLoader(LOADER_ID_CURSOR_1, null, this); 
lm.initLoader(LOADER_ID_CURSOR_2, null, this); 

// LoaderCallbacks implementations 
@Override 
public Loader<Cursor> onCreateLoader(int id, Bundle args) { 
    switch(id) { 
    case LOADER_ID_CURSOR_1: 
     return getCursor1Loader(); 
    case LOADER_ID_CURSOR_2: 
     return getCursor2Loader(); 
    } 
} 

@override 
public void onLoadFinished(Loader<Cursor> loader, Cursor data) { 
    switch(loader.getId()) { 
    case LOADER_ID_CURSOR_1: 
     cursor1 = data; 
     joinCursors(); 
     break; 
    case LOADER_ID_CURSOR_2: 
     cursor2 = data; 
     joinCursors(); 
     break; 
    } 
} 

private void joinCursors() { 
    if (cursor1 != null && cursor2 != null) { 
     // use CursorJoiner here 
    } 
} 

Answer 2

मैंने एक कक्षा लिखी है जो LoaderManager का उपयोग करके दो अलग-अलग Cursors लोड करती है और CursorJoiner.Result ऑब्जेक्ट्स लौटाती है ताकि आप शामिल हो सकें। इस कोड के बारे में कुछ कहना नहीं है, अगर कुछ अस्पष्ट है या आपके कोई प्रश्न हैं तो टिप्पणियों में पूछें!

public class JoinLoader { 

    public interface JoinHandler { 
     public void onHandleJoin(CursorJoiner.Result result); 
    } 

    private static final int LOADER_ONE = 0; 
    private static final int LOADER_TWO = 1; 

    private final LoaderCallbackImpl callbackOne; 
    private final LoaderCallbackImpl callbackTwo; 

    private final Context context; 
    private final LoaderManager loaderManager; 

    private Cursor cursorOne; 
    private Cursor cursorTwo; 

    private String[] leftColumns; 
    private String[] rightColumns; 

    private JoinHandler joinHandler; 

    private JoinLoader(Activity activity) { 
     this.context = activity; 
     this.loaderManager = activity.getLoaderManager(); 
     this.callbackOne = new LoaderCallbackImpl(activity, new LoaderCallbackImpl.FinishedListener() { 
      @Override 
      public void onFinished(Cursor data) { 
       cursorOne = data; 
       handleSuccess(); 
      } 
     }); 
     this.callbackTwo = new LoaderCallbackImpl(activity, new LoaderCallbackImpl.FinishedListener() { 
      @Override 
      public void onFinished(Cursor data) { 
       cursorTwo = data; 
       handleSuccess(); 
      } 
     }); 
    } 

    public void start() { 
     this.cursorOne = null; 
     this.cursorTwo = null; 
     this.loaderManager.initLoader(LOADER_ONE, null, this.callbackOne); 
     this.loaderManager.initLoader(LOADER_TWO, null, this.callbackTwo); 
    } 

    public void setJoinOn(String[] leftColumns, String[] rightColumns) { 
     this.leftColumns = leftColumns; 
     this.rightColumns = rightColumns; 
    } 

    private void handleSuccess() { 
     if(this.joinHandler != null && this.cursorOne != null && this.cursorTwo != null) { 
      CursorJoiner joiner = new CursorJoiner(this.cursorOne, this.leftColumns, this.cursorTwo, this.rightColumns); 
      for (CursorJoiner.Result result : joiner) { 
       this.joinHandler.onHandleJoin(result); 
      } 
      this.cursorOne.close(); 
      this.cursorTwo.close(); 
     } 
    } 

    public void setJoinHandler(JoinHandler joinHandler) { 
     this.joinHandler = joinHandler; 
    } 

    public void setFirstQuery(Uri uri, String[] projection, String selection, String[] selectionArgs, String orderBy) { 
     this.callbackOne.setQuery(uri, projection, selection, selectionArgs, orderBy); 
    } 

    public void setSecondQuery(Uri uri, String[] projection, String selection, String[] selectionArgs, String orderBy) { 
     this.callbackTwo.setQuery(uri, projection, selection, selectionArgs, orderBy); 
    } 

    private static class LoaderCallbackImpl implements LoaderManager.LoaderCallbacks<Cursor> { 

     public interface FinishedListener { 
      public void onFinished(Cursor data); 
     } 

     private final Context context; 
     private final FinishedListener finishedListener; 

     private Uri uri; 
     private String[] projection; 
     private String selection; 
     private String[] selectionArgs; 
     private String orderBy; 

     private boolean finished = false; 

     private LoaderCallbackImpl(Context context, FinishedListener listener) { 
      this.context = context; 
      this.finishedListener = listener; 
     } 

     @Override 
     public Loader<Cursor> onCreateLoader(int id, Bundle args) { 
      this.finished = false; 
      return new CursorLoader(context, uri, projection, selection, selectionArgs, orderBy); 
     } 

     @Override 
     public void onLoadFinished(Loader<Cursor> loader, Cursor data) { 
      this.finished = true; 
      if(this.finishedListener != null) { 
       this.finishedListener.onFinished(data); 
      } 
     } 

     @Override 
     public void onLoaderReset(Loader<Cursor> loader) { 

     } 

     public void setQuery(Uri uri, String[] projection, String selection, String[] selectionArgs, String orderBy) { 
      this.uri = uri; 
      this.projection = projection; 
      this.selection = selection; 
      this.selectionArgs = selectionArgs; 
      this.orderBy = orderBy; 
     } 

     public boolean isFinished() { 
      return finished; 
     } 
    } 
} 

मैंने कक्षा का परीक्षण किया और ऐसा लगता है कि यह अपेक्षा करता है। आप इसे इस तरह का उपयोग कर सकते हैं:

JoinLoader loader = new JoinLoader(activity); 
loader.setFirstQuery(firstUri, firstProjection, firstSelection, firstSelectionArgs, firstOrderBy); 
loader.setSecondQuery(secondUri, secondProjection, secondSelection, secondSelectionArgs, secondOrderBy); 
loader.setJoinOn(leftColumns, rightColumns); 
loader.setJoinHandler(new JoinLoader.JoinHandler() { 
    @Override 
    public void onHandleJoin(CursorJoiner.Result result) { 
     switch (result) { 
      case LEFT: 
       ... 
       break; 

      case RIGHT: 
       ... 
       break; 

      case BOTH: 
       ... 
       break; 
     } 
    } 
}); 
loader.start(); 

मुझे आशा है कि मैं आपकी मदद कर सकता है, तो आपको कोई प्रश्न हैं, तो पूछने में संकोच न करें!