从 SharedPreferences 中删除条目后未通知 OnSharedPreferenceChangeListener

Question

我一直在整理一个简单的 Android ListView 应用程序来自学 LoaderManagers 和 Loaders。该应用程序只是提供了一个加载器，当共享偏好更改时，它会通过 OnSharedPreferenceChangeListener 得到通知。

它有一个简单的 UI，带有一个 ListView 和两个按钮，一个用于添加首选项，一个用于删除所有共享的首选项。

我的活动是 ListActivity 的子类，并实现了 LoaderManager.LoaderCallbacks>。

我的加载器只是在共享首选项发生更改时通知活动。

我的问题是，当单击删除所有首选项按钮时，不会通知 OnSharedPreferenceChangeListener，而添加首选项会通知它。即使未通知侦听器，首选项被删除，因为随后单击添加首选项按钮会更新列表以显示单个列表条目。

这是代码（为简洁起见，省略了一些位）：

MainActivity.java

public class MainActivity extends ListActivity implements LoaderManager.LoaderCallbacks<List<String>>
{

private ListView listView;
private static final int LOADER_ID = 1;
private LoaderManager.LoaderCallbacks<List<String>> mCallbacks;
private ArrayAdapter<String> adapter;

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    setUpLoaderManager();

    ArrayList<String> values = new ArrayList<String>();
    adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, android.R.id.text1, values);

    listView = (ListView) findViewById(android.R.id.list);
    listView.setAdapter(adapter);
}

private void setUpLoaderManager()
{
    mCallbacks = this;
    LoaderManager lm = getLoaderManager();
    lm.initLoader(LOADER_ID, null, mCallbacks);
}

@Override
public void onLoadFinished(Loader<List<String>> loader, List<String> data)
{
    switch (loader.getId())
    {
        case LOADER_ID:
            adapter.clear();
            adapter.addAll(data);
            break;
    }
}

@Override
public Loader<List<String>> onCreateLoader(int id, Bundle args)
{
    return new SampleLoader(this);
}

public void addSharedPreference(View v)
{
    getSharedPreferences("someData", Context.MODE_PRIVATE).edit().putString(new Date().toString(), "hi").commit();
}

public void deleteSharedPreference(View v)
{
    SharedPreferences sharedPreferences = getSharedPreferences("someData", Context.MODE_PRIVATE);
    sharedPreferences.edit().clear().commit();
}

}

SampleLoader.java

public class SampleLoader extends AsyncTaskLoader<List<String>>

{
    private List<String> mData;

public SampleLoader(Context ctx)
{
    super(ctx);
}

@Override
public List<String> loadInBackground()
{
    List<String> data = new ArrayList<String>();

    SharedPreferences prefs = getContext().getSharedPreferences("someData", Context.MODE_PRIVATE);
    Map<String, String> currentPref = (Map<String, String>) prefs.getAll();

    if (currentPref.size() > 0)
    {
        for (Map.Entry<String, String> entry : currentPref.entrySet())
        {
            data.add(entry.getKey());
        }
    }
    return data;
}

@Override
public void deliverResult(List<String> data)
{
    if (isReset())
    {
        releaseResources(data);
        return;
    }

    List<String> oldData = mData;
    mData = data;

    if (isStarted())
    {
        super.deliverResult(data);
    }

    if (oldData != null && oldData != data)
    {
        releaseResources(oldData);
    }
}

@Override
protected void onStartLoading()
{
    if (mData != null)
    {
        deliverResult(mData);
    }

    if (mObserver == null)
    {
        mObserver = new SharedPrefsObserver(this, getContext());
    }

    if (takeContentChanged() || mData == null)
    {
        forceLoad();
    }
}

@Override
protected void onStopLoading()
{
    cancelLoad();
}

@Override
protected void onReset()
{
    onStopLoading();

    if (mData != null)
    {
        releaseResources(mData);
        mData = null;
    }

    if (mObserver != null)
    {
        mObserver = null;
    }
}

@Override
public void onCanceled(List<String> data)
{
    super.onCanceled(data);

    releaseResources(data);
}

private void releaseResources(List<String> data)
{
}

private SharedPrefsObserver mObserver;
}

SharedPrefsObserver.java

public class SharedPrefsObserver
{
    public static OnSharedPreferenceChangeListener listener;

    public SharedPrefsObserver(final SampleLoader sampleLoader, Context context)
    {
        final SharedPreferences prefs = context.getSharedPreferences("someData", Context.MODE_PRIVATE);

        listener = new OnSharedPreferenceChangeListener()
        {

            @Override
            public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
            {
                sampleLoader.onContentChanged();
            }
        };
        prefs.registerOnSharedPreferenceChangeListener(listener);
    }
}

activity_main.xml

<LinearLayout
    android:id="@+id/button_layout"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:layout_alignParentBottom="true"
    android:weightSum="2">

    <Button
        android:id="@+id/button_delete"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:onClick="deleteSharedPreference"
        android:text="Delete all preferences" >
    </Button>

    <Button
        android:id="@+id/button_add"
        android:layout_width="0dp"
        android:layout_weight="1"
        android:layout_height="wrap_content"
        android:onClick="addSharedPreference"
        android:text="Add new preference" >
    </Button>
</LinearLayout>

<ListView
    android:id="@android:id/list"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_above="@id/button_layout"
    android:layout_alignParentLeft="true">
</ListView>

这是我在删除首选项后不得不用来强制加载程序刷新数据的解决方法：

    public void deleteSharedPreference(View v)
{
    SharedPreferences sharedPreferences = getSharedPreferences("someData", Context.MODE_PRIVATE);
    sharedPreferences.edit().clear().commit();
    //dirty hack - sharedPreferences observer is not notified when preferences are removed so had to bypass it and call the loader manually
    getLoaderManager().getLoader(LOADER_ID).forceLoad();
}

那么，关于为什么删除首选项没有通知我的听众的任何想法？

Answer 1

sharedPreferences.edit().clear().commit() 在设计上不会通知侦听器。如果您想收到删除共享首选项的通知，则需要使用 remove(key) 而不是 clear()。

查看Androidsource，可以看到clear()和remove(key)的实现略有不同。 remove(key) 将密钥添加到由编辑器创建的私有 HashMap 对象以跟踪更改，clear() 只是设置一个标志并且不对 HashMap 对象进行任何更改。 SharedPreferences 私有方法NotifyListeners() 不尊重此标志，它只查看 HashMap 对象。所以调用clear()不会被监听器上报。

[编辑]： 删除密钥时，您也必须使用相同的 editor 实例来提交它：

SharedPreferences settings = getSharedPreferences("someData", MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.remove(myKey1);
editor.remove(myKey2);
...
editor.commit();