MVC Design Pattern(Model View Controller)

After developing the complex application it is very tough to manage the application, so the stable app we want it to be, we use design pattern so any developer can easily understand the code any easy change the code according to need

MVC firstly comes picture in design pattern

The Model-View-Controller Pattern:-

Model — the model layer, responsible for managing the business logic and handling network or database API.

View — the UI layer, perform the operation related to the user interface

Controller — the controller layer, gets notified of the user’s behaviour and updates the Model.

Note:- Here we can see that  both the Controller and the View depend on the Model

Q- How to use MVC in android

The Activities, Fragments and Views should be the Views in the MVC world.

The Controllers should be separate classes that don’t extend or use any Android class.

The Model should be separate classes that don’t extend or use any Android class.

Things you should know:-

One problem arises when connecting the Controller to the View since the Controller needs to tell the View to update. In the Model MVC architecture, the Controller needs to hold a reference to the View. The easiest way of doing this, while focusing on testing, is to have a Base View interface, that the Activity/Fragment would extend. So the Controller would have a reference to the Base View.

Advantage:-

The Model-View-Controller pattern highly supports the separation of concerns. This advantage not only increases the understanding of the code but it also makes it easier to extend, allowing easy implementation of new features.

The Model classes don’t have any reference to Android classes. The Controller doesn’t extend or implement any Android classes and should have a reference to an interface class of the View.

the Views respect the single responsibility principle then their role is just to update the Controller for every user event and just display data from the Model, without implementing any business logic.

According to the MVC pattern, the Controller updates the Model and the View gets the data to be displayed from the Model. But who decides on how to display the data?

we have a User, with first name and last name. In the View, we need to display the user name as “Lastname, Firstname” (e.g. “ABC”, “DEF”).

If the Model’s role is to just provide the “raw” data, it means that the code in the View would be:

String firstName = userModel.getFirstName();

String lastName = userModel.getLastName();

nameTextView.setText(lastName + ", " + firstName)

The other approach is to have the Model expose only the data that needs to be displayed, hiding any business logic from the View. But then, we end up with Models that handle both business and UI logic. It would be unit-testable, but then the Model ends up, implicitly being dependent on the View.

String name = userModel.getDisplayName();

nameTextView.setText(name);

MVP(Model View Presenter)

MVP is one of the software development design patterns which is currently in use by many android application developers for better app development

The MVP pattern allows separating the presentation layer from the logic.

MVP:——–

Model: The Model holds the business logic of the application. It controls how data is created, stored, and modified.

View: The View is an interface that displays data and routes user actions to the Presenter.

Presenter: The Presenter acts as the middleman. It retrieves data from the Model and shows it in the View. It also processes user actions forwarded by the View.

MVP makes views independent from our data source. We divide the application into at least three different layers

How to implement MVP?

There are many variations of MVP and everyone can adjust the pattern idea to their needs and the way they feel more comfortable.

interface ChangePasswordContractor {

    interface View: BaseActivityContractor.View {
        fun showError(resId: Int, errorMessage: String)
        fun setBackground(resId: Int, drawbleId: Int)
        fun moveToLoginScreen()
        fun isOldObsecure() : Boolean
        fun setIsOldObsecure(isOldObsecure : Boolean)
        fun isNewObsecure() : Boolean
        fun setIsNewObsecure(isNewObsecure : Boolean)
        fun isConfirmObsecure() : Boolean
        fun setIsConfirmObsecure(isConfirmObsecure : Boolean)

    }

    interface Presenter : BaseActivityContractor.Presenter, AlertDialogCallback {
        fun showAlertDialog()
        fun onChangePasswordSuccess()
        fun onChangePasswordFailed(errorMessage: String)
        fun onSaveButtonClick(oldPassword: String, newPassword: String, confirmPassword : String)
        fun getSaveInstanceDataMap() : HashMap<String, Any>
        fun initializeSavedInstanceData(map : HashMap<String, Any>)
    }

    interface Interactor: BaseActivityContractor.Interactor {
        fun onApiHitOfChangePassWord(accessToken: String, map: HashMap<String, String>)

    }
}

