एंड्रॉइड 4.0.3 कर्सर एडाप्टर परिवर्तन पर ListView को पॉप्युलेट नहीं करता है कर्सर

Question

संपादित करें: मैंने इस संवाद के लिए अपना एक्सएमएल पोस्ट नहीं किया है।

<?xml version="1.0" encoding="utf-8"?> 
<RelativeLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:id="@+id/tag_layout" 
    android:orientation="vertical" 
    android:layout_height="wrap_content" 
    android:layout_width="@dimen/min_dialog_width" 
    android:padding="5dp" 
    android:animateLayoutChanges="true" 
    > 

<!-- Here is the view to show if the list is emtpy --> 
<TextView 
     android:id="@android:id/empty" 
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content" 
     android:padding="50dp" 
     android:textAppearance="?android:attr/textAppearanceMedium" 
     android:layout_centerInParent="true" 
     android:gravity="center" 
     android:text="@string/no_items" 
     android:visibility="invisible" 
     /> 

<ListView 
     android:id="@android:id/list" 
     android:layout_width="match_parent" 
     android:layout_height="wrap_content" 
     android:visibility="invisible" 
     /> 

<ProgressBar 
     android:id="@+id/tag_spin_progress_bar" 
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content" 
     android:layout_centerInParent="true" 
     android:indeterminate="true" 
     /> 

</RelativeLayout> 

मैं android.support.v4.CursorLoader और CursorAdapter उपयोग कर रहा हूँ और मैं इसे अपने कर्सर अद्यतन करने के लिए प्राप्त करने की कोशिश कर रहा हूँ। एंड्रॉइड 2.3.3 में यह ठीक काम करता है। हालांकि जब मैं इसे अपने 4.0.3 डिवाइस पर आज़माता हूं तो ListView रीफ्रेश नहीं होता है और मेरे एडाप्टर में नई व्यू विधि को कभी नहीं कहा जाता है। मुझे पता है कि कर्सर में डेटा है क्योंकि मैं इसे अपने 2.3.3 डिवाइस पर देख सकता हूं।

यदि मैं अपने डिवाइस को घुमाता हूं तो ListView दिखाता है कि मैं क्या चाहता हूं। मैंने ListView को अमान्य करने का प्रयास किया है लेकिन यह समस्या को हल नहीं करता है।

यदि मैं ListView के एडाप्टर को रीसेट नहीं करता हूं तो सूची खाली नहीं होती है, लेकिन यह अभी भी सूची को रीफ्रेश नहीं करती है।

मैं इन सब को एक विस्तारित अलर्टडिअलॉग के अंदर कर रहा हूं जो डायलॉग फ्रैगमेंट में एम्बेडेड है।

यहाँ पूरी क्लास

import android.app.AlertDialog; 
import android.content.Context; 
import android.content.DialogInterface; 
import android.content.res.Resources; 
import android.database.Cursor; 
import android.os.Bundle; 

import android.support.v4.app.LoaderManager; 
import android.support.v4.content.CursorLoader; 
import android.support.v4.content.Loader; 

import android.text.Editable; 
import android.text.TextWatcher; 
import android.util.Log; 
import android.view.LayoutInflater; 
import android.view.View; 
import android.view.inputmethod.InputMethodManager; 
import android.widget.*; 
import org.lds.ldssa.service.MLDatabase; 
import org.lds.ldssa.service.aws.Annotation; 

import java.io.Serializable; 
import java.util.Collection; 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 

