删除时Android OrmLite刷新列表

当列表中的项目被删除时，我正在尝试刷新视图。我当前正在尝试刷新/重新加载AsyncTask的onPostExecute方法中的视图。到目前为止，我尝试过的都没有成功。这似乎是一项容易完成的任务。我的自定义适配器扩展了BaseAdapter。我希望我错过了一些简单的东西。有人能发光吗

干杯

public class ItemListActivity extends OrmLiteBaseListActivity<DatabaseHelper>  {

    private final String TAG = getClass().getSimpleName();
    private DatabaseHelper dbHelper;
    private ListView itemListView;
    private ItemListAdapter listAdapter;
    /** Called when the activity is first created. */

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.itemslistactivity);
        registerForContextMenu(getListView());
        itemListView = getListView();     
        itemListView.setOnCreateContextMenuListener(new OnCreateContextMenuListener() {
            public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
                MenuInflater inflater = getMenuInflater();
                inflater.inflate(R.menu.listview_context_menu, menu);
            }           
        });
        listAdapter = new ItemListAdapter(getApplicationContext(), new ArrayList<Item>());
        itemListView.setAdapter(listAdapter);

        dbHelper = getHelper();
        new SelectDataTask().execute(dbHelper);

    }

    public void add_OnClick(View v) {
         Intent intent = new Intent();
         intent.setClass(this, AddItemActivity.class);
         startActivity(intent);
    }



    @Override
    public boolean onContextItemSelected(MenuItem item) {
        AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
        Item b = (Item) listAdapter.getItem(info.position);
        try {
            switch (item.getItemId()) {
                case R.id.remove_item:          
                    dbHelper.getItemDao().deleteById(new Integer(b.id));
                    listAdapter.notifyDataSetChanged();
                    return true;
            }
        } catch (SQLException e) {
            //FIXME
            e.printStackTrace();
            Log.e(TAG, e.getMessage());
        }
        return false;
    }

    private class SelectDataTask extends AsyncTask<DatabaseHelper, Void, List<Item>> {
        private final ProgressDialog dialog = new ProgressDialog(
                ItemListActivity.this);

        // can use UI thread here
        protected void onPreExecute() {
            this.dialog.setMessage("Retreiving item data...");
            this.dialog.show();
        }

        @Override
        protected List<Item> doInBackground(DatabaseHelper... params) {
            List<Item> l = null;
            try {
                Dao<Item, Integer> dao = params[0].getItemDao();
                l = dao.queryForAll();
            } catch (SQLException e) {
                //TODO -- cleanup
                e.printStackTrace();
                Log.e(TAG, e.getMessage());
            }
            return l;
        }

        // can use UI thread here
        @Override
        protected void onPostExecute(List<Item> b) {
            listAdapter = new MyListAdapter(getApplicationContext(), b);
            itemListView.setAdapter(listAdapter);
            //TODO -- none of this works
            itemListView.invalidateViews();
            listAdapter.notifyDataSetChanged();
            if (this.dialog.isShowing()) {
                this.dialog.dismiss();
            }

        }
    }

