Cómo adoptar Model View Presenter en Android

Spanish (Español) translation by Elías Nicolás (you can also view the original English article)

En el tutorial anterior, hablamos sobre el modelo Model View Presenter, cómo se aplica en Android y cuáles son sus ventajas más importantes. En este tutorial, exploramos el patrón Model View Presenter con más detalle implementándolo en una aplicación de Android.

En este tutorial:

Construimos una aplicación simple usando el patrón MVP
Exploramos cómo implementar el patrón MVP en Android
Y discutimos cómo superar algunas dificultades causadas por la arquitectura de Android

1. Model View Presenter

El patrón Model View Presenter es un patrón arquitectónico basado en el patrón Model View Controller (MVC) que aumenta la separación de las preocupaciones y facilita las pruebas unitarias. Crea tres capas, Model, View y Presenter, cada una con una responsabilidad bien definida.

El Modelo contiene la lógica de negocio de la aplicación. Controla cómo se crean, almacenan y modifican los datos. View es una interfaz pasiva que muestra datos y dirige las acciones del usuario al presentador Presenter. El Presentador actúa como intermediario. Recupera datos del modelo y lo muestra en View. También procesa las acciones de usuario enviadas por la vista.

2. Planificación y configuración del proyecto

Vamos a construir una aplicación de notas sencilla para ilustrar MVP. La aplicación permite al usuario tomar notas, guardarlas en una base de datos local y eliminar notas. Para que sea sencillo, la aplicación tendrá una sola actividad.

En este tutorial, nos concentramos principalmente en la implementación del patrón MVP. Otras funciones, como la creación de una base de datos SQLite, la construcción de un DAO o el manejo de la interacción del usuario, se saltan. Si necesita ayuda con cualquiera de estos temas, Envato Tuts+ tiene algunos excelentes tutoriales sobre estos temas.

Diagrama de acción y capas MVP

Comencemos con la creación de una nueva nota. Si rompemos esta acción en operaciones más pequeñas, entonces este es el aspecto que tendría el flujo usando el patrón arquitectónico MVP:

El usuario escribe una nota y hace clic en el botón añadir nota.
El presentador crea un objeto Note con el texto introducido por el usuario y le pide al modelo que lo inserte en la base de datos.
El modelo inserta la nota en la base de datos e informa al presentador de que la lista de notas ha cambiado.
El presentador borra el campo de texto y le pide a la vista que actualice su lista para mostrar la nota recién creada.

Interfaces MVP

Consideremos ahora las operaciones necesarias para lograr esta acción y separarlas usando MVP. Para mantener los diversos objetos ligeramente acoplados, la comunicación entre las capas toma lugar utilizando interfaces. Necesitamos cuatro interfaces:

RequiredViewOps: necesario Ver operaciones disponibles para Presenter
ProvidedPresenterOps: operaciones ofrecidas a View para comunicación con Presenter
RequiredPresenterOps: requiere las operaciones de Presenter disponibles para Model
ProvidedModelOps: operaciones ofrecidas a Model para comunicarse con Presenter

3. Implementación de MVP en Android

Ahora que tenemos una idea de cómo los diversos métodos deben ser organizados, podemos comenzar a crear nuestra aplicación. Simplificamos la implementación concentrándonos únicamente en la acción para agregar una nueva nota. Los archivos fuente de este tutorial están disponibles en GitHub.

Utilizamos solamente una actividad Activity con un diseño que incluye:

EditText para nuevas notas
Button para añadir una nota
RecyclerView para listar todas las notas
Dos elementos TextView y un botón Button dentro de un contenedor de RecyclerView

Interfaces

Comencemos creando las interfaces. Para mantener todo organizado, ponemos las interfaces dentro de un titular. Una vez más, en este ejemplo nos centramos en la acción para agregar una nueva nota.

public interface MVP_Main {
    /**
     * Required View methods available to Presenter.
     * A passive layer, responsible to show data
     * and receive user interactions
     */
    interface RequiredViewOps {
      // View operations permitted to Presenter
		Context getAppContext();
        	Context getActivityContext();
		void notifyItemInserted(int layoutPosition);
        	void notifyItemRangeChanged(int positionStart, int itemCount);
    }

