Wie kann man Model View Presenter unter Android übernehmen?

German (Deutsch) translation by Valentina (you can also view the original English article)

Im vorherigen Tutorial haben wir über das Model View Presenter-Muster gesprochen, wie es auf Android angewendet wird und was seine wichtigsten Vorteile sind. In diesem Tutorial untersuchen wir das Model View Presenter-Muster detaillierter, indem wir es in einer Android-Anwendung implementieren.

In diesem Tutorial:

wir erstellen eine einfache Anwendung mit dem MVP-Muster
wir untersuchen, wie das MVP-Muster auf Android implementiert wird
und wir diskutieren, wie einige Schwierigkeiten überwunden werden können, die durch die Android-Architektur verursacht werden

1. Model View Presenter

Das Model View Presenter-Muster ist ein Architekturmuster, das auf dem Model View Controller (MVC)-Muster basiert und die Trennung von Bedenken erhöht und das Testen von Einheiten erleichtert. Es werden drei Layers erstellt: Modell, Ansicht und Präsentator mit jeweils genau definierter Verantwortung.

Das Modell enthält die Geschäftslogik der Anwendung. Es steuert, wie Daten erstellt, gespeichert und geändert werden. Die Ansicht ist eine passive Oberfläche, die Daten anzeigt und Benutzeraktionen an den Präsentator weiterleitet. Der Moderator fungiert als Vermittler. Es ruft Daten aus dem Modell ab und zeigt sie in der Ansicht an. Es verarbeitet auch Benutzeraktionen, die von der Ansicht weitergeleitet werden.

2. Projektplanung und -einrichtung

Wir werden eine einfache Notizenanwendung erstellen, um MVP zu veranschaulichen. Mit der App kann der Benutzer Notizen machen, diese in einer lokalen Datenbank speichern und Notizen löschen. Zur Vereinfachung verfügt die App nur über eine Aktivität.

In diesem Tutorial konzentrieren wir uns hauptsächlich auf die Implementierung des MVP-Musters. Andere Funktionen, wie das Einrichten einer SQLite-Datenbank, das Erstellen eines DAO oder das Behandeln der Benutzerinteraktion, werden übersprungen. Wenn Sie Hilfe zu einem dieser Themen benötigen, bietet Envato Tuts+ einige großartige Tutorials zu diesen Themen.

Aktionsdiagramm und MVP-Layers

Beginnen wir mit der Erstellung einer neuen Notiz. Wenn wir diese Aktion in kleinere Operationen aufteilen, sieht der Ablauf anhand des MVP-Architekturmusters folgendermaßen aus:

Der Benutzer gibt eine Notiz ein und klickt auf die Schaltfläche Notiz hinzufügen.
Der Präsentator erstellt ein Note-Objekt mit dem vom Benutzer eingegebenen Text und fordert das Modell auf, es in die Datenbank einzufügen.
Das Modell fügt die Notiz in die Datenbank ein und informiert den Präsentator darüber, dass sich die Liste der Notizen geändert hat.
Der Präsentator löscht das Textfeld und fordert die Ansicht auf, die Liste zu aktualisieren, um die neu erstellte Notiz anzuzeigen.

MVP-Schnittstellen

Betrachten wir nun die Operationen, die erforderlich sind, um diese Aktion auszuführen, und trennen Sie sie mithilfe von MVP. Um die verschiedenen Objekte locker miteinander zu verbinden, erfolgt die Kommunikation zwischen den Layers über Schnittstellen. Wir brauchen vier Schnittstellen:

RequiredViewOps: Erforderlich Für Presenter verfügbare Ansichtsvorgänge
ProvidedPresenterOps: Vorgänge, die View zur Kommunikation mit Presenter angeboten werden
RequiredPresenterOps: Erforderliche Presenter-Vorgänge, die Model zur Verfügung stehen
ProvidedModelOps: Vorgänge, die Model zur Kommunikation mit Presenter angeboten werden

3. Implementierung von MVP unter Android

Nachdem wir eine Vorstellung davon haben, wie die verschiedenen Methoden organisiert werden sollen, können wir mit der Erstellung unserer App beginnen. Wir vereinfachen die Implementierung, indem wir uns nur auf die Aktion konzentrieren, um eine neue Notiz hinzuzufügen. Die Quelldateien dieses Tutorials sind auf GitHub verfügbar.

Wir verwenden nur eine Activity mit einem Layout, das Folgendes umfasst:

EditText für neue Notizen
Button zum Hinzufügen einer Notiz
RecyclerView, um alle Notizen aufzulisten
zwei TextView-Elemente und eine Button in einem RecyclerView-Halter

Schnittstellen

Beginnen wir mit der Erstellung der Schnittstellen. Um alles organisiert zu halten, platzieren wir die Schnittstellen in einem Halter. Auch in diesem Beispiel konzentrieren wir uns auf die Aktion zum Hinzufügen einer neuen Notiz.

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();
    }
}

