Java 数据更改时刷新加载程序-android

我使用LoaderManager和CursorLoader从数据库中使用ContentProvider加载数据。 现在，初始载荷很好。我有一个列表视图，显示数据库中的所有行（仅名称字符串适配器）

现在，当我从数据库中添加/删除一行时，我想刷新ListView，以便它显示最近的更改

目前，每当提交更改时，我只是使用“restartLoader”方法重新启动加载程序，但我想询问是否有其他方法可以在不重新启动加载程序的情况下执行此操作

以下是我的活动类别代码： 包com.silverfix.phony.activities

import java.util.ArrayList;

import com.silverfix.phony.R;
import com.silverfix.phony.contentprovider.PhonyContentProvider;
import com.silverfix.phony.database.RingtonesTable;

import android.app.Activity;
import android.app.LoaderManager.LoaderCallbacks;
import android.content.ContentValues;
import android.content.CursorLoader;
import android.content.Intent;
import android.content.Loader;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.text.Editable;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.View.OnClickListener;
import android.view.View.OnCreateContextMenuListener;
import android.widget.AdapterView;
import android.widget.AdapterView.AdapterContextMenuInfo;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;

public class RingtonesActivity extends Activity implements LoaderCallbacks<Cursor>{

    private final int PICK_RINGTONE_CODE = 1;
    private final int CURSOR_LOADER_ID = 1;
    private final int EDIT_ID = 1;
    private final int DELETE_ID = 2;
    private String[] ContextCommands;
    private ArrayAdapter<String> adapter;
    private ArrayList<String> ringtones;
    private ListView listview;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ringtones);
        listview = (ListView) findViewById(R.id.list);
        Button add = (Button) findViewById(R.id.add_ringtone);
        add.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                Intent i = new Intent(
                        Intent.ACTION_PICK,
                        android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI);
                startActivityForResult(i, PICK_RINGTONE_CODE);
            }
        });
        fillData();
    }

    @Override
    protected void onActivityResult(int arg0, int arg1, Intent arg2) {
        super.onActivityResult(arg0, arg1, arg2);
        switch (arg0) {
        case 1: // PICK_RINGTONE_CODE
            if (arg1 == RESULT_OK) {
                Uri ringtoneURI = arg2.getData();
                String[] projection = { MediaStore.MediaColumns.DISPLAY_NAME };
                Cursor cursor = getContentResolver().query(ringtoneURI,
                        projection, null, null, null);
                cursor.moveToFirst();
                int column = cursor
                        .getColumnIndex(MediaStore.MediaColumns.DISPLAY_NAME);
                String displayName = cursor.getString(column);
                addRingtone(ringtoneURI, displayName);
                cursor.close();
            }
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.ringtones, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    private void fillData() {
        getLoaderManager().initLoader(CURSOR_LOADER_ID, null, this);
        ringtones = new ArrayList<String>();
        adapter = new ArrayAdapter<String>(this,
                android.R.layout.simple_list_item_1, ringtones);
        ContextCommands = getResources().getStringArray(R.array.commands);
        listview.setAdapter(adapter);
        listview.setOnItemClickListener(new OnItemClickListener() {

            @Override
            public void onItemClick(AdapterView<?> parent, View view,
                    int position, long id) {
                editRingtone();
            }
        });
        registerForContextMenu(listview);
        listview.setOnCreateContextMenuListener(new OnCreateContextMenuListener() {

            @Override
            public void onCreateContextMenu(ContextMenu menu, View v,
                    ContextMenuInfo menuInfo) {
                if (v.getId()==R.id.list) {
                    AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo)menuInfo;
                    menu.setHeaderTitle(ContextCommands[info.position]);
                    String[] menuItems = getResources().getStringArray(R.array.commands);
                    menu.add(Menu.NONE, EDIT_ID, 0, menuItems[0]);
                    menu.add(Menu.NONE, DELETE_ID, 0, menuItems[1]);
                  }
            }
        });
    }

    @Override
    public boolean onContextItemSelected(MenuItem item) {
        switch(item.getItemId()) {
        case EDIT_ID:
            editRingtone();
            return true;
        case DELETE_ID:
            String name = adapter.getItem(((AdapterContextMenuInfo) item.getMenuInfo()).position);
            getContentResolver().delete(PhonyContentProvider.RINGTONES_URI, RingtonesTable.COLUMN_NAME
                    + "='" + name + "'", null);
            return true;
        default:
            return super.onContextItemSelected(item);
        }
    }

    private void editRingtone() {
        Intent i = new Intent(
                Intent.ACTION_PICK,
                android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI);
        startActivityForResult(i, PICK_RINGTONE_CODE);
    }

    private void addRingtone(Uri uri, String name) {
        String[] projection = { RingtonesTable.COLUMN_NAME };
        Cursor cursor = getContentResolver().query(
                PhonyContentProvider.RINGTONES_URI, projection,
                RingtonesTable.COLUMN_NAME + "='"+name+"'", null, null);
        if (cursor.getCount() == 0) {
            ContentValues values = new ContentValues();
            values.put(RingtonesTable.COLUMN_NAME, name);
            values.put(RingtonesTable.COLUMN_URI, uri.toString());
            getContentResolver().insert(PhonyContentProvider.RINGTONES_URI,
                    values);
            getLoaderManager().restartLoader(CURSOR_LOADER_ID, null, this);
        } else {
            Toast.makeText(this, "You already picked that ringtone!",
                    Toast.LENGTH_LONG).show();
            cursor.close();
        }
    }

    @Override
    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
        String[] projection = {RingtonesTable.COLUMN_ID, RingtonesTable.COLUMN_NAME, RingtonesTable.COLUMN_URI};
        return new CursorLoader(this, PhonyContentProvider.RINGTONES_URI, projection, null, null, null);
    }

    @Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        swapCursor(data);
    }

    @Override
    public void onLoaderReset(Loader<Cursor> loader) {
        swapCursor(null);
    }

    private void swapCursor(Cursor cursor) {
        if(cursor != null) {
            cursor.moveToFirst();
            ringtones.clear();
            for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
                int column = cursor.getColumnIndex(RingtonesTable.COLUMN_NAME);
                ringtones.add(cursor.getString(column));
            }
            adapter.notifyDataSetChanged();
            cursor.close();
            return;
        }
        ringtones.clear();
        adapter.notifyDataSetChanged();
    }
}