Above interfaces will use to pass data between three layers. To implement these interfaces we will create three classes which will implement the defined methods of interfaces.

Above methods will interact with the view layer to update user interface as needed. This ILoginView will be implemented by LoginActivity.

class ChangePasswordActivity : BaseActivity(), ChangePasswordContractor.View {
    override fun isOldObsecure(): Boolean = this.isOldObsecure

    override fun setIsOldObsecure(isOldObsecure: Boolean) {
        this.isOldObsecure = isOldObsecure
    }

    override fun isNewObsecure(): Boolean = this.isNewObsecure

    override fun setIsNewObsecure(isNewObsecure: Boolean) {
        this.isNewObsecure = isNewObsecure
    }

    override fun isConfirmObsecure(): Boolean = this.isConfirmObsecure

    override fun setIsConfirmObsecure(isConfirmObsecure: Boolean) {
        this.isConfirmObsecure = isConfirmObsecure
    }

    private val mChangePasswordPresenter: ChangePasswordContractor.Presenter =
        ChangePasswordPresenter(this)
    private var isOldObsecure = true
    private var isNewObsecure = true
    private var isConfirmObsecure = true

    override fun getLayoutResourseId(): Int = R.layout.activity_change_password
    override fun showError(resId: Int, errorMessage: String) {
        findViewById<TextInputLayout>(resId).error = errorMessage

    }

    override fun moveToLoginScreen() {
        val intent = Intent(this, LoginActivity::class.java)
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
        startActivity(intent)

    }


    override fun setBackground(resId: Int, drawbleId: Int) {
        findViewById<EditText>(resId).setBackgroundResource(drawbleId)
    }

    override fun initViews() {
        if (isOldObsecure) {
            etOldPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
            etOldPassword.transformationMethod = PasswordTransformationMethod()
            etOldPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)

        } else {
            etOldPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
            etOldPassword.transformationMethod = null
            etOldPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)

        }

        if (isNewObsecure) {
            etNewPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
            etNewPassword.transformationMethod = PasswordTransformationMethod()
            etNewPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)

        } else {
            etNewPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
            etNewPassword.transformationMethod = null
            etNewPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)
        }

        if (isConfirmObsecure) {
            etConfirmPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
            etConfirmPassword.transformationMethod = PasswordTransformationMethod()
            etConfirmPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)

        } else {
            etConfirmPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
            etConfirmPassword.transformationMethod = null
            etConfirmPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)
        }


        tvBack.setOnClickListener {
            onBackPressed()
        }
        btnSave.setOnClickListener {
            mChangePasswordPresenter.onSaveButtonClick(
                etOldPassword.text.toString().trim(),
                etNewPassword.text.toString().trim(),
                etConfirmPassword.text.toString().trim()
            )
        }

        etOldPassword.setOnTouchListener(object : DrawableOnClickListener(etOldPassword) {
            override fun onClick(v: View?, event: MotionEvent?, whichDrawable: Int) {
                ViewUtils.showKeyboard(this@ChangePasswordActivity, etOldPassword)
                if (isOldObsecure) {
                    etOldPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
                    etOldPassword.transformationMethod = null
                    etOldPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)

                } else {
                    etOldPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
                    etOldPassword.transformationMethod = PasswordTransformationMethod()
                    etOldPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)
                }

                isOldObsecure = !isOldObsecure
            }
        })

        etNewPassword.setOnTouchListener(object : DrawableOnClickListener(etNewPassword) {
            override fun onClick(v: View?, event: MotionEvent?, whichDrawable: Int) {
                ViewUtils.showKeyboard(this@ChangePasswordActivity, etNewPassword)
                if (isNewObsecure) {
                    etNewPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
                    etNewPassword.transformationMethod = null
                    etNewPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)

                } else {
                    etNewPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
                    etNewPassword.transformationMethod = PasswordTransformationMethod()
                    etNewPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)
                }

                isNewObsecure = !isNewObsecure
            }
        })

        etConfirmPassword.setOnTouchListener(object : DrawableOnClickListener(etConfirmPassword) {
            override fun onClick(v: View?, event: MotionEvent?, whichDrawable: Int) {
                ViewUtils.showKeyboard(this@ChangePasswordActivity, etConfirmPassword)
                if (isConfirmObsecure) {
                    etConfirmPassword.inputType = InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
                    etConfirmPassword.transformationMethod = null
                    etConfirmPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_show, 0)

                } else {
                    etConfirmPassword.inputType = InputType.TYPE_TEXT_VARIATION_PASSWORD or InputType.TYPE_CLASS_TEXT
                    etConfirmPassword.transformationMethod = PasswordTransformationMethod()
                    etConfirmPassword.setCompoundDrawablesRelativeWithIntrinsicBounds(0, 0, R.drawable.ic_password_hide, 0)
                }

                isConfirmObsecure = !isConfirmObsecure
            }
        })

    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putSerializable(SAVED_INSTANCE_DATA, mChangePasswordPresenter.getSaveInstanceDataMap())
    }


    @Suppress("UNCHECKED_CAST")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState != null) {
            mChangePasswordPresenter.initializeSavedInstanceData(
                savedInstanceState.getSerializable(
                    SAVED_INSTANCE_DATA
                ) as HashMap<String, Any>
            )
        }
        mChangePasswordPresenter.onCreate()
    }
}