View Layer

Jetzt ist es Zeit, die Layers Modell, Ansicht und Präsentator zu erstellen. Da MainActivity als Ansicht fungiert, sollte die RequiredViewOps-Schnittstelle implementiert werden.

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);
        }
    }
}

Presenter-Layer

Der Moderator ist der Mittelsmann und muss zwei Schnittstellen implementieren:

ProvidedPresenterOps, um Anrufe aus der Ansicht zuzulassen
RequiredPresenterOps, um Ergebnisse vom Modell zu erhalten

Achten Sie besonders auf die Ansichtslayerreferenz. Wir müssen eine WeakReference<MVP_Main.RequiredViewOps> verwenden, da MainActivity jederzeit zerstört werden kann und wir Speicherlecks vermeiden möchten. Außerdem wurde die Modellebene noch nicht eingerichtet. Das machen wir später, wenn wir die MVP-Layers miteinander verbinden.

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;

    }
}

Modell Layer

Die Modell Layer ist für die Verwaltung der Geschäftslogik verantwortlich. Es enthält eine ArrayList mit den zur Datenbank hinzugefügten Notizen, eine DAO-Referenz zum Ausführen von Datenbankoperationen und eine Referenz zum Presenter.

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. Alles zusammenbinden

Wenn die MVP-Layers vorhanden sind, müssen wir sie instanziieren und die erforderlichen Referenzen einfügen. Bevor wir dies tun, müssen wir einige Probleme ansprechen, die in direktem Zusammenhang mit Android stehen.

Instanziieren der Layers

Da Android die Instanziierung einer Activity nicht zulässt, wird die Ansichtslayer für uns instanziiert. Wir sind für die Instanziierung der Layers Presenter und Model verantwortlich. Leider kann das Instanziieren dieser Layers außerhalb der Activity problematisch sein.

Es wird empfohlen, eine Form der Abhängigkeitsinjektion zu verwenden, um dies zu erreichen. Da unser Ziel darin besteht, uns auf die MVP-Implementierung zu konzentrieren, werden wir einen einfacheren Ansatz verfolgen. Dies ist nicht der beste verfügbare Ansatz, aber am einfachsten zu verstehen. Wir werden später in dieser Serie über MVP und Abhängigkeitsinjektion sprechen.

instanziieren Sie den Präsentator und das Modell in der Aktivität mithilfe lokaler Variablen
richten Sie RequiredViewOps und ProvidedModelOps im Presenter ein
richten Sie RequiredPresenterOps im Modell ein
speichern Sie ProvidedPresenterOps als Referenz für die Ansicht

/**
* 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;
}

Umgang mit Konfigurationsänderungen

Eine andere Sache, die wir berücksichtigen sollten, ist der Lebenszyklus der Aktivität. Die Activity von Android kann jederzeit zerstört werden, und die Layers Präsentator und Modell können auch damit zerstört werden. Wir müssen dies beheben, indem wir eine Art Zustandsmaschine verwenden, um den Zustand während Konfigurationsänderungen zu speichern. Wir sollten auch die anderen Layers über den Status der Aktivität informieren.

Um dies zu erreichen, verwenden wir eine separate Klasse, StateMaintainer, die ein Fragment enthält, das seinen Status beibehält und dieses Fragment zum Speichern und Abrufen unserer Objekte verwendet. Sie können sich die Implementierung dieser Klasse in den Quelldateien dieses Tutorials ansehen.

Wir müssen dem Präsentator und dem Modell eine onDestroy-Methode hinzufügen, um sie über den aktuellen Status der Aktivität zu informieren. Wir müssen dem Präsentator auch eine setView-Methode hinzufügen, die für den Empfang einer neuen Ansichtsreferenz der neu erstellten Aktivität verantwortlich ist.

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);
        }
    }
    // …
}

Abschluss

Das MVP-Muster kann einige Probleme lösen, die durch die Standardarchitektur von Android verursacht werden. Es macht Ihren Code einfach zu warten und zu testen. Die Einführung von MVP mag zunächst schwierig aussehen, aber sobald Sie die Logik dahinter verstanden haben, ist der gesamte Prozess unkompliziert.

Sie können jetzt Ihre eigene MVP-Bibliothek erstellen oder eine bereits verfügbare Lösung wie Mosby oder simple-mvp verwenden. Sie sollten jetzt besser verstehen, was diese Bibliotheken hinter den Kulissen tun.

Wir sind fast am Ende unserer MVP-Reise. Im dritten und letzten Teil dieser Serie werden wir dem Mix Unit-Tests hinzufügen und unseren Code anpassen, um die Abhängigkeitsinjektion mit Dagger zu verwenden. Ich hoffe Sie dort zu sehen.

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	}