    /**
     * Operations offered to View to communicate with Presenter.
     * Processes user interactions, sends data requests to Model, etc.
     */
    interface ProvidedPresenterOps {
       	// Presenter operations permitted to View
		void clickNewNote(EditText editText);
            // setting up recycler adapter
            int getNotesCount();
            NotesViewHolder createViewHolder(ViewGroup parent, int viewType);
            void bindViewHolder(NotesViewHolder holder, int position);
    }

    /**
     * Required Presenter methods available to Model.
     */
    interface RequiredPresenterOps {
       	// Presenter operations permitted to Model
		Context getAppContext();
        	Context getActivityContext();
    }

    /**
     * Operations offered to Model to communicate with Presenter
     * Handles all data business logic.
     */
    interface ProvidedModelOps {
        	// Model operations permitted to Presenter
            int getNotesCount();
            Note getNote(int position);
		int insertNote(Note note);
        	boolean loadData();
    }
}

Capa View

Ahora es el momento de crear las capas Model, View y Presenter. Dado que MainActivity funcionará como View, debería implementar la interfaz RequiredViewOps.

public class MainActivity
        extends AppCompatActivity
    implements View.OnClickListener, MVP_Main.RequiredViewOps {

    private MVP_Main.ProvidedPresenterOps mPresenter;
    private EditText mTextNewNote;
    private ListNotes mListAdapter;

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.fab:{
                // Adds a new note
                mPresenter.clickNewNote(mTextNewNote);
            }
        }
    }
    @Override
    public Context getActivityContext() {
        return this;
    }

    @Override
    public Context getAppContext() {
        return getApplicationContext();
    }
    // Notify the RecyclerAdapter that a new item was inserted
    @Override
    public void notifyItemInserted(int adapterPos) {
        mListAdapter.notifyItemInserted(adapterPos);
    }
    // notify the RecyclerAdapter that items has changed
    @Override
    public void notifyItemRangeChanged(int positionStart, int itemCount){
        mListAdapter.notifyItemRangeChanged(positionStart, itemCount);
    }
    // notify the RecyclerAdapter that data set has changed
    @Override
    public void notifyDataSetChanged() {
        mListAdapter.notifyDataSetChanged();
    }
    // Recycler adapter
    // This class could have their own Presenter, but for the sake of
    // simplicity, will use only one Presenter.
    // The adapter is passive and all the processing occurs 
    // in the Presenter layer.
    private class ListNotes extends RecyclerView.Adapter<NotesViewHolder>       
    {
        @Override
        public int getItemCount() {
            return mPresenter.getNotesCount();
        }

        @Override
        public NotesViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            return mPresenter.createViewHolder(parent, viewType);
        }

        @Override
        public void onBindViewHolder(NotesViewHolder holder, int position) {
            mPresenter.bindViewHolder(holder, position);
        }
    }
}

Capa Presenter

El presentador es el intermediario y necesita implementar dos interfaces:

ProvidedPresenterOps para permitir llamadas desde la vista
RequiredPresenterOps para recibir resultados del modelo

Preste especial atención a la referencia de capa Ver. Necesitamos usar WeakReference<MVP_Main.RequiredViewOps> ya que MainActivity podría ser destruida en cualquier momento y queremos evitar pérdidas de memoria. Además, la capa de modelo aún no se ha configurado. Lo hacemos más tarde cuando conectamos las capas MVP.

public class MainPresenter implements MVP_Main.ProvidedPresenterOps, MVP_Main.RequiredPresenterOps {

    // View reference. We use as a WeakReference
    // because the Activity could be destroyed at any time
    // and we don't want to create a memory leak
    private WeakReference<MVP_Main.RequiredViewOps> mView;
    // Model reference
    private MVP_Main.ProvidedModelOps mModel;

    /**
     * Presenter Constructor
     * @param view  MainActivity
     */
    public MainPresenter(MVP_Main.RequiredViewOps view) {
        mView = new WeakReference<>(view);
    }

    /**
     * Return the View reference.
     * Throw an exception if the View is unavailable.
     */
    private MVP_Main.RequiredViewOps getView() throws NullPointerException{
        if ( mView != null )
            return mView.get();
        else
            throw new NullPointerException("View is unavailable");
    }