In LoginPresenterImpl, we will have an instance of view(ILoginView) and Model(ILoginInteractor) which call methods as needed.

Interactor:-

personally we prefer Api related operation here

class ChangePasswordIntractor(private val mChangePasswordPresenter: ChangePasswordContractor.Presenter) :
    BaseActivityInteractor(mChangePasswordPresenter), ChangePasswordContractor.Interactor {
    override fun onApiHitOfChangePassWord(accessToken: String, map: HashMap<String, String>) {


        if (!mChangePasswordPresenter.isInternetAvailable()) {
            mChangePasswordPresenter.onChangePasswordFailed(ERROR_NO_INTERNET)
            return
        }

        RestClient.getApiInterface()
            .changePassword(getHeader(accessToken, CHANGE_PASSWORD), map)
            .enqueue(object : ResponseCallback<Any>() {
                override fun success(responseBody: BaseResponse<Any>) {
                    mChangePasswordPresenter.onChangePasswordSuccess()
                }

                override fun failure(statusCode: Int, errorMessage: String) {
                    mChangePasswordPresenter.onChangePasswordFailed(errorMessage)
                }

                override fun sessionExpired() {
                    mChangePasswordPresenter.onSessionExpired()
                }

                override fun onForceUpdate() {
                    mChangePasswordPresenter.onForceUpdate()
                }

            })

    }
} Presenter:-Act  as  a brain,which contain the reference of view and intractor. class ChangePasswordPresenter(private val mChangePasswordView: ChangePasswordContractor.View) :
    BaseActivityPresenter(mChangePasswordView), ChangePasswordContractor.Presenter {


    private val mChangePasswordIntractor: ChangePasswordIntractor = ChangePasswordIntractor(this)
    private var isAlertDialogOpen: Boolean = false

    override fun getSaveInstanceDataMap(): java.util.HashMap<String, Any> = hashMapOf(
        "is_old_password_visible" to mChangePasswordView.isOldObsecure(),
        "is_new_password_visible" to mChangePasswordView.isNewObsecure(),
        "is_confirm_password_visible" to mChangePasswordView.isConfirmObsecure(),
        "isAlertDialogOpen" to isAlertDialogOpen
    )

    override fun initializeSavedInstanceData(map: java.util.HashMap<String, Any>) {
        mChangePasswordView.setIsOldObsecure(map["is_old_password_visible"].toString().toBoolean())
        mChangePasswordView.setIsNewObsecure(map["is_new_password_visible"].toString().toBoolean())
        mChangePasswordView.setIsConfirmObsecure(map["is_confirm_password_visible"].toString().toBoolean())
        this.isAlertDialogOpen = map["isAlertDialogOpen"].toString().toBoolean()
    }

    override fun onSaveButtonClick(oldPassword: String, newPassword: String, confirmPassword : String) {

        mChangePasswordView.setTextFor(R.id.tv_passwoordnotmatch, "")

        if (oldPassword.isEmpty()) {
            mChangePasswordView.setTextFor(R.id.tv_passwoordnotmatch, mChangePasswordView.getStringFor(R.string.error_empty_old_password))

        } else if (newPassword.isEmpty()) {
            mChangePasswordView.setTextFor(R.id.tv_passwoordnotmatch, mChangePasswordView.getStringFor(R.string.error_empty_new_password))

        } else if (!newPassword.isPassword() || newPassword.length < 7) {
            mChangePasswordView.setTextFor(
                R.id.tv_passwoordnotmatch,
                mChangePasswordView.getStringFor(R.string.error_invalid_password)
            )
        } else if (newPassword.length > 15) {
            mChangePasswordView.setTextFor(
                R.id.tv_passwoordnotmatch,
                mChangePasswordView.getStringFor(R.string.error_password_greaterthan15)
            )

        } else if (confirmPassword.isEmpty()) {
            mChangePasswordView.setTextFor(R.id.tv_passwoordnotmatch, mChangePasswordView.getStringFor(R.string.error_empty_confirm_password))

        } else if (confirmPassword.replace(
                "\\s".toRegex(),
                ""
            ) != newPassword.replace("\\s".toRegex(), "")
        ) {
            mChangePasswordView.setTextFor(R.id.tv_passwoordnotmatch, mChangePasswordView.getStringFor(R.string.error_password_mismatch))

        } else {
            mChangePasswordView.showProgressDialog()
            mChangePasswordIntractor.onApiHitOfChangePassWord(
                accessToken!!, hashMapOf(
                    "oldPassword" to oldPassword.replace("\\s".toRegex(), ""),
                    "newPassword" to newPassword.replace("\\s".toRegex(), "")
                )
            )
        }
    }

    override fun onChangePasswordSuccess() {
        mChangePasswordView.dismissProgressDialog()
        showAlertDialog()

    }

    override fun onChangePasswordFailed(errorMessage: String) {
        mChangePasswordView.dismissProgressDialog()
        mChangePasswordView.showSnackbarMessage(errorMessage)
    }

    override fun onAlertDialogPositiveButtonClicked(purposeType: Int) {

    }

    override fun onAlertDialogNegativeButtonClicked(purposeType: Int) {
        if (purposeType == 0) {
            isAlertDialogOpen = false
            mChangePasswordView.dismissAlertDialog()
            super.onBackPressed()
        }
    }

    override fun onAlertDialogNeutralButtonClicked(purposeType: Int) {
    }

    override fun showAlertDialog() {
        isAlertDialogOpen = true
        mChangePasswordView.showPrimaryAlertDialog(
            title = mChangePasswordView.getStringFor(R.string.password_change_successfully),
            positiveButton = "",
            negativeButton = mChangePasswordView.getStringFor(R.string.text_ok),
            isCanclable = true,
            purposeType = 0
        )
    }


    override fun onCreate() {
        if (isAlertDialogOpen) {
            showAlertDialog()
        }
        mChangePasswordView.addAlertDialogCallback(this)
        super.onCreate()
        mChangePasswordView.initViews()
    }
}

