MVP Pattern in Android Using Kotlin

What is MVP?
The Model, View, Presenter pattern was based off the well known MVC pattern. It was created to alleviate the problem that often arises in the development of an android application.  In android, what often happens is that the business logic of the app is coupled with the code that handles the UI. In a lot of cases, this leads to the creation of "God objects" which greatly reduces testability and maintainability.

Basically, what MVP does is separate the UI codes and the logic, which is placed in a preferably POJO called Presenter. This effectively enables us to test our application logic without worrying about the other components. That's pretty much the gist of it. I won't dive into the topic too much, but if you want to read more about it, head over to this link.

To demonstrate this, I'll be creating a GWA(General Weighted Average) calculator app that is going to calculate my overall semester grade.

First we need to define the responsibilities of each component.

	class Contract{
	interface View{
	fun showTable(courses: MutableList<Course>)
	fun updateGWA(gwa: Double)
	fun showDeletePrompt(course: Course)
	fun showInput()
	}
	interface Actions{
	fun computeGWA()
	fun loadCourses()
	fun getCourse(courseCode: String): Course
	fun addCourse(course: Course)
	fun removeCourse(course: Course)
	fun updateCourse(course: Course)
	fun onAddCourseClick(course: Course)
	fun onChangeGrade(course: Course)
	}
	interface Repository{
	fun getCourse(courseCode: String): Course
	fun getAllCourse(): MutableList<Course>
	fun addCourse(course: Course): Boolean
	fun removeCourse(course: Course)
	fun updateCourse(course: Course)
	}
	}

view raw Contract.kt hosted with ❤ by GitHub

Then we define our Presenter object to contain all of the logic. Make sure to implement the contract so we know what methods we need to override.

	class GWACalcPresenter(val view: Contract.View, val repo: Contract.Repository) : Contract.Actions{
	override fun computeGWA(){
	val courses = repo.getAllCourse()
	val sum = courses.sumByDouble { it.grade * it.units }
	val totalUnits = courses.sumBy { it.units }
	var gwa = sum/totalUnits
	if(gwa.isNaN())
	gwa = 0.0
	view.updateGWA(gwa)
	}
	override fun loadCourses() {
	val courses = repo.getAllCourse()
	view.showTable(courses)
	}
	override fun onAddCourseClick(course: Course) {
	view.showInput()
	}
	override fun addCourse(course: Course) {
	repo.addCourse(course)
	loadCourses()
	}
	override fun getCourse(courseCode: String): Course {
	return repo.getCourse(courseCode)
	}
	override fun removeCourse(course: Course) {
	repo.removeCourse(course)
	loadCourses()
	computeGWA()
	}
	override fun updateCourse(course: Course) {
	repo.updateCourse(course)
	}
	override fun onChangeGrade(course: Course) {
	updateCourse(course)
	}
	}

view raw GWACalcPresenter.kt hosted with ❤ by GitHub

Next, we create the View component that will handle all of the UI.

	class MainActivity : AppCompatActivity(), Contract.View{
	lateinit var mPresenter: Contract.Actions
	override fun onCreate(savedInstanceState: Bundle?) {
	super.onCreate(savedInstanceState)
	setContentView(R.layout.activity_main)
	mPresenter = GWACalcPresenter(this, CourseRepository(this))
	mPresenter.loadCourses()
	fab.setOnClickListener {
	showInput()
	}
	}
	override fun updateGWA(gwa: Double) {
	gwaValue.text = getString(R.string.gwa_format).format(gwa)
	}
	override fun showInput() {
	alert {
	title = "Add Course"
	val view = layoutInflater.inflate(R.layout.input_layout, null)
	customView = view
	positiveButton("Add"){
	val courseCode = view.courseCodeInput.text.toString()
	val units = view.unitInputDropDown.selectedItem.toString().toInt()
	val grade = view.gradesInputDropDown.selectedItem.toString().toDouble()
	mPresenter.addCourse(Course(courseCode, units, grade))
	}
	negativeButton("Cancel"){}
	}.show()
	}
	override fun showDeletePrompt(course: Course) {
	alert {
	title = "Delete Course?"
	positiveButton("Cancel"){}
	negativeButton("Delete"){
	mPresenter.removeCourse(course)
	}
	}.show()
	}
	override fun showTable(courses: MutableList<Course>) {
	courseList.layoutManager = LinearLayoutManager(this)
	courseList.adapter = RecyclerAdapter(courses) {}
	}
	}

view raw MainActivity.kt hosted with ❤ by GitHub

And lastly we implement the object that will handle all of the Model transactions.

	class CourseRepository(mContext: Context) : Contract.Repository {
	val database = DbHelper.getInstance(mContext)
	override fun getCourse(courseCode: String): Course {
	var course = Course("CC", 0, 0.0)
	database.use {
	select("Course")
	.whereArgs("(courseCode = {courseCode})",
	"courseCode" to courseCode)
	.parseOpt(classParser<Course>())
	?.let {course = it}
	}
	return course
	}
	override fun getAllCourse(): MutableList<Course> {
	var courses = mutableListOf<Course>()
	database.use {
	courses = select("Course")
	.parseList(classParser<Course>()).toMutableList()
	}
	return courses
	}
	override fun addCourse(course: Course): Boolean {
	if (getCourse(course.courseCode).courseCode == "CC") {
	database.use {
	insert("Course",
	"courseCode" to course.courseCode,
	"units" to course.units,
	"grade" to course.grade)
	}
	return true
	}
	else
	return false
	}
	override fun updateCourse(course: Course){
	database.use {
	update("Course", "grade" to course.grade)
	.whereArgs("courseCode = {courseCode}",
	"courseCode" to course.courseCode)
	.exec()
	}
	}
	override fun removeCourse(course: Course){
	database.use{
	delete("Course",
	"(courseCode = {courseCode})",
	"courseCode" to course.courseCode)
	}
	}
	}

view raw CourseRepository.kt hosted with ❤ by GitHub

And that is basically the idea of MVP. Keep in mind that this in not an architecture and is to be used with you own software architecture. If you want to see the full application code, here is the source code.