Problem updating Listactivity using a custom adapter

Question

I’m working on an app where I populate a ListActivity using data from a SQLite created by the program itself. When adding items in the database, the list is automatically updated, but when removing, the list is not updated.

I insert new items into a Activity separate from the main, but when deleting items, I do the same within a DialogFragment called from within the ListActivity. Here is my code:

package activities;

import adapters.ItemListAdapter;
import android.app.FragmentManager;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ListView;
import br.bravosix.historico.R;
import classes.Database;
import classes.ListItem;
import fragments.QuickViewFragment;

public class ActivityList extends ListActivity {

    ItemListAdapter adapter;


    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // carrega os itens salvos no banco de dados quando
        // a tela é criada
        loadItems();
    }

    // re-carrega os itens após o resumo da activity

    public void onResume() {
        super.onResume();
        loadItems();
    }


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


    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        if (id == R.id.menu_list_add) {
            // activity responsável por adicionar novos itens
            // ao banco de dados
            Intent addItem = new Intent(this, ActivityNewItem.class);
            startActivity(addItem);
            return true;
        }
        return super.onOptionsItemSelected(item);
    }


    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        ListItem item = (ListItem) l.getItemAtPosition(position);
        FragmentManager fm = getFragmentManager();
        QuickViewFragment quickView = QuickViewFragment.newInstance(item);
        quickView.show(fm, "tag_quick_view");
        // testei o notifyDataSetChanged aqui e não funcionou, o mesmo
        // ocorreu quando usei a função loadItems();
        adapter.notifyDataSetChanged();
    }

    public void loadItems() {
        Database db = new Database(this);
        adapter = new ItemListAdapter(this, db.readItems());
        setListAdapter(adapter);
    }
}

What I need to do to that, when the QuickViewFragment is closed, the list is updated?

Answer 1

I will suggest a solution to the problem of Fragment but I have another suggestion to improve the way you update your list on ActivityList.

From what I understand, you update the list whenever your Activity That includes the call to onResume resulting from the finalisation of ActivityNewItem, but there is a negative effect in this form due to the life cycle of the Activity. When your app goes into the background and comes back, you’ll go to BD needlessly.

In the case of Fragment there is no interference in the life cycle of the Activity then the onResume is not called. Nor is it good to call the notifyDataSetChanged because at that moment the Fragment will be displayed, and the user has not yet deleted the item, given the asynchronicity.

---

1. Updating the list after iteration with Quickviewfragment

In the method onListItemClick, i would make a small change. Pass a Listener for the Fragment (or leave the onAttach set it), so that at the end of the interaction (update, delete, any other), it calls the method to update the list.

The ActionListener in the code, is the form of communication (avoiding coupling) between the Fragment and the Activity. With the interface methods the Fragment may notify the Activity of the interactions made that require updating in the Activity.

It would look something like:

Class ActivityList:

public class ActivityList extends ListActivity implements QuickViewFragment.ActionListener {

// ... Codigo e mais codigo

    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        ListItem item = (ListItem) l.getItemAtPosition(position);
        FragmentManager fm = getFragmentManager();
        QuickViewFragment quickView = QuickViewFragment.newInstance(item);
        quickView.setActionListener(this);
        // Sendo generico, pois nao sei que acoes poderiam ocorrer no fragment 
        quickView.show(fm, "tag_quick_view");
        // Nao precisa do adapter.notifyDataSetChanged();
    }

    @Override
    public void onDelete(Item item) {
        atualizaLista(item);
        // O metodo atualiza pode ser de duas formas:
        // Ou ele remove o item da lista, sem ir no banco.
        // Ou ele atualiza toda a lista, select no banco.
    }

    // Demais metodos da interface

}

Class QuickViewFragment:

public class QuickViewFragment extends DialogFragment {

    private ActionListener mAl;

    @Override
    public View onCreateView(...) {
        // ...
    }

    public interface ActionListener {
        public void onDelete(...);
        public void onUpdate(...);
        // ... O que mais quiser
    }

    private void ActionListener al; // Getter/Setter suprimidos

    @Override
    public void onAttach(Activity a) {
        super.onAttach(a);

        if(a instanceof ActionListener) {
            mAl = (ActionListener) a;
        }

        // Apenas uma sugestão de uso, nao precisa ser assim...
    }

    @Override
    public void onDismiss(DialogInterface dialog) {
        if(al != null) {
            //Chamar alguma acao do Listener
        }

        super.onDismiss(dialog);
    }

    @Override
    public void onDestroyView(...) {
        al = null; // Evitar MemoryLeak
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        // ... Código

        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

        // ... Mais Código

        // Na configuracao do botao negativo (utilizar o ClickListener para chamar a Callback.
        builder.setNegativeButton(R.string.quickview_delete,
            new OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    // Codigo de deleção no BD...
                    if(mAl != null) {
                        mAl.onDelete(...);
                    }
                }
            }
        );
}

In the interface methods you would update your list.

The method onAttach belongs to the life cycle of Fragment, He is called when the Fragment is "attached" to Activity, before being added. I recommend reading the documentation on the life cycle of Fragment.

Already the method onDismiss is called when the Dialog of DialogFragment is being closed. Take a look at the documentation of the method DialogFragment.onDismiss(DialogInterface dialog).

2. Updating the list after return from Activitynewitem

When you call an Activity using Intent, there is an alternative way that indicates that you are expecting a result of the return of ActivityNewItem. The startActivityForResult (Intent intent, int requestCode), and to get the return you need to write the method onActivityResult (int requestCode, int resultCode, Intent data) of his ListActivity to know whether or not to update the list.

In the method onOptionsItemSelected of ListActivity I would make a small change:

public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();

    if (id == R.id.menu_list_add) {
        // activity responsável por adicionar novos itens
        // ao banco de dados
        Intent addItem = new Intent(this, ActivityNewItem.class);
        startActivityForResult(addItem, 999, null); // Guarde o numero 999 pra depois
        return true;
    }

    return super.onOptionsItemSelected(item);
}

And add this class method ListActivity:

protected void onActivityResult(int requestCode /* 999 */, int resultCode, Intent data) {
    if(requestCode == 999 && resultCode == RESULT_OK) {
        // Atualiza lista, pois o retorno foi positivo...
    }

    super.onActivityResult(...);
}

In the ActivityNewItem put something like:

@Override
public void finish() {
    if(houveAlteracao) { // Se houve alguma atualizacao nessa `Activity`
        setResult(RESULT_OK, dado);
        // Diz para a Activity que me chamou
        // Que houve uma alteracao de dados aqui...
    }

    super.finish();
}

I believe with this working, you don’t need to use the method onResume to update the list, unless some external app modifies your BD.

The answer was long, but I hope it helps...