Как использовать два курсора и CursorJoiner в LoaderManager в android
у меня есть ContentProvider
, он имеет две таблицы 1. OnlineContacts
2. AllContacts
. Тогда у меня есть метод, в котором я запрашиваю обе таблицы и получаю их результирующее cursors
отдельно. А потом ... --18-->вступление их с помощью CursorJoiner
список Contacts
. Передача этого списка в my 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
. Я не знал, как спросить, почему. это слишком объяснимо.
2 ответов
используйте два загрузчика, по одному для каждого курсора. Когда один из них завершит загрузку, вызовите другой метод, который присоединится к ним, если оба загрузились.
// 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
}
}
я написал класс, который загружает две разные Cursors
С помощью LoaderManager
и возвращает 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();
Я надеюсь, что я мог помочь вам, если у вас есть какие-либо вопросы пожалуйста, не стесняйтесь спрашивать!