Cara Mengadopsi Model View Presenter di Android

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

Pada tutorial sebelumnya, kita berbicara tentang pola Model View Presenter, bagaimana penerapannya di Android, dan apa keuntungan terpentingnya. Dalam tutorial ini, kita mengeksplorasi pola Model View Presenter secara lebih rinci dengan menerapkannya di aplikasi Android.

Dalam tutorial ini:

kita membangun aplikasi sederhana dengan menggunakan pola MVP
kita mengeksplorasi bagaimana menerapkan pola MVP di Android
dan kita membahas bagaimana mengatasi beberapa kesulitan yang disebabkan oleh arsitektur Android

1. Model View Presenter

Pola Model View Presenter adalah pola arsitektural yang didasarkan pada pola Model View Controller (MVC) yang meningkatkan pemisahan kekhawatiran dan memfasilitasi pengujian unit. Ini menciptakan tiga lapisan, Model, View, dan Presenter, masing-masing memiliki tanggung jawab yang jelas.

Model memegang logika bisnis aplikasi. Ini mengontrol bagaimana data dibuat, disimpan, dan dimodifikasi. View adalah antarmuka pasif yang menampilkan data dan mengarahkan tindakan pengguna ke Presenter. Presenter bertindak sebagai perantara. Ini mengambil data dari Model dan menampilkannya di View. Ini juga memproses tindakan pengguna yang diteruskan oleh View.

2. Perencanaan Proyek & Penyiapan

Kita akan membuat aplikasi catatan sederhana untuk menggambarkan MVP. Aplikasi ini memungkinkan pengguna mencatat, menyimpannya di database lokal, dan menghapus catatan. Untuk membuatnya sederhana, aplikasi hanya akan memiliki satu Activity.

Layout AplikasiDalam tutorial ini, kita berkonsentrasi terutama pada implementasi pola MVP. Fungsi lainnya, seperti menyiapkan database SQLite, membangun DAO, atau menangani interaksi pengguna, dilewati. Jika Anda memerlukan bantuan untuk topik ini, Envato Tuts+ memiliki beberapa tutorial hebat tentang topik ini.

Diagram Action dan Lapisan MVP

Mari kita mulai dengan membuat catatan baru. Jika kita memecah tindakan ini menjadi operasi-operasi yang lebih kecil, maka inilah yang akan terlihat seperti menggunakan pola arsitektur MVP:

Pengguna mengetik catatan dan mengklik tombol tambah catatan.
Presenter membuat objek Note dengan teks yang dimasukkan oleh pengguna dan meminta Model untuk memasukkannya ke dalam database.
Model memasukkan catatan di database dan menginformasikan kepada Presenter bahwa daftar catatan telah berubah.
Presenter membersihkan field teks dan meminta View untuk menyegarkan daftar untuk menunjukkan catatan yang baru dibuat.

Antarmuka MVP

Sekarang mari kita pertimbangkan operasi yang dibutuhkan untuk mencapai tindakan ini dan memisahkan dengan menggunakan MVP. Untuk menjaga agar berbagai objek digabungkan secara longgar, komunikasi antar lapisan terjadi dengan menggunakan antarmuka. Kita membutuhkan empat antarmuka:

RequiredViewOps: diperlukan operasi View yang tersedia untuk Presenter
ProvidedPresenterOps: operasi ditawarkan ke View untuk berkomunikasi dengan Presenter
RequiredPresenterOps: diperlukan operasi Presenter yang tersedia untuk Model
ProvidedModelOps: operasi ditawarkan ke Model untuk berkomunikasi dengan Presenter

3. Menerapkan MVP di Android

Sekarang kita memiliki gagasan tentang bagaimana berbagai metode harus diatur, kita dapat mulai membuat aplikasi kita. Kita menyederhanakan pelaksanaannya dengan hanya berfokus pada tindakan untuk menambahkan catatan baru. File sumber dari tutorial ini tersedia di GitHub.

Kita hanya menggunakan satu Activity dengan tata letak yang meliputi:

EditText untuk catatan baru
Button untuk menambahkan catatan
RecyclerView untuk mencantumkan semua catatan
dua elemen TextView dan Button di dalam pemegang RecyclerView

Antarmuka

Mari kita mulai dengan membuat antarmukanya. Agar semuanya tetap teratur, kami menempatkan antarmuka di dalam holder. Sekali lagi, dalam contoh ini kita fokus pada tindakan untuk menambahkan catatan baru.

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