import java.util.ArrayList；
导入com.silverfix.phony.R；
导入com.silverfix.phony.contentprovider.PhonyContentProvider；
导入com.silverfix.phony.database.RingtonesTable；
导入android.app.Activity；
导入android.app.LoaderManager.LoaderCallbacks；
导入android.content.ContentValues；
导入android.content.CursorLoader；
导入android.content.Intent；
导入android.content.Loader；
导入android.database.Cursor；
导入android.net.Uri；
导入android.os.Bundle；
导入android.provider.MediaStore；
导入android.text.Editable；
导入android.view.ContextMenu；
导入android.view.Menu；
导入android.view.MenuItem；
导入android.view.view；
导入android.view.ContextMenu.ContextMenuInfo；
导入android.view.view.OnClickListener；
导入android.view.view.OnCreateContextMenuListener；
导入android.widget.AdapterView；
导入android.widget.AdapterView.AdapterContextMenuInfo；
导入android.widget.AdapterView.OnItemClickListener；
导入android.widget.ArrayAdapter；
导入android.widget.Button；
导入android.widget.ListView；
导入android.widget.Toast；
公共类RingtonesActivity扩展活动实现LoaderCallbacks{
私人最终整数选择铃声代码=1；
私有最终整数游标\加载程序\ ID=1；
私有最终整数编辑_ID=1；
私有最终int DELETE_ID=2；
私有字符串[]上下文命令；
专用阵列适配器；
私人ArrayList铃声；
私有列表视图列表视图；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_铃声）；
listview=（listview）findViewById（R.id.list）；
按钮添加=（按钮）findViewById（R.id.add\u铃声）；
add.setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
意向i=新意向(
意向、行动、选择，
android.provider.MediaStore.Audio.Media.EXTERNAL\u CONTENT\u URI）；
startActivityForResult（i，选择铃声码）；
}
});
fillData（）；
}
@凌驾
ActivityResult上的受保护无效（int arg0、int arg1、Intent arg2）{
super.onActivityResult（arg0、arg1、arg2）；
开关（arg0）{
案例1://选择铃声码
如果（arg1==结果_确定）{
Uri ringtoneURI=arg2.getData（）；
字符串[]投影={MediaStore.MediaColumns.DISPLAY_NAME}；
Cursor Cursor=getContentResolver（）.query（ringtoneURI，
投影，空，空，空）；
cursor.moveToFirst（）；
int列=游标
.getColumnIndex（MediaStore.MediaColumns.DISPLAY_NAME）；
String displayName=cursor.getString（列）；
addRingtone（ringtoneURI，displayName）；
cursor.close（）；
}
}
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
getMenuInflater（）.充气（R.menu.ringtones，menu）；
返回true；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
int id=item.getItemId（）；
if（id==R.id.action\u设置）{
返回true；
}
返回super.onOptionsItemSelected（项目）；
}
私有void fillData（）{
getLoaderManager（）.initLoader（游标\u加载器\u ID，null，this）；
铃声=新的ArrayList（）；
适配器=新阵列适配器（此，
android.R.layout.simple_list_item_1，铃声）；
ContextCommands=getResources（）.getStringArray（R.array.commands）；
setAdapter（适配器）；
setOnItemClickListener（新的OnItemClickListener（）{
@凌驾
public void onItemClick（AdapterView父级、视图、，
内部位置，长id）{
编辑铃声（）；
}
});
registerForContextMenu（列表视图）；
setOnCreateContextMenuListener（新的OnCreateContextMenuListener（）{
@凌驾
public void onCreateContextMenu（ContextMenu，视图v，
上下文菜单信息（menuInfo）{
if（v.getId（）==R.id.list）{
AdapterView.AdapterContextMenuInfo信息=（AdapterView.AdapterContextMenuInfo）菜单信息；
menu.setHeaderTitle（ContextCommands[info.position]）；
字符串[]menuItems=getResources（）.getStringArray（R.array.commands）；
menu.add（menu.NONE，EDIT_ID，0，menuItems[0]）；
menu.add（menu.NONE，DELETE_ID，0，menuItems[1]）；
}
}
});
}
@凌驾
公共布尔值onContextItemSelected（MenuItem项）{
开关（item.getItemId（））{
案例编辑ID:
编辑铃声（）；
返回true；
案例编号：
字符串名称=adapter.getItem（（（AdapterContextMenuInfo）item.getMenuInfo（））.position）；
getContentResolver（）.delete（PhonyContentProvider.RINGTONES\u URI，RingtonesTable.COLUMN\u名称
+“=”“+name+””，空）；
返回true；
违约：
返回super.onContextItemSelected（项目）；
}
}
私有无效编辑