公共类ItemListActivity扩展了OrmListBaseListActivity{
私有最终字符串标记=getClass（）.getSimpleName（）；
私有数据库助手dbHelper；
私有ListView项目ListView；
私有项目列表适配器列表适配器；
/**在首次创建活动时调用*/
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.itemslistactivity）；
registerForContextMenu（getListView（））；
itemListView=getListView（）；
setOnCreateContextMenuListener（新的OnCreateContextMenuListener（）{
public void onCreateContextMenu（ContextMenu菜单、视图v、ContextMenuInfo菜单信息）{
MenuInflater充气机=getMenuInflater（）；
充气器。充气（R.menu.listview\u上下文菜单，菜单）；
}           
});
listAdapter=new ItemListAdapter（getApplicationContext（），new ArrayList（））；
setAdapter（listAdapter）；
dbHelper=getHelper（）；
新建SelectDataTask（）.execute（dbHelper）；
}
公共无效添加单击（视图v）{
意图=新意图（）；
intent.setClass（这个，AddItemActivity.class）；
星触觉（意向）；
}
@凌驾
公共布尔值onContextItemSelected（MenuItem项）{
AdapterContextMenuInfo信息=（AdapterContextMenuInfo）项。getMenuInfo（）；
项目b=（项目）listAdapter.getItem（信息位置）；
试一试{
开关（item.getItemId（））{
案例R.id.移除项目：
dbHelper.getItemDao（）.deleteById（新整数（b.id））；
listAdapter.notifyDataSetChanged（）；
返回true；
}
}捕获（SQLE异常）{
//修理工
e、 printStackTrace（）；
Log.e（标记，e.getMessage（））；
}
返回false；
}
私有类SelectDataTask扩展了AsyncTask{
private final ProgressDialog dialog=新建ProgressDialog(
ItemListActivity.this）；
//可以在这里使用UI线程
受保护的void onPreExecute（）{
this.dialog.setMessage（“检索项目数据…”）；
this.dialog.show（）；
}
@凌驾
受保护列表doInBackground（DatabaseHelper…参数）{
列表l=空；
试一试{
Dao Dao=params[0]。getItemDao（）；
l=dao.queryForAll（）；
}捕获（SQLE异常）{
//待办事项——清理
e、 printStackTrace（）；
Log.e（标记，e.getMessage（））；
}
返回l；
}
//可以在这里使用UI线程
@凌驾
受保护的void onPostExecute（列表b）{
listAdapter=新的MyListAdapter（getApplicationContext（），b）；
setAdapter（listAdapter）；
//TODO——这些都不起作用
itemListView.invalidateViews（）；
listAdapter.notifyDataSetChanged（）；
if（this.dialog.isShowing（））{
this.dialog.disclose（）；
}
}
}

检查我的解决方案（组积垢）：

公共类组ReferenceActivity扩展了BaseAppActivity{
私有数据库助手dbHelper；
私有列表视图列表视图；
私有组适配器组适配器；
私有数据库模型；
私有OnDeleteListener OnDeleteListener；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.group\u preference\u布局）；
setDbHelper（新的DatabaseHelper（getApplicationContext（））；
setGroupModel（新数据库模型（getDbHelper（），GroupData.class））；
setListView（（ListView）findViewById（R.id.lv_组））；
setGroupAdapter（新的GroupAdapter（groupsReferenceActivity.this））；
getListView（）.setAdapter（getGroupAdapter（））；
setOnDeleteListener（新的OnDeleteListener（）{
@凌驾
公共void onClick（GroupData组）{
removeGroup（组）；
}
});
getListView（）.setOnItemClickListener（新的OnItemClickListener（））{
@凌驾
公共单击（适配器视图适配器、视图父级、，
内部位置，长id）{
addGroup（getGroupAdapter（）.getItem（位置））；
}
});
getGroupAdapter（）.setOnDeleteListener（getOnDeleteListener（））；
doLoadGroups（）；
}
私有void doLoadGroups（）{
getGroupAdapter（）.clear（）；
列表项=getGroupModel（）.getAll（）；
用于（对象组：项）{
getGroupAdapter（）.add（（GroupData）组）；
}
getGroupAdapter（）.notifyDataSetChanged（）；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
super.onCreateOptions菜单（菜单）；
getSupportMenuInflater（）.充气（R.menu.groups\u preference\u菜单，菜单）；
返回true；
}
@凌驾
公共布尔值onMenuItemSelected（int-featureId，MenuItem项）{
super.onMenuItemSelected（featureId，item）；
开关（item.getItemId（））{
案例R.id.选项\项目\添加\组：
addGroup（）；
打破
违约：
打破
}
返回true；
}
私有void addGroup（）{
addGroup（null）；
}
私有void addGroup（最终GroupData GroupData）{
LayoutInflater工厂=LayoutInflater工厂
.来自（Gr
public class GroupsPreferenceActivity extends BaseAppActivity {
    private DatabaseHelper dbHelper;
    private ListView listView;
    private GroupAdapter groupAdapter;
    private DatabaseModel groupModel;
    private OnDeleteListener onDeleteListener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.group_preference_layout);
        setDbHelper(new DatabaseHelper(getApplicationContext()));
        setGroupModel(new DatabaseModel(getDbHelper(), GroupData.class));
        setListView((ListView) findViewById(R.id.lv_group));
        setGroupAdapter(new GroupAdapter(GroupsPreferenceActivity.this));
        getListView().setAdapter(getGroupAdapter());
        setOnDeleteListener(new OnDeleteListener() {
            @Override
            public void onClick(GroupData group) {
                removeGroup(group);
            }
        });
        getListView().setOnItemClickListener(new OnItemClickListener() {

            @Override
            public void onItemClick(AdapterView<?> adapter, View parent,
                    int position, long id) {
                addGroup(getGroupAdapter().getItem(position));
            }
        });
        getGroupAdapter().setOnDeleteListener(getOnDeleteListener());
        doLoadGroups();
    }

    private void doLoadGroups() {
        getGroupAdapter().clear();
        List<?> items = getGroupModel().getAll();
        for (Object group : items) {
            getGroupAdapter().add((GroupData) group);
        }
        getGroupAdapter().notifyDataSetChanged();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        getSupportMenuInflater().inflate(R.menu.groups_preference_menu, menu);
        return true;
    }

    @Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        super.onMenuItemSelected(featureId, item);
        switch (item.getItemId()) {
        case R.id.option_item_add_group:
            addGroup();
            break;

        default:
            break;
        }
        return true;
    }

    private void addGroup() {
        addGroup(null);
    }

    private void addGroup(final GroupData groupData) {
        LayoutInflater factory = LayoutInflater
                .from(GroupsPreferenceActivity.this);
        final View textEntryView = factory.inflate(
                R.layout.create_group_dialog_view, null);
        final EditText editName = (EditText) textEntryView
                .findViewById(R.id.tv_group_name);
        String positiveButtonName = getString(R.string.create);
        OnClickListener positiveListener = new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int id) {
                createGroup(editName.getText().toString());
            }
        };
        if (groupData != null) {
            positiveButtonName = getString(R.string.update);
            editName.setText(groupData.getName());
            positiveListener = new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    groupData.setName(editName.getText().toString());
                    updateGroup(groupData);
                }
            };
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(
                GroupsPreferenceActivity.this);
        String title = getString(R.string.preference_add_group);

        builder.setCancelable(true)
                .setTitle(title)
                .setView(textEntryView)
                .setPositiveButton(positiveButtonName, positiveListener)
                .setNegativeButton(getString(R.string.cancel),
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                dialog.cancel();
                            }
                        });
        final AlertDialog alert = builder.create();
        alert.show();
        final Button yesButton = alert.getButton(Dialog.BUTTON_POSITIVE);
        yesButton.setEnabled(false);
        editName.addTextChangedListener(new TextWatcher() {

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

            @Override
            public void beforeTextChanged(CharSequence s, int start, int count,
                    int after) {

            }

            @Override
            public void afterTextChanged(Editable s) {
                yesButton.setEnabled(s.length() > 0);
            }
        });
    }

    protected void updateGroup(GroupData groupData) {
        getGroupModel().update(groupData);
        doLoadGroups();
    }

    protected void createGroup(String name) {
        GroupData groupData = new GroupData();
        groupData.setName(name);
        getGroupModel().add(groupData);
        doLoadGroups();
    }

    protected void removeGroup(GroupData group) {
        getGroupModel().remove(group);
        doLoadGroups();
    }

    public DatabaseHelper getDbHelper() {
        return dbHelper;
    }

    public void setDbHelper(DatabaseHelper dbHelper) {
        this.dbHelper = dbHelper;
    }

    public ListView getListView() {
        return listView;
    }

    public void setListView(ListView listView) {
        this.listView = listView;
    }

    public GroupAdapter getGroupAdapter() {
        return groupAdapter;
    }

    public void setGroupAdapter(GroupAdapter groupAdapter) {
        this.groupAdapter = groupAdapter;
    }

    public DatabaseModel getGroupModel() {
        return groupModel;
    }

    public void setGroupModel(DatabaseModel groupModel) {
        this.groupModel = groupModel;
    }

    public OnDeleteListener getOnDeleteListener() {
        return onDeleteListener;
    }

    public void setOnDeleteListener(OnDeleteListener onDeleteListener) {
        this.onDeleteListener = onDeleteListener;
    }
}