public class TagDialog extends AlertDialog implements LoaderManager.LoaderCallbacks<Cursor>,AdapterView.OnItemClickListener { 

private static final String TAG = "ldssa.tagdialog"; 
public static final int TAGLOADERID = 0; 

// View Items 
private EditText mEditText; 
private ListView mListView; 
private TextView mEmptyView; 
private ProgressBar mProgressBar; 
private ImageButton mNewTagButton; 
private ImageButton mSortTagButton; 
private TextView mTitle; 
private String mTagTitle; 
private String mNewTagTitle; 

private Annotation mAnnotation; 
private ContentFragment mContentFragment; 

private boolean isNewTagView; 
private static final String KEY_NEWTAGVIEW = "new_tag_view"; 

private static final String POSITION_KEY = "TAG_POSITION"; 
private static final String Y_KEY = "TAG_Y"; 
private static final String SORT_KEY = "TAG_SORT"; 
private static final String CHECKED_STATE_KEY = "TAG_CHECKED_STATE"; 
private static final int NOT_SET = -1; 
private int mPosition; 
private int mY; 

private TagSuggestionAdapter mSuggestionAdapter; 
private TagListAdapter mTagAdapter; 

private MLDatabase mlDatabase; 
private boolean mSortAlpha; 
private HashMap<Long, CheckedState> mCheckedState; 

protected TagDialog(Context context) { 
    super(context); 
} 

public void onCreate(Bundle savedInstanceState){ 
    Context context = getContext(); 
    Resources r = context.getResources(); 

    final LayoutInflater inflater = LayoutInflater.from(context); 
    View view = inflater.inflate(R.layout.dialog_tag, null); 

    // Main parts of the view   
    mEditText = (EditText) view.findViewById(R.id.tag_new_tag); 
    mListView = (ListView) view.findViewById(android.R.id.list); 
    mProgressBar = (ProgressBar) view.findViewById(R.id.tag_spin_progress_bar); 
    mEmptyView = (TextView) view.findViewById(android.R.id.empty); 
    mEmptyView.setVisibility(View.INVISIBLE); 

    // Titlebar 
    View titleBar = inflater.inflate(R.layout.dialog_tag_title, null); 
    mNewTagButton = (ImageButton) titleBar.findViewById(R.id.tag_new_icon); 
    mSortTagButton = (ImageButton) titleBar.findViewById(R.id.tag_sort_icon); 
    mTitle = (TextView) titleBar.findViewById(R.id.tag_title); 
    mTagTitle = r.getString(R.string.tag_dialog_title); 
    mNewTagTitle = r.getString(R.string.tag_new_dialog_title); 
    this.setCustomTitle(titleBar); 

    // Buttons 
    final String OK = r.getString(R.string.ok); 
    final String CANCEL = r.getString(R.string.cancel); 
    this.setButton(BUTTON_POSITIVE, OK, new OnClickListener() { 
     @Override 
     public void onClick(DialogInterface dialog, int which) { /*Never Used*/}}); 
    this.setButton(BUTTON_NEGATIVE, CANCEL, new OnClickListener() { 
     @Override 
     public void onClick(DialogInterface dialog, int which) { /*Never Used*/}}); 

    // Setup Button Listeners 
    setOnShowListener(new OnShowListener() { 
     @Override 
     public void onShow(DialogInterface dialog) { 
      Button ok = getButton(BUTTON_POSITIVE); 
      ok.setOnClickListener(new View.OnClickListener() { 
       @Override 
       public void onClick(View v) { 
        if(isNewTagView){ 
         hideIMM(); 
         addNewTag(); 
         mEditText.setText(""); 
         setupTagDialog(); 
        } else { 
         Collection<CheckedState> changes = mCheckedState.values(); 
         boolean success = true; 
         MLDatabase db = getDatabase(); 
         db.beginAnnotationTransaction(); 
         for(CheckedState change : changes){ 
          if(!change.checked()){ 
           //Detag 
           db.detagAnnotation(mAnnotation.getDbKey(), change.tagID()); 
          } else { 
           mAnnotation.saveHighlightsToDatabase(db); 
           if(mAnnotation.getDbKey().intValue() != MLDatabase.NOT_SET_INT & 
             change.tagID() != MLDatabase.NOT_SET_INT){ 
            success = db.tagAnnotation(mAnnotation.getDbKey(), change.tagID(), change.changed()); 
           } 
          } 
         } 
         if(success){ 
          db.setAnnotationTransactionSuccessful(); 
         } 
         db.endAnnotationTransaction(); 
         mCheckedState.clear(); 
         dismiss(); 
        } 
       } 
      }); 

      Button cancel = getButton(BUTTON_NEGATIVE); 
      cancel.setOnClickListener(new View.OnClickListener() { 
       @Override 
       public void onClick(View v) { 
        if(isNewTagView){ 
         hideIMM(); 
         setupTagDialog(); 
         mEditText.setText(""); 
        } else { 
         mCheckedState.clear(); 
         dismiss(); 
        } 
       } 
      }); 
     } 
    }); 

    mNewTagButton.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      setupNewTagDialog(); 
     } 
    }); 
    mSortTagButton.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      mSortAlpha = !mSortAlpha; 
      restartLoader(); 
     } 
    }); 

    mListView.setOnItemClickListener(TagDialog.this); 

    mEditText.addTextChangedListener(new TextWatcher() { 
     @Override 
     public void beforeTextChanged(CharSequence s, int start, int count, int after) {} 

     @Override 
     public void onTextChanged(CharSequence s, int start, int before, int count) {} 

     @Override 
     public void afterTextChanged(Editable s) { 
      LoaderManager lm = getLoaderManager(); 
      if(lm != null){ 
       Loader l = lm.getLoader(TAGLOADERID); 
       if(l != null){ 
        l.forceLoad(); 
       } else { 
        restartLoader(); 
       } 
      } else { 
       restartLoader(); 
      } 
     } 
    }); 

    //Handle Rotations 
    if(savedInstanceState == null){ 
     //New 
     mPosition = NOT_SET; 
     mY = NOT_SET; 
     mSortAlpha = false; 
     mCheckedState = getCheckedState(mAnnotation.getDbKey()); 
     isNewTagView = false; 
    } else { 
     //rotated 
     isNewTagView = savedInstanceState.getBoolean(KEY_NEWTAGVIEW, false); 
     mPosition = savedInstanceState.getInt(POSITION_KEY, NOT_SET); 
     mY = savedInstanceState.getInt(Y_KEY, NOT_SET); 
     mSortAlpha = savedInstanceState.getBoolean(SORT_KEY, false); 
     restoreCheckedState(savedInstanceState); 
    } 

    mTagAdapter = new TagListAdapter(context, null, mCheckedState); 
    mSuggestionAdapter = new TagSuggestionAdapter(context, null, 0); 

    LoaderManager lm = getLoaderManager(); 
    if(lm != null){ 
     lm.initLoader(TAGLOADERID, null, this); 
    } 

    this.setView(view); 
    super.onCreate(savedInstanceState); 
} 