Lapisan View

Sekarang saatnya membuat lapisan Model, View, dan Presenter. Karena MainActivity akan bertindak sebagai View, seharusnya mengimplementasikan antarmuka 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);
        }
    }
}

Lapisan Presenter

Presenter adalah perantara dan perlu menerapkan dua antarmuka:

ProvidedPresenterOps untuk mengizinkan panggilan dari View
RequiredPresenterOps untuk menerima hasil dari Model

Beri perhatian khusus pada referensi lapisan View. Kita perlu menggunakan WeakReference<MVP_Main.RequiredViewOps> karena MainActivity dapat dihancurkan kapan saja dan kita ingin menghindari kebocoran memori. Juga, lapisan Model belum disiapkan. Kita melakukannya nanti saat kita menghubungkan lapisan MVP bersama-sama.

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;

    }
}

Lapisan Model

Lapisan Model bertanggung jawab untuk menangani logika bisnis. Ini memegang ArrayList dengan catatan yang ditambahkan ke database, referensi DAO untuk melakukan operasi database, dan referensi ke 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. Mengikat Segalanya Bersama-sama

Dengan lapisan MVP di tempat, kita perlu memberi instantiate dan memasukkan referensi yang diperlukan. Sebelum kita melakukannya, kita perlu membahas beberapa masalah yang terkait langsung dengan Android.

Instansiasi Lapisan-lapisannya

Karena Android tidak mengizinkan instansiasi Activity, lapisan View akan diinstansiasikan untuk kita. Kita bertanggung jawab untuk instansiasi lapisan Presenter dan Model. Sayangnya, instansiasi lapisan di luar Activity bisa menjadi masalah.

Dianjurkan untuk menggunakan bentuk injeksi ketergantungan untuk mencapai hal ini. Karena tujuan kita adalah berkonsentrasi pada implementasi MVP, kita akan mengambil pendekatan yang lebih mudah. Ini bukan pendekatan terbaik yang tersedia, tapi ini yang paling mudah dipahami. Kita akan membahas MVP dan injeksi ketergantungan nanti di serial ini.

instansiasi Presenter dan Model dalam Activity menggunakan variabel lokal
atur RequiredViewOps dan ProvidedModelOps di Presenter
atur RequiredPresenterOps di Model
simpan ProvidedPresenterOps sebagai referensi untuk digunakan di View

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

Menangani Perubahan Konfigurasi

Hal lain yang harus kita pertimbangkan adalah siklus hidup Activity. Activity Android dapat dihancurkan setiap saat dan lapisan Presenter dan Model juga bisa dihancurkan dengannya. Kita perlu memperbaikinya dengan menggunakan beberapa jenis keadaan mesin untuk menyimpan keadaan selama perubahan konfigurasi. Kita juga harus menginformasikan lapisan lain tentang status Activity.

Untuk mencapai hal ini, kita akan menggunakan kelas terpisah, StateMaintainer, yang berisi sebuah Fragment yang mempertahankan kondisinya dan menggunakan fragmen ini untuk menyimpan dan mengambil objek kita. Anda bisa melihat implementasi kelas ini di file sumber tutorial ini.

Kita perlu menambahkan metode onDestroy ke Presenter dan Model untuk memberi tahu mereka tentang status Activity saat ini. Kita juga perlu menambahkan metode setView ke Presenter, yang akan bertanggung jawab untuk menerima referensi View baru dari Activity yang diciptakan kembali.

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

Kesimpulan

Pola MVP mampu memecahkan beberapa masalah yang disebabkan oleh arsitektur bawaan Android. Itu membuat kode Anda mudah dipelihara dan diuji. Mengadopsi MVP mungkin terlihat sulit pada awalnya, tapi begitu Anda memahami logika di baliknya, keseluruhan proses itu mudah.

Anda sekarang bisa membuat perpustakaan MVP sendiri atau menggunakan solusi yang sudah tersedia, seperti Mosby atau simple-mvp. Anda sekarang seharusnya lebih memahami apa yang perpustakaan ini lakukan di belakang layar.

Kita hampir di akhir perjalanan MVP kita. Pada bagian ketiga dan terakhir dari seri ini, kami akan menambahkan pengujian unit ke dalam campuran dan menyesuaikan kode kita untuk menggunakan injeksi ketergantungan dengan Dagger. Saya berharap bisa bertemu Anda di sana.

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	}