    /**
     * Retrieves total Notes count from Model
     * @return  Notes list size
     */
    @Override
    public int getNotesCount() {
        return mModel.getNotesCount();
    }

    /**
     * Creates the RecyclerView holder and setup its view
     * @param parent    Recycler viewGroup
     * @param viewType  Holder type
     * @return          Recycler ViewHolder
     */
    @Override
    public NotesViewHolder createViewHolder(ViewGroup parent, int viewType) {
        NotesViewHolder viewHolder;
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());

        View viewTaskRow = inflater.inflate(R.layout.holder_notes, parent, false);
        viewHolder = new NotesViewHolder(viewTaskRow);

        return viewHolder;
    }

    /**
     * Binds ViewHolder with RecyclerView
     * @param holder    Holder to bind
     * @param position  Position on Recycler adapter
     */
    @Override
    public void bindViewHolder(final NotesViewHolder holder, int position) {
        final Note note = mModel.getNote(position);
        holder.text.setText( note.getText() );
        holder.date.setText( note.getDate() );
        holder.btnDelete.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                clickDeleteNote(note, holder.getAdapterPosition(), holder.getLayoutPosition());
            }
        });

    }

    /**
     * @return  Application context
     */
    @Override
    public Context getAppContext() {
        try {
            return getView().getAppContext();
        } catch (NullPointerException e) {
            return null;
        }
    }

    /**
     * @return  Activity context
     */
    @Override
    public Context getActivityContext() {
        try {
            return getView().getActivityContext();
        } catch (NullPointerException e) {
            return null;
        }
    }

    /**
     * Called by View when user clicks on new Note button.
     * Creates a Note with text typed by the user and asks
     * Model to insert it in DB.
     * @param editText  EditText with text typed by user
     */
    @Override
    public void clickNewNote(final EditText editText) {
        getView().showProgress();
        final String noteText = editText.getText().toString();
        if ( !noteText.isEmpty() ) {
            new AsyncTask<Void, Void, Integer>() {
                @Override
                protected Integer doInBackground(Void... params) {
                    // Inserts note in Model, returning adapter position
                    return mModel.insertNote(makeNote(noteText));
                }

                @Override
                protected void onPostExecute(Integer adapterPosition) {
                    try {
                        if (adapterPosition > -1) {
                            // Note inserted
                            getView().clearEditText();
                            getView().notifyItemInserted(adapterPosition + 1);
                            getView().notifyItemRangeChanged(adapterPosition, mModel.getNotesCount());
                        } else {
                            // Informs about error
                            getView().hideProgress();
                            getView().showToast(makeToast("Error creating note [" + noteText + "]"));
                        }
                    } catch (NullPointerException e) {
                        e.printStackTrace();
                    }
                }
            }.execute();
        } else {
            try {
                getView().showToast(makeToast("Cannot add a blank note!"));
            } catch (NullPointerException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Creates a Note object with given text
     * @param noteText  String with Note text
     * @return  A Note object
     */
    public Note makeNote(String noteText) {
        Note note = new Note();
        note.setText( noteText );
        note.setDate(getDate());
        return note;

    }
}

Capa de modelo

La capa Modelo es responsable de manejar la lógica. Contiene una ArrayList con las notas agregadas a la base de datos, una referencia DAO para realizar operaciones de base de datos y una referencia al presentador.

public class MainModel implements MVP_Main.ProvidedModelOps {

    // Presenter reference
    private MVP_Main.RequiredPresenterOps mPresenter;
    private DAO mDAO;
    // Recycler data
    public ArrayList<Note> mNotes;

    /**
     * Main constructor, called by Activity during MVP setup
     * @param presenter Presenter instance
     */
    public MainModel(MVP_Main.RequiredPresenterOps presenter) {
        this.mPresenter = presenter;
        mDAO = new DAO( mPresenter.getAppContext() );
    }

     /**
     * Inserts a note on DB
     * @param note  Note to insert
     * @return      Note's position on ArrayList
     */
    @Override
    public int insertNote(Note note) {
        Note insertedNote = mDAO.insertNote(note);
        if ( insertedNote != null ) {
            loadData();
            return getNotePosition(insertedNote);
        }
        return -1;
    }

     /**
     * Loads all Data, getting notes from DB
     * @return  true with success
     */
    @Override
    public boolean loadData() {
        mNotes = mDAO.getAllNotes();
        return mNotes != null;
    }
     /**
     * Gets a specific note from notes list using its array position
     * @param position    Array position
     * @return            Note from list
     */
    @Override
    public Note getNote(int position) {
        return mNotes.get(position);
    }
     
    /**
     * Get ArrayList size
     * @return  ArrayList size
     */
    @Override
    public int getNotesCount() {
        if ( mNotes != null )
            return mNotes.size();
        return 0;
    }
}

4. Atar todo junto

Con las capas MVP en su lugar, necesitamos instanciarlas e insertar las referencias necesarias. Antes de hacerlo, tenemos que abordar algunos problemas que están directamente relacionados con Android.

Instanciar las capas

Debido a que Android no permite la creación de instancias de una actividad Activity, la capa de vista se instanciará para nosotros. Somos responsables de instanciar las capas del presentador y del modelo. Desafortunadamente, instanciar esas capas fuera de la Actividad Activity puede ser problemática.

Se recomienda utilizar una forma de inyección de dependencia para lograr esto. Dado que nuestro objetivo es concentrarnos en la implementación del MVP, tomaremos un enfoque más fácil. Este no es el mejor enfoque disponible, pero es el más fácil de entender. Discutiremos MVP y la inyección de la dependencia más adelante en esta serie.

Instanciar el Presentador y el Modelo en la Actividad usando variables locales
Configure RequiredViewOps y ProvidedModelOps en el presentador
Configure RequiredPresenterOps en el modelo
Guardar ProvidedPresenterOps como referencia para usar en la vista

/**
* Setup Model View Presenter pattern
*/
private void setupMVP() {
     // Create the Presenter
     MainPresenter presenter = new MainPresenter(this);
     // Create the Model
     MainModel model = new MainModel(presenter);
     // Set Presenter model
     presenter.setModel(model);
     // Set the Presenter as a interface
     mPresenter = presenter;
}

Manejo de cambios de configuración

Otra cosa que debemos considerar es el ciclo de vida de la actividad. La actividad de Android Activity podría ser destruida en cualquier momento y las capas de Presenter y Model también podrían ser destruidas con ella. Necesitamos solucionar esto usando algún tipo de máquina de estado para guardar el estado durante los cambios de configuración. También debemos informar a las otras capas sobre el estado de la Actividad.

Para lograr esto, utilizaremos una clase separada, StateMaintainer, que contiene un fragmento que mantiene su estado y utiliza este fragmento para guardar y recuperar nuestros objetos. Puedes echar un vistazo a la implementación de esta clase en los archivos de origen de este tutorial.

Necesitamos agregar un método onDestroy al Presentador y al Modelo para informarles sobre el estado actual de la Actividad. También debemos agregar un método setView al Presentador, el cual será responsable de recibir una nueva referencia View de la Actividad recreada.

public class MainActivity
        extends AppCompatActivity
    implements View.OnClickListener, MVP_Main.RequiredViewOps
{
    // …
    private void setupMVP() {
        // Check if StateMaintainer has been created
        if (mStateMaintainer.firstTimeIn()) {
            // Create the Presenter
            MainPresenter presenter = new MainPresenter(this);
            // Create the Model
            MainModel model = new MainModel(presenter);
            // Set Presenter model
            presenter.setModel(model);
            // Add Presenter and Model to StateMaintainer
            mStateMaintainer.put(presenter);
            mStateMaintainer.put(model);

            // Set the Presenter as a interface
            // To limit the communication with it
            mPresenter = presenter;

        }
        // get the Presenter from StateMaintainer
        else {
            // Get the Presenter
            mPresenter = mStateMaintainer.get(MainPresenter.class.getName());
            // Updated the View in Presenter
            mPresenter.setView(this);
        }
    }
    // …
}

Conclusión

El patrón MVP es capaz de resolver algunos problemas causados por la arquitectura predeterminada de Android. Hace que su código sea fácil de mantener y probar. La adopción de MVP puede parecer difícil al principio, pero una vez que entienda la lógica detrás de ella, todo el proceso es sencillo.

Ahora puede crear su propia biblioteca MVP o utilizar una solución que ya está disponible, como Mosby o simple-mvp. Ahora deberías entender mejor lo que estas bibliotecas están haciendo detrás de las escenas.

Estamos casi al final de nuestro viaje MVP. En la tercera y última parte de esta serie, agregaremos las pruebas unitarias a la mezcla y adaptaremos nuestro código para usar la inyección de dependencia con Dagger. Espero verte allí.

1	public class MainActivity
2	extends AppCompatActivity
3	implements View.OnClickListener, MVP_Main.RequiredViewOps {
4
5	private MVP_Main.ProvidedPresenterOps mPresenter;
6	private EditText mTextNewNote;
7	private ListNotes mListAdapter;
8
9	@Override
10	public void onClick(View v) {
11	switch (v.getId()) {
12	case R.id.fab:{
13	// Adds a new note
14	mPresenter.clickNewNote(mTextNewNote);
15	}
16	}
17	}
18	@Override
19	public Context getActivityContext() {
20	return this;
21	}
22
23	@Override
24	public Context getAppContext() {
25	return getApplicationContext();
26	}
27	// Notify the RecyclerAdapter that a new item was inserted
28	@Override
29	public void notifyItemInserted(int adapterPos) {
30	mListAdapter.notifyItemInserted(adapterPos);
31	}
32	// notify the RecyclerAdapter that items has changed
33	@Override
34	public void notifyItemRangeChanged(int positionStart, int itemCount){
35	mListAdapter.notifyItemRangeChanged(positionStart, itemCount);
36	}
37	// notify the RecyclerAdapter that data set has changed
38	@Override
39	public void notifyDataSetChanged() {
40	mListAdapter.notifyDataSetChanged();
41	}
42	// Recycler adapter
43	// This class could have their own Presenter, but for the sake of
44	// simplicity, will use only one Presenter.
45	// The adapter is passive and all the processing occurs
46	// in the Presenter layer.
47	private class ListNotes extends RecyclerView.Adapter<NotesViewHolder>
48	{
49	@Override
50	public int getItemCount() {
51	return mPresenter.getNotesCount();
52	}
53
54	@Override
55	public NotesViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
56	return mPresenter.createViewHolder(parent, viewType);
57	}
58
59	@Override
60	public void onBindViewHolder(NotesViewHolder holder, int position) {
61	mPresenter.bindViewHolder(holder, position);
62	}
63	}
64	}

1	public class MainPresenter implements MVP_Main.ProvidedPresenterOps, MVP_Main.RequiredPresenterOps {
2
3	// View reference. We use as a WeakReference
4	// because the Activity could be destroyed at any time
5	// and we don't want to create a memory leak
6	private WeakReference<MVP_Main.RequiredViewOps> mView;
7	// Model reference
8	private MVP_Main.ProvidedModelOps mModel;
9
10	/**
11	* Presenter Constructor
12	* @param view MainActivity
13	*/
14	public MainPresenter(MVP_Main.RequiredViewOps view) {
15	mView = new WeakReference<>(view);
16	}
17
18	/**
19	* Return the View reference.
20	* Throw an exception if the View is unavailable.
21	*/
22	private MVP_Main.RequiredViewOps getView() throws NullPointerException{
23	if ( mView != null )
24	return mView.get();
25	else
26	throw new NullPointerException("View is unavailable");
27	}
28
29	/**
30	* Retrieves total Notes count from Model
31	* @return Notes list size
32	*/
33	@Override
34	public int getNotesCount() {
35	return mModel.getNotesCount();
36	}
37
38	/**
39	* Creates the RecyclerView holder and setup its view
40	* @param parent Recycler viewGroup
41	* @param viewType Holder type
42	* @return Recycler ViewHolder
43	*/
44	@Override
45	public NotesViewHolder createViewHolder(ViewGroup parent, int viewType) {
46	NotesViewHolder viewHolder;
47	LayoutInflater inflater = LayoutInflater.from(parent.getContext());
48
49	View viewTaskRow = inflater.inflate(R.layout.holder_notes, parent, false);
50	viewHolder = new NotesViewHolder(viewTaskRow);
51
52	return viewHolder;
53	}
54
55	/**
56	* Binds ViewHolder with RecyclerView
57	* @param holder Holder to bind
58	* @param position Position on Recycler adapter
59	*/
60	@Override
61	public void bindViewHolder(final NotesViewHolder holder, int position) {
62	final Note note = mModel.getNote(position);
63	holder.text.setText( note.getText() );
64	holder.date.setText( note.getDate() );
65	holder.btnDelete.setOnClickListener(new View.OnClickListener() {
66	@Override
67	public void onClick(View v) {
68	clickDeleteNote(note, holder.getAdapterPosition(), holder.getLayoutPosition());
69	}
70	});
71
72	}
73
74	/**
75	* @return Application context
76	*/
77	@Override
78	public Context getAppContext() {
79	try {
80	return getView().getAppContext();
81	} catch (NullPointerException e) {
82	return null;
83	}
84	}
85
86	/**
87	* @return Activity context
88	*/
89	@Override
90	public Context getActivityContext() {
91	try {
92	return getView().getActivityContext();
93	} catch (NullPointerException e) {
94	return null;
95	}
96	}
97
98	/**
99	* Called by View when user clicks on new Note button.
100	* Creates a Note with text typed by the user and asks
101	* Model to insert it in DB.
102	* @param editText EditText with text typed by user
103	*/
104	@Override
105	public void clickNewNote(final EditText editText) {
106	getView().showProgress();
107	final String noteText = editText.getText().toString();
108	if ( !noteText.isEmpty() ) {
109	new AsyncTask<Void, Void, Integer>() {
110	@Override
111	protected Integer doInBackground(Void... params) {
112	// Inserts note in Model, returning adapter position
113	return mModel.insertNote(makeNote(noteText));
114	}
115
116	@Override
117	protected void onPostExecute(Integer adapterPosition) {
118	try {
119	if (adapterPosition > -1) {
120	// Note inserted
121	getView().clearEditText();
122	getView().notifyItemInserted(adapterPosition + 1);
123	getView().notifyItemRangeChanged(adapterPosition, mModel.getNotesCount());
124	} else {
125	// Informs about error
126	getView().hideProgress();
127	getView().showToast(makeToast("Error creating note [" + noteText + "]"));
128	}
129	} catch (NullPointerException e) {
130	e.printStackTrace();
131	}
132	}
133	}.execute();
134	} else {
135	try {
136	getView().showToast(makeToast("Cannot add a blank note!"));
137	} catch (NullPointerException e) {
138	e.printStackTrace();
139	}
140	}
141	}
142
143	/**
144	* Creates a Note object with given text
145	* @param noteText String with Note text
146	* @return A Note object
147	*/
148	public Note makeNote(String noteText) {
149	Note note = new Note();
150	note.setText( noteText );
151	note.setDate(getDate());
152	return note;
153
154	}
155	}

1	public class MainModel implements MVP_Main.ProvidedModelOps {
2
3	// Presenter reference
4	private MVP_Main.RequiredPresenterOps mPresenter;
5	private DAO mDAO;
6	// Recycler data
7	public ArrayList<Note> mNotes;
8
9	/**
10	* Main constructor, called by Activity during MVP setup
11	* @param presenter Presenter instance
12	*/
13	public MainModel(MVP_Main.RequiredPresenterOps presenter) {
14	this.mPresenter = presenter;
15	mDAO = new DAO( mPresenter.getAppContext() );
16	}
17
18	/**
19	* Inserts a note on DB
20	* @param note Note to insert
21	* @return Note's position on ArrayList
22	*/
23	@Override
24	public int insertNote(Note note) {
25	Note insertedNote = mDAO.insertNote(note);
26	if ( insertedNote != null ) {
27	loadData();
28	return getNotePosition(insertedNote);
29	}
30	return -1;
31	}
32
33	/**
34	* Loads all Data, getting notes from DB
35	* @return true with success
36	*/
37	@Override
38	public boolean loadData() {
39	mNotes = mDAO.getAllNotes();
40	return mNotes != null;
41	}
42	/**
43	* Gets a specific note from notes list using its array position
44	* @param position Array position
45	* @return Note from list
46	*/
47	@Override
48	public Note getNote(int position) {
49	return mNotes.get(position);
50	}
51
52	/**
53	* Get ArrayList size
54	* @return ArrayList size
55	*/
56	@Override
57	public int getNotesCount() {
58	if ( mNotes != null )
59	return mNotes.size();
60	return 0;
61	}
62	}