private void addNewTag() { 
    String tag = mEditText.getText().toString().trim(); 
    if(!tag.equals("")){ 
     getDatabase(); 
     Integer langID = mAnnotation.getLanguageId(); 
     try{ 
      long tagID = mlDatabase.insertTag(langID, tag); 
      if(mAnnotation.getDbKey().intValue() != MLDatabase.NOT_SET_INT && 
        tagID != MLDatabase.NOT_SET_INT){ 
       mCheckedState.put(tagID, new CheckedState(tagID, true, true)); 
      } 
     } catch (Exception e) { 
      Log.d(TAG, "Problem saving new tag: " + tag + " : " + e.getMessage()); 
      e.printStackTrace(); 
     } 
    } 
} 

public void onStart(){ 
    if(isNewTagView){ 
     setupNewTagDialog(); 
    } else { 
     setupTagDialog(); 
    } 
    restartLoader(); 
} 

@Override 
public Bundle onSaveInstanceState(){ 
    Bundle bundle = super.onSaveInstanceState(); 

    //Save What dialog we are in. 
    bundle.putBoolean(KEY_NEWTAGVIEW, isNewTagView); 
    bundle.putBoolean(SORT_KEY, mSortAlpha); 

    //Save position 
    bundle.putInt(POSITION_KEY, mListView.getFirstVisiblePosition()); 
    final View v = mListView.getChildAt(0); 
    bundle.putInt(Y_KEY, (v == null) ? 0 : v.getTop()); 

    //Save Checked State 
    Iterator it = mCheckedState.entrySet().iterator(); 
    int i = 0; 
    while(it.hasNext()){ 
     Map.Entry pair = (Map.Entry)it.next(); 
     bundle.putSerializable(CHECKED_STATE_KEY + i, (CheckedState)pair.getValue()); 
     i++; 
    } 
    bundle.putInt(CHECKED_STATE_KEY, i); 

    return bundle; 
} 

