为什么引入架构呢？引入架构的项目，必是到了一定的规模，也就是出现了一定程度的耦合与冗余，也一定意义上违反了面向对象的单一职责原则。
那么MVP解决的问题就很明显了， 那就是冗余、混乱、耦合重。此时抛开MVP不讲，如果要我们自己想办法去解决，如何来解决呢？
分而治之， 我们可能会想到，根据单一职责原则，Activity或Fragment或其他组件冗余了，那么必然要根据不同的功能模块，来划分出来不同的职责模块，这样也就遵循了单一职责的原则。站在前人的智慧上，或许很多人就想到了M(Model)V(View)C(Controller)。我们可以借鉴这一开发模式，来达到我们的目的，暂时将一个页面划分为
UI模块，也即View层
Model模块，也即数据请求模块
Logic模块， 司逻辑处理
这样划分首先职责分工就明确了，解决了混乱，冗余的问题。
public class LoginActivity extends AppCompatActivity {
EditText inputUserName;
EditText inputPassword;
Button btnLogin;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
final String userName = inputUserName.getText().toString();
final String password = inputPassword.getText().toString();
boolean isEmptyUserName = userName == null || userName.length() == 0;
boolean isEmptyPassword = userName == null || userName.length() == 0;
boolean isUserNameValid =Pattern.compile("^[A-Za-z0-9]{3,20}+$").matcher(userName ).matches()；
boolean isPasswordValid = Pattern.compile("^[A-Za-z0-9]{3,20}+$").matcher(password ).matches()；
if (isEmptyPassword || isEmptyPassword) {
Toast.makeText(LoginActivity.this, "请输入帐号密码", Toast.LENGTH_SHORT).show();
} else {
if (isUserNameValid && isPasswordValid) {
new Thread(new Runnable() {
@Override
public void run() {
// ...登录请求
boolean loginResult = false;
if (loginResult) {
Toast.makeText(LoginActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(LoginActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
}
}
}).start();
} else {
Toast.makeText(LoginActivity.this, "帐号密码格式错误", Toast.LENGTH_SHORT).show();
}
}
}
});
}
}
一个简单的登录， 包括点击事件， 获取登录信息， 判断是否空， 校验是否正确， 请求登录， 返回处理。
上面说到， 面向对象的单一职责原则， 一个模块划分越具有原子性，也即划分越细，那么重用性就越高。如果我改成这样
public class LoginActivity extends AppCompatActivity {
EditText inputUserName;
EditText inputPassword;
Button btnLogin;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
final String userName = getEditorText(inputUserName);
final String password = getEditorText(inputPassword);
if (isEmpty(userName) || isEmpty(password)) {
showTips("请输入帐号密码");
} else {
if (isValid(userName) && isValid(password)) {
// 登录
doLogin(userName, password);
} else {
showTips("帐号密码格式错误");
}
}
}
});
}
private boolean isValid(String s) {
return Pattern.compile("^[A-Za-z0-9]{3,20}+$").matcher(s).matches();
}
private boolean isEmpty(String s) {
return s == null || s.length() == 0;
}
private String getEditorText(EditText et) {
return et.getText().toString();
}
private void showTips(String tips) {
Toast.makeText(LoginActivity.this, tips, Toast.LENGTH_SHORT).show();
}
private void doLogin(String username, String password) {
new Thread(new Runnable() {
@Override
public void run() {
// ...登录请求
boolean loginResult = false;
// 更新UI
notifyLoginResult(loginResult);
}
}).start();
}
private void notifyLoginResult(boolean loginResult) {
if (loginResult) {
showTips("登录成功");
} else {
showTips("登录失败");
}
}
}
将源码方法进行拆分后， isEmpty, isValid, showTips…等，产生的结果有亮点：
这就是单一职责原则的作用，提高可重用性， 减少代码冗余，开始露出清晰的思维脉络。
以上说明了单一职责的意义，以及带来的附加的益处。那么代码经过初步重构以后， 虽然更清晰了，消除了冗余，但是耦合的问题依旧。那怎么解决耦合问题呢？我们来看下半场
MVP最难的难点之一： 如何正确划分各模块
View层与Presenter层交互性很频繁，很多人不清楚这一块代码算是View，还是Presenter
像登录模块，View与逻辑交错在一起，怎么区分呢 ？
首先Login功能大抵分为以下子功能：
1、取值， EditText帐号与密码（明确的View层，不涉及逻辑操作）
2、判空与校验 （Presenter但涉及View, 因为使用帐号与密码，通过传参的形式）
3、登录请求 （名副其实的Model， 处理明显在Presenter层）
4、更新UI (View层)
其实以上划分界限相对比较清晰，项目中难免遇到一些不好界限的，教你一招，难以划分的必然包含View也包含逻辑处理。那么第一步，
那么明确了M V P的拆分，看一下拆分结果
1、View 部分
public class LoginActivity extends AppCompatActivity {
EditText inputUserName;
EditText inputPassword;
Button btnLogin;
LoginPresenter presenter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
presenter = new LoginPresenter(this);
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
presenter.execureLogin(getEditorText(inputUserName), getEditorText(inputPassword));
}
});
}
private String getEditorText(EditText et) {
return et.getText().toString();
}
public void showTips(String tips) {
Toast.makeText(LoginActivity.this, tips, Toast.LENGTH_SHORT).show();
}
public void notifyLoginResult(boolean loginResult) {
if (loginResult) {
showTips("登录成功");
} else {
showTips("登录失败");
}
}
}
2、Model部分
public class LoginModel {
private Handler handler;
public LoginModel() {
handler = new Handler();
}
public interface OnLoginCallback {
void onResponse(boolean success);
}
public void login(String username, String password, final OnLoginCallback callback) {
new Thread(new Runnable() {
@Override
public void run() {
// ...请求接口
boolean result = true; // 假设这是接口返回的结果
callback.onResponse(result);
}
}).start();
}
}
Presenter部分
public class LoginPresenter {
private LoginModel model;
private LoginActivity activity;
private String verifyMsg;
public LoginPresenter(LoginActivity activity) {
this.activity = activity;
model = new LoginModel();
}
public void execureLogin(String username, String password) {
boolean verifyBefore = verifyBeforeLogin(username, password);
if (verifyBefore) {
// 校验通过，请求登录
model.login(username, password, new LoginModel.OnLoginCallback() {
@Override
public void onResponse(boolean success) {
// 登录结果
activity.notifyLoginResult(success);
}
});
} else {
// 校验失败，提示
activity.showTips(verifyMsg);
}
}
private boolean verifyBeforeLogin(String username, String password) {
boolean isEmpty = isEmpty(username) || isEmpty(password);
boolean isValid = isValid(username) && isValid(password);
if (isEmpty) {
verifyMsg = "请输入帐号或密码";
return false;
}
if (isValid) {
return true;
}
verifyMsg = "帐号或密码错误";
return false;
}
private boolean isValid(String s) {
return Pattern.compile("^[A-Za-z0-9]{3,20}+$").matcher(s).matches();
}
private boolean isEmpty(String s) {
return s == null || s.length() == 0;
}
}
通过以上代码可以看出：
这样每一层都只处理本层的业务，从大的方向上进行了单一职责拆分，从而整体符合单一职责原则。
根据MVP将页面拆分为了3层，单一职责的原则我们已经完全符合了。但是仔细看，忽然发现相互之间还存在依赖，解耦效果并不是那么理想。那我们要思考了，是什么原因导致耦合尚在？
那就是对象持有，看看我们的项目
MVP是怎么解决对象持有问题的？
对于面向对象设计来讲， 利用接口达到解耦目的已经是人尽皆知的了。 这次改动很小，把对象持有改为接口持有即可。
既然持有接口，肯定要在View与Presenter分别实现供外部调用的接口。
notifyLoginResult和showTips；executeLogin。那么先来实现接口如何？看代码
Presenter接口
public interface IPresenter {
/**
* 执行登录
*
* @param username
* @param password
*/
void executeLogin(String username, String password);
}
View接口
public interface IView {
/**
* 更新登录结果
*
* @param loginResult
*/
void notifyLoginResult(boolean loginResult);
/**
* Toast提示
*
* @param tips
*/
void showTips(String tips);
}
接口的作用是对外部提供一种供外部调用的规范。因此这里我们把外部需要调用的方法抽象出来，加入到接口中。接口有了，且接口代表的是View或Presenter的实现，所以分别实现它们。看代码
Presenter实现接口
public class LoginPresenter implements IPresenter {
private LoginModel model;
private LoginActivity activity;
private String verifyMsg;
public LoginPresenter(LoginActivity activity) {
this.activity = activity;
model = new LoginModel();
}
@Override
public void executeLogin(String username, String password) {
boolean verifyBefore = verifyBeforeLogin(username, password);
if (verifyBefore) {
// 校验通过，请求登录
model.login(username, password, new LoginModel.OnLoginCallback() {
@Override
public void onResponse(boolean success) {
// 登录结果
activity.notifyLoginResult(success);
}
});
} else {
// 校验失败，提示
activity.showTips(verifyMsg);
}
}
private boolean verifyBeforeLogin(String username, String password) {
boolean isEmpty = isEmpty(username) || isEmpty(password);
boolean isValid = isValid(username) && isValid(password);
if (isEmpty) {
verifyMsg = "请输入帐号或密码";
return false;
}
if (isValid) {
return true;
}
verifyMsg = "帐号或密码错误";
return false;
}
private boolean isValid(String s) {
return Pattern.compile("^[A-Za-z0-9]{3,20}+$").matcher(s).matches();
}
private boolean isEmpty(String s) {
return s == null || s.length() == 0;
}
}
View实现接口
public class LoginActivity extends AppCompatActivity implements IView{
EditText inputUserName;
EditText inputPassword;
Button btnLogin;
LoginPresenter presenter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
presenter = new LoginPresenter(this);
btnLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
presenter.executeLogin(getEditorText(inputUserName), getEditorText(inputPassword));
}
});
}
private String getEditorText(EditText et) {
return et.getText().toString();
}
@Override
public void showTips(String tips) {
Toast.makeText(LoginActivity.this, tips, Toast.LENGTH_SHORT).show();
}
@Override
public void notifyLoginResult(boolean loginResult) {
if (loginResult) {
showTips("登录成功");
} else {
showTips("登录失败");
}
}
}
在接口中提供对外部调用的方法，然后分别在View和Presenter中实现它们。接口与实现都有了，还记得我们的目的是什么吗？是把持有的对象替换为接口，撸起来，看代码
// 这是View持有的接口，在onCreate中初始化的对象由原来的LoginPresenter改为了IPresenter。
public class LoginActivity extends AppCompatActivity implements IView{
EditText inputUserName;
EditText inputPassword;
Button btnLogin;
IPresenter presenter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
presenter = new LoginPresenter(this);
...
}
// 这是Presenter持有的接口，在构造中由原来的LoginActivity改为了IView
public class LoginPresenter implements IPresenter {
private LoginModel model;
private String verifyMsg;
private IView activity;
public LoginPresenter(IView activity) {
this.activity = activity;
model = new LoginModel();
}
...
1） 单一职责
2） 面向接口通信
这里以登录为例。先来分析下业务：
1、EditText取得输入的UserName与Password
2、校验（包括判断是否是空的， 是否符合输入规范比如不允许输入特殊字符）
3、校验通过， 执行登录请求； 不通过，直接提示错误
4、登录请求
5、根据登录结果，提示登录成功或失败
6、伴随着登录结果更新UI
MVP引入了BaseInterface 与Contract的概念。如果单纯的mvp，可能很多人都理解，但是加上这两个概念，加深了理解难度。
base-interface 就是我们常用的base的概念，目的就是规范统一的操作。比如显示一个Toast, 判断网络是否连接，跳转动画等，我们都放在BaseActivity中，因为所有的Activity都需要这些。接口的继承也是这个目的。如登录功能
这个概念的引入只是为了统一管理一个页面的View和Presenter接口。每个页面对应
1个View(Activity或Fragment), 一个IView(View接口)，1个Presenter,一个IPresenter(Presenter接口)，1个Contract(一个包含View接口和Presenter接口的接口)。如
public interface LoginContract {
interface View {
void notifyLoginResult();
}
interface Presenter {
void login(String username, String password);
}
}
1） 首先来思考，我们最先定义的应该是什么？ 当然是公共接口。
View的公共接口（MVP-Samples中的IView）没有公共的操作，我们定义一个空的接口，用于统一规范。
public interface IView {
}
Presenter的公共接口（MVP-Samples中的IPresenter）也没有公共的操作，在mvp提供的samples中是带了一个start的，但是这里不需要。
public interface IPresenter {
}
以上两个接口，是用于给View与Presenter的接口继承的，注意，不是View或Presenter本身继承。因为它定义的是接口的规范， 而接口才是定义的类的规范。
2）定义的接口要继承IView与IPresenter, 而且由Contract统一管理
public interface LoginContract {
interface View extends IView {
// View中的2个功能：
// 1) 取得登录需要的username, password # 不需要对Presenter层提供调用
// 2) 提示错误信息， 提示登录结果 # 需要Presenter层调用,因为校验和登录都是在Presenter层的
// 因此2)是View层提供的对外方法，需要在接口中定义
/**
* 提示一个Toast
*
* @param msg
*/
void showToast(String msg);
}
interface Presenter extends IPresenter {
// Presenter中的2个功能：
// 1) 校验 # 看你怎么写，既可以在View层中调用校验方法，也可以在Presenter层中，这里定义为直接在Presenter中校验，彻底和View解耦
// 2) 登录 # 先执行校验，再执行登录，需要在View层点击登录时调用
// 因此2)是Presenter对外层提供的方法，需要在接口中定义
/**
* 登录操作
*
* @param username
* @param password
*/
void login(String username, String password);
}
}
以上Contract（称之为功能仓库）分别定义了View与Presenter接口，并添加了接口的定义过程分析。
3） 接口定义完成了，下一步是什么呢？ 肯定是实现接口，加入功能吧。定义Presenter与View分别实现接口，加入对应功能。
public class LoginActivity extends AppCompatActivity implements LoginContract.View {
LoginContract.Presenter mPresenter;
Button loginBtn;
EditText etUser, etPwd;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mPresenter = new LoginPresenter(this);
loginBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPresenter.login(etUser.getText().toString(), etPwd.getText().toString());
}
});
}
@Override
public void showToast(String msg) {
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
}
*********************************************************************************************************
public class LoginPresenter implements LoginContract.Presenter {
LoginContract.View mView;
public LoginPresenter(LoginContract.View mView) {
this.mView = mView;
}
@Override
public void login(String username, String password) {
// 校验直接放在登录流程
boolean isVerifySuccessully = verifyLoginInfo();
if (isVerifySuccessully) {
// 请求登录
LoginModel.requestLogin(username, password, new LoginModel.RequestCallback() {
@Override
public void onResponse(boolean result) {
if (result) {
// 提示登录成功
mView.showToast("登录成功");
} else {
// 提示登录失败
mView.showToast("登录失败");
}
}
});
} else {
// 校验失败，提示错误
mView.showToast("无效的帐号或密码");
}
}
private boolean verifyLoginInfo() {
// 这里校验登录信息
// 校验帐号，密码是否为空
// 校验帐号，密码是否符合要求
return true;
}
}
注意：LoginActivity在相对的生命周期中需要销毁Presenter引用，由于后面会封装，这里没加。
走到这一步基本就是一个完整的MVP开发模式了，从划分层次到接口通信，其实还是挺简单的，不是么？下面继续来优化这个框架，我们考虑以下几个问题：
Presenter基类抽取，公共元素有哪些 ：
Context， View接口。
很多网上View的获取是定义一个AttachView的方法， 这里使用在构造中直接传入。
public abstract class BasePresenter<AttachView extends IView> {
private Context mContext;
private AttachView mView;
public BasePresenter(Context context, AttachView view) {
if (context == null) {
throw new NullPointerException("context == null");
}
mContext = context.getApplicationContext();
mView = view;
}
/**
* 获取关联的View
*
* @return
*/
public AttachView getAttachedView() {
if (mView == null) {
throw new NullPointerException("AttachView is null");
}
return mView;
}
/**
* 获取关联的Context
*
* @return
*/
public Context getContext() {
return mContext;
}
/**
* 清空Presenter
*/
public void clearPresenter() {
mContext = null;
mView = null;
}
/**
* View是否关联
*
* @return
*/
public boolean isViewAttached() {
return mView != null;
}
/**
* 网络是否连接
*
* @return
*/
public boolean isNetworkConnected() {
if (mContext == null) {
throw new NullPointerException("mContext is null");
}
return NetworkHelper.isNetworkConnected(mContext);
}
public abstract void start();
public abstract void destroy();
}
以上是我们抽取的Presenter基类。实现了：
1、初始化时绑定View接口，并在clear时清除接口
2、自动获取ApplicationContext（还是建议不这样，直接传Application的Context） 3、View状态判定
4、网络连接判断（因为Presenter中执行网络请求比较频繁，你可以根据业务自定义多个方法）
5、satrt初始化方法与destroy销毁方法（结合后面的MVPCompatActivity自动销毁）
注意：在使用View时，请先判断View状态，否则View异常销毁时会报NullPoiterException。如果有线程或者Handler一定要在destroy中销毁，避免造成内存泄漏 。
for Activity
/**
* MVP - Activity基类
*/
public abstract class MVPCompatActivity<T extends BasePresenter> extends RootActivity {
protected T mPresenter;
@Override
protected void onStart() {
super.onStart();
if (mPresenter == null) {
mPresenter = createPresenter();
}
mPresenter.start();
}
@Override
protected void onStop() {
super.onStop();
mPresenter.clearPresenter();
mPresenter = null;
}
@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
mPresenter.clearPresenter();
mPresenter = null;
}
/**
* 创建一个Presenter
*
* @return
*/
protected abstract T createPresenter();
}
for Fragment
public abstract class MVPCompatFragment<T extends BasePresenter> extends RootFragment {
protected T mPresenter;
@Override
public void onStart() {
super.onStart();
if (mPresenter == null) {
mPresenter = createPresenter();
}
mPresenter.start();
}
@Override
public void onStop() {
super.onStop();
if (mPresenter != null) {
mPresenter.clearPresenter();
mPresenter = null;
}
}
protected abstract T createPresenter();
}
for Layout
public abstract class MVPCompatLayout<T extends BasePresenter> extends RootLayout {
protected T mPresenter;
public MVPCompatLayout(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
mPresenter = createPresenter();
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
if (mPresenter != null) {
mPresenter.clearPresenter();
mPresenter = null;
}
}
protected abstract T createPresenter();
}
for Adapter
public abstract class MVPCompatRecyclerAdapter<T, P extends BasePresenter> extends RootRecyclerAdapter<T> {
protected P mPresenter;
public MVPCompatRecyclerAdapter(Context context, List data) {
super(context, data);
}
protected abstract P createPresenter();
@Override
public void onViewAttachedToWindow(RecyclerViewHolder holder) {
super.onViewAttachedToWindow(holder);
mPresenter = createPresenter();
}
@Override
public void onViewDetachedFromWindow(RecyclerViewHolder holder) {
super.onViewDetachedFromWindow(holder);
if (mPresenter != null) {
mPresenter.clearPresenter();
mPresenter = null;
}
}
}
通过继承以上View的Base, 可以自由实现初始化以及销毁。轻松实现MVP。
最后，补充的RootActivity, 作为一个Base的Activity,是根据不同的业务决定里面的内容的，因此这里很少
public abstract class RootActivity extends AppCompatActivity {
protected Context mContext;
protected Context mAppContext;
private View mContentView;
private Bundle mBundleObj;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mAppContext = getApplicationContext();
mContext = this;
mContentView = getLayoutInflater().inflate(getLayoutRes(), null);
setContentView(mContentView);
ButterKnife.bind(this);
init();
}
protected abstract int getLayoutRes();
protected abstract void init();
/**
* findViewById
*
* @param resId
* @param <T>
* @return
*/
protected <T extends View> T $(int resId) {
return (T) findViewById(resId);
}
/**
* Toast
*
* @param toast
*/
protected void showToast(String toast) {
Toast.makeText(this, toast, Toast.LENGTH_SHORT).show();
}
/**
* get a bundle from reuse.
*
* @return
*/
protected Bundle obtainBundle() {
if (mBundleObj == null) {
mBundleObj = new Bundle();
} else {
mBundleObj.clear();
}
return mBundleObj;
}
}
public class MyUser extends BmobUser {
private String image;
private String gender;
private String age;
public String getImage() {
return image;
}
public void setImage(String image) {
this.image = image;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
public interface BaseContract {
interface BasePresenter<T> {
void attachView(T view);
void detachView();
}
interface BaseView {
void onSuccess();
void onFailure(Throwable e);
}
}
public interface LandContract extends BaseContract {
interface View extends BaseContract.BaseView {
void landSuccess(MyUser user);
}
interface Presenter extends BaseContract.BasePresenter<View>{
/**
* 用户登陆
*/
void login(String username, String password);
/**
* 用户注册
*/
void signup(String password, String mail);
}
}
public abstract class BaseMVPActivity<T extends BaseContract.BasePresenter> extends BaseActivity{
protected T mPresenter;
protected abstract T bindPresenter();
@Override
protected void processLogic() {
attachView(bindPresenter());
}
private void attachView(T presenter){
mPresenter = presenter;
mPresenter.attachView(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
mPresenter.detachView();
}
}
public class LoginActivity extends BaseMVPActivity<LandContract.Presenter>
implements LandContract.View, View.OnFocusChangeListener, View.OnClickListener {
private OwlView mOwlView;
private EditText usernameET;
private EditText passwordET;
private EditText rpasswordET;
private TextView signTV;
private TextView forgetTV;
private Button loginBtn;
//是否是登陆操作
private boolean isLogin = true;
@Override
protected int getLayoutId() {
return R.layout.activity_user_land;
}
@Override
protected void initWidget() {
super.initWidget();
mOwlView=findViewById(R.id.land_owl_view);
usernameET=findViewById(R.id.login_et_username);
passwordET=findViewById(R.id.login_et_password);
rpasswordET=findViewById(R.id.login_et_rpassword);
signTV=findViewById(R.id.login_tv_sign);
forgetTV=findViewById(R.id.login_tv_forget);
loginBtn=findViewById(R.id.login_btn_login);
}
@Override
protected void initClick() {
super.initClick();
passwordET.setOnFocusChangeListener(this);
rpasswordET.setOnFocusChangeListener(this);
signTV.setOnClickListener(this);
forgetTV.setOnClickListener(this);
loginBtn.setOnClickListener(this);
}
@Override
public void onFocusChange(View v, boolean hasFocus) {
if (hasFocus) {
mOwlView.open();
} else {
mOwlView.close();
}
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.login_btn_login: //button
if (isLogin) {
login(); //登陆
} else {
sign(); //注册
}
break;
case R.id.login_tv_sign: //sign
if (isLogin) {
//置换注册界面
signTV.setText("登录");
loginBtn.setText("注册");
rpasswordET.setVisibility(View.VISIBLE);
usernameET.setVisibility(View.GONE);
} else {
//置换登陆界面
signTV.setText("注册");
loginBtn.setText("登录");
usernameET.setVisibility(View.VISIBLE);
rpasswordET.setVisibility(View.GONE);
}
isLogin = !isLogin;
break;
case R.id.login_tv_forget: //忘记密码
showForgetPwDialog();
break;
default:
break;
}
}
/**
* 执行登陆动作
*/
public void login() {
String username = usernameET.getText().toString();
String password = passwordET.getText().toString();
if (username.length() == 0 || password.length() == 0) {
SnackbarUtils.show(mContext, "用户名或密码不能为空");
return;
}
ProgressUtils.show(this, "正在登陆...");
mPresenter.login(username, password);
}
/**
* 执行注册动作
*/
public void sign() {
String email = usernameET.getText().toString();
String password = passwordET.getText().toString();
String rpassword = rpasswordET.getText().toString();
if (email.length() == 0 || password.length() == 0 || rpassword.length() == 0) {
SnackbarUtils.show(mContext, "请填写必要信息");
return;
}
if (!StringUtils.checkEmail(email)) {
SnackbarUtils.show(mContext, "请输入正确的邮箱格式");
return;
}
if (!password.equals(rpassword)) {
SnackbarUtils.show(mContext, "两次密码不一致");
return;
}
ProgressUtils.show(this, "正在注册...");
usernameET.setText(email);
mPresenter.signup(password,email);
}
/***********************************************************************/
@Override
protected LandContract.Presenter bindPresenter() {
return new LandPresenter();
}
@Override
public void landSuccess(MyUser user) {
ProgressUtils.dismiss();
if (isLogin) {
setResult(RESULT_OK, new Intent());
Intent intent = new Intent(this, MainActivity1.class);
startActivity(intent);
finish();
} else {
Toast.makeText(this, "注册成功", Toast.LENGTH_SHORT).show();
//置换登陆界面
signTV.setText("注册");
loginBtn.setText("登录");
rpasswordET.setVisibility(View.GONE);
usernameET.setVisibility(View.VISIBLE);
isLogin=true;
}
Log.i(TAG,user.toString());
}
@Override
public void onSuccess() {
ProgressUtils.dismiss();
}
@Override
public void onFailure(Throwable e) {
ProgressUtils.dismiss();
SnackbarUtils.show(mContext, e.getMessage());
Log.e(TAG,e.getMessage());
}
/**
* 显示忘记密码对话框
*/
public void showForgetPwDialog() {
new MaterialDialog.Builder(this)
.title("找回密码")
.inputType(InputType.TYPE_CLASS_TEXT)
.input("请输入注册邮箱", null, (dialog, input) -> {
String inputStr = input.toString();
if (input.equals("")) {
SnackbarUtils.show(mContext, "内容不能为空！");
} else if(!StringUtils.checkEmail(inputStr)) {
Toast.makeText(LoginActivity.this,
"请输入正确的邮箱格式", Toast.LENGTH_LONG).show();
} else {
//找回密码
BmobUser.resetPasswordByEmail(input.toString(), new UpdateListener() {
@Override
public void done(BmobException e) {
if (e == null) {
ToastUtils.show(mContext, "重置密码请求成功，请到邮箱进行密码重置操作");
} else {
ToastUtils.show(mContext, "重置密码请求失败，请确认输入邮箱正确！");
}
}
});
}
})
.positiveText("确定")
.negativeText("取消")
.show();
}
}
public class LandPresenter extends RxPresenter<LandContract.View> implements LandContract.Presenter{
private String TAG="LandPresenter";
@Override
public void login(String username, String password) {
MyUser.loginByAccount(username, password, new LogInListener<MyUser>() {
@Override
public void done(MyUser myUser, BmobException e) {
if(e == null) {
mView.landSuccess(myUser);
}else {
String error=e.toString();
if(error.contains("incorrect")){
Toast.makeText(getApplicationContext(), "账号或者密码错误！", Toast.LENGTH_SHORT).show();
mView.onSuccess();
}else {
mView.onFailure(e);
}
}
}
});
}
@Override
public void signup(String password, String mail) {
MyUser myUser =new MyUser();
myUser.setPassword(password);
myUser.setEmail(mail);
myUser.signUp(new SaveListener<MyUser>() {
@Override
public void done(MyUser myUser, BmobException e) {
if(e == null)
mView.landSuccess(myUser);
else{
String error = e.toString();
if(error.contains("already")){
Toast.makeText(getApplicationContext(), "邮箱已经被注册，请重新填写！", Toast.LENGTH_SHORT).show();
mView.onSuccess();
}else {
mView.onFailure(e);
}
}
}
});
}
}