MVVM  (MODEL-VIEW-VIEWMODEL)

MVVM is a software architectural pattern which facilitates separation of development UI (Activity or Fragment) from the development of the business logic or back-end logic (the data model).

ViewModels are simples classes that interact with the logic/model layer and just exposes states/data and actually have no idea by whom or how that data will be consumed. Only View(Activity) holds the reference to ViewModel and not vice versa, this solves our tight coupling issue.

Note:– A single view can hold a reference to multiple ViewModels.

Q- Why it is good to use MVVM over MVP?

In MVP, the role of a Presenter is to drive the View changes and at the same time provide data for completing those operations whereas MVVM, the ViewModel only provides the data, whereas the View is responsible for consuming them and does not hold the reference to the View. The ViewModel can also hold the logic for processing users input, same as the Presenter

Note:-we can worry less about lifecycle, memory leaks and crashes.

MVVM components:-

Data Model — it abstracts the data source. The ViewModel works with the DataModel to get and save the data. it represents the business objects that encapsulate the data and behaviour of the application.

ViewModel — it exposes streams of data relevant to the View and provides the data for a specific UI component, such as a fragment or activity, and contains data-handling business logic to communicate with the model.

View — the UI that users see and view send and receive the data from the view model

The Repository holds all the business logic of the particular app section in the app.