private void restoreCheckedState(Bundle bundle){ 
    int count = bundle.getInt(CHECKED_STATE_KEY); 
    mCheckedState = new HashMap<Long, CheckedState>(); 
    boolean success = true; 
    for(int i = 0; i < count; i++){ 
     CheckedState cs = (CheckedState)bundle.getSerializable(CHECKED_STATE_KEY+i); 
     if(cs == null){ 
      success = false; 
      break; 
     } 
     mCheckedState.put(cs.tagID(), cs); 
    } 
    if(!success){ 
     mCheckedState = getCheckedState(mAnnotation.getDbKey()); 
    } 
} 

@Override 
public void onBackPressed(){ 
    if(isNewTagView){ 
     hideIMM(); 
     setupTagDialog(); 
    } else { 
     this.dismiss(); 
    } 
} 

private void setupTagDialog() { 
    isNewTagView = false; 
    mTitle.setText(mTagTitle); 
    mNewTagButton.setVisibility(View.VISIBLE); 
    mSortTagButton.setVisibility(View.VISIBLE); 
    mEmptyView.setVisibility(View.INVISIBLE); 
    mEditText.setVisibility(View.GONE); 
    mListView.setVisibility(View.GONE); 
    mProgressBar.setVisibility(View.VISIBLE); 
    mListView.setAdapter(mTagAdapter); 
    restartLoader(); 
} 

private void setupNewTagDialog() { 
    isNewTagView = true; 
    mTitle.setText(mNewTagTitle); 
    mNewTagButton.setVisibility(View.INVISIBLE); 
    mSortTagButton.setVisibility(View.INVISIBLE); 
    mEmptyView.setVisibility(View.INVISIBLE); 
    mEditText.setVisibility(View.VISIBLE); 
    mListView.setVisibility(View.GONE); 
    mProgressBar.setVisibility(View.VISIBLE); 
    mListView.setAdapter(mSuggestionAdapter); 
    restartLoader(); 
} 

public void setAnnotation(Annotation a) { 
    mAnnotation = a; 
} 

public void setContentViewInterface(ContentFragment contentFragment) { 
    mContentFragment = contentFragment; 
} 

private MLDatabase getDatabase() { 
    if(mlDatabase == null){ 
     GospelLibraryApplication app = (GospelLibraryApplication) getContext().getApplicationContext(); 
     mlDatabase = app.getMlDatabase(); 
    } 
    return mlDatabase; 
} 

public String getFilter() { 
    return mEditText.getText().toString().trim(); 
} 

public Integer getAnnotationID(){ 
    if(mAnnotation != null){ 
     return mAnnotation.getDbKey(); 
    } 
    return MLDatabase.NOT_SET_INT; 
} 

private LoaderManager getLoaderManager(){ 
    if(mContentFragment == null){ 
     Log.d(TAG, "ContentFragment is NULL!"); 
     return null; 
    } 
    return mContentFragment.getContentActivity().getSupportLoaderManager(); 
} 

private void restartLoader(){ 
    LoaderManager lm = getLoaderManager(); 
    if(lm != null){ 
     lm.restartLoader(TAGLOADERID, null, this); 
    } 
} 

private void hideIMM(){ 
    InputMethodManager imm = (InputMethodManager)getContext().getSystemService(Context.INPUT_METHOD_SERVICE); 
    imm.hideSoftInputFromWindow(mEditText.getWindowToken(), 0); 
} 

private HashMap<Long, CheckedState> getCheckedState(Integer annotationID) { 
    HashMap<Long, CheckedState> checkedState = new HashMap<Long, CheckedState>(); 
    MLDatabase db = getDatabase(); 
    Cursor cursor = db.queryAllTagsWithAnnotation(annotationID); 
    if(cursor != null){ 
     for(cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()){ 
      Long tagID = cursor.getLong(cursor.getColumnIndex(MLDatabase.CL_ID)); 
      boolean isChecked = !cursor.isNull(cursor.getColumnIndex(MLDatabase.CL_ANNOTATION)); 
      checkedState.put(tagID, new CheckedState(tagID, isChecked, false)); 
     } 
    } 
    return checkedState; 
} 

@Override 
public Loader<Cursor> onCreateLoader(int id, Bundle args) { 
    TagCursorLoader loader = new TagCursorLoader(getContext(), this); 
    return loader; 
} 

@Override 
public void onLoadFinished(Loader<Cursor> cursorLoader, Cursor data) { 
    if(isNewTagView) { 
     mSuggestionAdapter.changeCursor(data); 
     if(mListView.getAdapter() == null){ 
      mListView.setAdapter(mSuggestionAdapter); 
     } 
    } else { 
     mTagAdapter.changeCursor(data); 
     if(mListView.getAdapter() == null){ 
      mListView.setAdapter(mTagAdapter); 
     } 
    } 
    if(mPosition != NOT_SET && mY != NOT_SET){ 
     mListView.setSelectionFromTop(mPosition, mY); 
     mPosition = mY = NOT_SET; 
    } 

    if (mListView.getAdapter() != null) { 
     if (mListView.getAdapter().getCount() > 0) { 
      mEmptyView.setVisibility(View.INVISIBLE); 
     } 
     else { 
      mEmptyView.setVisibility(View.VISIBLE); 
     } 
    } 
    else { 
     mEmptyView.setVisibility(View.VISIBLE); 
    } 
    mProgressBar.setVisibility(View.GONE); 
    mListView.setVisibility(View.VISIBLE); 
    mListView.invalidate(); 
} 

@Override 
public void onLoaderReset(Loader<Cursor> cursorLoader) { 
    if(mSuggestionAdapter != null) { 
     mSuggestionAdapter.changeCursor(null); 
    } 
} 

@Override 
public void onItemClick(AdapterView<?> parent, View view, int position, long id) { 
    if(isNewTagView){ 
     TextView tv = (TextView)view; 
     mEditText.setText(tv.getText()); 
     Button ok = getButton(BUTTON_POSITIVE); 
     if(ok != null){ 
      ok.performClick(); 
     } 
    } else { 
     CheckedTextView ctv = (CheckedTextView)view; 
     boolean checked = !ctv.isChecked(); 
     ctv.setChecked(checked); 
     mCheckedState.put(id, new CheckedState(id, checked, true)); 
    } 

} 

public static class TagCursorLoader extends CursorLoader { 
    private final ForceLoadContentObserver mObserver = new ForceLoadContentObserver(); 

    private TagDialog dialog; 
    private MLDatabase mlDatabase; 
    private Cursor mCursor; 
    private String mFilter; 
    private Integer mAnnotationID; 

    // Runs on worker thread 
    @Override 
    public Cursor loadInBackground(){ 
     Cursor cursor = null; 
     if(dialog.isNewTagView){ 
      mFilter = dialog.getFilter(); 
      cursor = mlDatabase.getTagSuggestions(mFilter); 
     } else { 
      cursor = mlDatabase.queryTags(dialog.mSortAlpha); 
     } 

     if(cursor != null){ 
      cursor.registerContentObserver(mObserver); 
     } 

     return cursor; 

    } 

    //Runs on UI thread 
    @Override 
    public void deliverResult(Cursor cursor){ 
     //Handle if canceled in the middle. 
     if(isReset()){ 
      if(cursor != null){ 
       cursor.close(); 
      } 
      return; 
     } 

     Cursor oldCursor = mCursor; 
     mCursor = cursor; 
     if(isStarted()) { 
      super.deliverResult(cursor); 
     } 

     if(oldCursor != null && !oldCursor.equals(cursor) && !oldCursor.isClosed()) { 
      oldCursor.close(); 
     } 
    } 

    public TagCursorLoader(Context context, TagDialog dialog) { 
     super(context); 
     this.dialog = dialog; 
     mlDatabase = dialog.getDatabase(); 
    } 

    @Override 
    public void onStartLoading(){ 
     if(mCursor == null) { 
      forceLoad(); 
     } else { 
      if(dialog.isNewTagView && mFilter.equals(dialog.getFilter())) { 
       deliverResult(mCursor); 
      } else { 
       forceLoad(); 
      } 
     } 
    } 

    @Override 
    protected void onStopLoading() { 
     // Attempt to cancel the current load task if possible. 
     cancelLoad(); 
    } 