Step to implement MVVM in your project:-

1- Add the following line in your project level build.gradle

repositories {
    google()
    jcenter()
    maven {
        url 'https://maven.fabric.io/public'
    }

2- Open the build.gradle file for your app or module and add dependencies:

implementation “androidx.lifecycle:lifecycle-viewmodel:2.2.0”
annotationProcessor “androidx.lifecycle:lifecycle-compiler:2.2.0”

3- Create data source

you will create a data source for your application if you are using RestAPI you might use Retrofit or Volley for parsing the JSON data and if you are using SQL database you will use Room Database or SQLite.

4- Create repository

A Repository is basically a wrapper class which contains the business logic of our app.

we are Using Room database we need to have ApplicationContext and we will write all the database operation here so the person who is working on the UI does not have to worry about any database operations.

Public class Reprository{

Public Reprository(Application application)

{

}

}

In this Repository class, we will write all the DAO operations and access them in the UI through ViewModel.

5- Create a viewmodel

The ViewModel class allows data to survive configuration changes such as screen rotations.

The purpose of the ViewModel is to acquire and keep the information that is necessary for an Activity or a Fragment. The Activity or the Fragment should be able to observe changes in the ViewModel. ViewModels usually expose this information via LiveData or Android Data Binding. You can also use any observability construct from your favourite framework.

public class SignupViewModel extends ViewModel implements RetrofitResponseCallback {
    private SignupCallback signupCallback;
    private Context context;

    public void setCallback(Context context) {
        this.context = context;
        this.signupCallback = (SignupCallback) context;
    }

    private ApiInterface apiInterface(String token) {
        return ApiClient.getRetrofitInstance(token).create(ApiInterface.class);
    }

    public void signupUser(String email, String language, String name, String country, String state, String password) {
        SignupRequest signupRequest = new SignupRequest();
        signupRequest.setEmail(email);
        signupRequest.setLanguage(language);
        signupRequest.setFirst_name(name);
        signupRequest.setCountry(country);
        signupRequest.setPassword(password);
        signupRequest.setRole("DMS_Admin");
        signupRequest.setState(state);

        Call<SignupResponse> call = apiInterface("").signUpUser(signupRequest);
        ApiClient.retrofitInvokeWebService(call, this, AppConstants.REQUEST_CODE_SIGNUP);
    }

    public void sendTokenToServer(String token, String authToken, String userId, String userEmail) {
        ApiInterface apiInterface = ApiClient.getRetrofitInstance(authToken).create(ApiInterface.class);
        UserAppDetail userAppDetail = new UserAppDetail();
        userAppDetail.setFirebaseId(token);
        userAppDetail.setUserId(userId);
        userAppDetail.setUserEmail(userEmail);
        userAppDetail.setAppVersionId(Integer.toString(BuildConfig.VERSION_CODE));
        userAppDetail.setAppVersionName(BuildConfig.VERSION_NAME);

        Call<UserAppResponse> call = apiInterface.sendFirebaseUserDetail(userAppDetail);
        ApiClient.retrofitInvokeWebService(call, this, AppConstants.REQUEST_CODE_SEND_TOKEN);
    }

    @Override
    public void onStart(int requestCode) {
        if (requestCode == AppConstants.REQUEST_CODE_SIGNUP) {
            signupCallback.onShowProgress("SIgnUp ...");
        }
    }

    @Override
    public void onResponse(Object call, Object response, int requestCode) {
        signupCallback.onSuccess(response, requestCode);

    }

    @Override
    public void onFailure(Object call, Object faliure, int requestCode) {
        if (faliure instanceof String) {
            signupCallback.onHideProgress();
            ToasterNotification.showToast(context, faliure.toString());
        }
    }

}

Note:-ViewModel can handle the lifecycle configurations.

6- Use view model in UI