    @Override 
    public void onCanceled(Cursor cursor) { 
     if (cursor != null && !cursor.isClosed()) { 
      cursor.close(); 
     } 
    } 

    @Override 
    protected void onReset() { 
     super.onReset(); 

     // Ensure the loader is stopped 
     onStopLoading(); 

     if (mCursor != null && !mCursor.isClosed()) { 
      mCursor.close(); 
     } 
     mCursor = null; 
    } 

} 

/** 
* Class is used to store the temporary checked state of the tags. 
*/ 
public class CheckedState implements Serializable { 
    private static final long serialVersionUID = 1263560458217339487L; 

    /** 
    * @serialField 
    */ 
    private long tagID; 
    /** 
    * @serialField 
    */ 
    private boolean checked; 
    /** 
    * @serialField 
    */ 
    private boolean changed; 

    /** 
    * Constructor for CheckedState. 
    * @param tagID The tag ID 
    * @param checked The Current Checked State 
    * @param changed Ture if changed in the dialog. False if pulling from database. 
    */ 
    public CheckedState(long tagID, boolean checked, boolean changed){ 
     this.tagID = tagID; 
     this.checked = checked; 
     this.changed = changed; 
    } 

    public long tagID(){ 
     return tagID; 
    } 

    public boolean checked() { 
     return checked; 
    } 

    public boolean changed() { 
     return changed; 
    } 
    } 
} 

Answer 1

नोट मैंने पहले अपना एक्सएमएल नहीं जोड़ा था। वह जगह है जहां समस्या रहती है।

andriod:animateLayoutChanges 

मुझे क्या करना है कोशिश कर रहा था के साथ काम नहीं करता।

एक बार जब मैंने इसे अपने एक्सएमएल से हटा दिया तो यह एक आकर्षण की तरह काम करता था।

Answer 2

सबसे उदाहरण है कि मैं देख रहा हूँ में है, तो आप एक बार अपने अनुकूलक उदाहरण बना सकते हैं और यह ListView जब आप दृश्य निर्मित हो जाने में निर्धारित करते हैं, और उसके बाद getLoaderManager().initLoader() कहते हैं।

// Prepare the loader. Either re-connect with an existing one, 
// or start a new one. 
getLoaderManager().initLoader(0, null, this); 

फिर onLoadFinished() विधि में आप swapCursor() जो स्वचालित रूप से ListView ताज़ा करता है कहते हैं।

// This is the Adapter being used to display the list's data. 
SimpleCursorAdapter mAdapter; 
... 

public void onLoadFinished(Loader<Cursor> loader, Cursor data) { 
    // Swap the new cursor in. (The framework will take care of closing the 
    // old cursor once we return.) 
    mAdapter.swapCursor(data); 
} 

ऊपर कोड Loaders प्रलेखन http://developer.android.com/guide/topics/fundamentals/loaders.html

अद्यतन से नकल किया गया था: क्रियाएँ और टुकड़े के लिए लोडर का उपयोग कर के बारे में दस्तावेज़ वार्ता, लेकिन संवाद का उपयोग कर उल्लेख नहीं है। मुझे लगता है कि अगर getLoaderManager() मौजूद है तो आप ठीक हैं, लेकिन यदि आप लोडर मैनेजर का उपयोग नहीं कर रहे हैं और आप लोडर मैन्युअल रूप से स्वयं चला रहे हैं, तो मुझे लगता है कि आपको यह सुनिश्चित करना होगा कि जब आप swapCursor() या setAdapter() कि आप इसे UI थ्रेड पर कर रहे हैं। कभी कभी सबसे आसान तरीका है यह सुनिश्चित करने के लिए, कॉल करने के लिए

getListView().post(new Runnable() { 
    public void run() { 
     // so the setAdapter() or swapCursor() here 
    } 
}); 

मैं मामलों अपने आप को जहाँ मैं पृष्ठभूमि में एक ListView नवीनीकृत किया है में चलाने की है और इसे अपडेट किया जा रहा जब तक मैं डिवाइस घुमाएं के रूप में प्रतिबिंबित नहीं करता है, क्योंकि है यूआई थ्रेड पर यूआई अपडेट नहीं किया गया था।