mvp-登陆

public class API {

    // 离线 假数据
    public static boolean OFFLINE = false;

    // Cookie
    private static ClearableCookieJar cookieJar = new PersistentCookieJar(new SetCookieCache(), new SharedPrefsCookiePersistor(APP.getContext()));
    // OkHttpClient
    private static OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .cookieJar(cookieJar)
            .addInterceptor(new Interceptor() {
                @Override
                public Response intercept(Chain chain) throws IOException {
                    Request request = chain.request()
                            .newBuilder()
                            .addHeader("User-Agent", "Android APP")
                            .addHeader("accept-language", "zh-CN,zh;q=0.9")
                            .build();
                    return chain.proceed(request);
                }
            })
            .build();

    // Retrofit
    public static Service list = new Retrofit.Builder()
            .baseUrl(Service.BASE_URL)
            .client(okHttpClient)
            .build()
            .create(Service.class);

    public interface Service {
        
         String BASE_URL = "http://10.69.3.30:8080/";

        // 登录
        @GET("appLogin/login")
        Call<ResponseBody> login(@Query("username") String username, @Query("password") String password);
}
}

==========================================================================

public interface MyCallback {

    interface SimpleCallback{
        void callback(String str);
    }

    interface GeneralCallback {
        void callback(int code, String str);
    }

    interface HTTPCallback {
        void callback(Headers headers, int code, String body);
    }

}

==========================================================

public interface LoginControl {

    interface View {

        void showUserErr(String msg);

        void showPawErr(String msg);

        void loginFailure(String msg);

        void loginSucceed(String code, String msg, String id);

        void resetPaw();

        void verify();
    }

    interface Presenter {
        void onDestroy();

        String login(String user, String paw);
    }

    interface Model {
        void onDestroy();

        String requestLogin(String user, String paw, MyCallback.HTTPCallback callback);

        String queryRoles(MyCallback.HTTPCallback callback);
    }
}

=============================================================

public class LoginModel extends BaseModel implements LoginControl.Model {

    private List<Call<ResponseBody>> callList = new ArrayList<>();

    @Override
    public void onDestroy() {
        for (Call<ResponseBody> call : callList) {
            call.cancel();
        }
    }

    @Override
    public String requestLogin(String user, String paw, final MyCallback.HTTPCallback callback) {

        Call<ResponseBody> login = API.list.login(user, paw);
        callList.add(login);

        NetUtils.enqueue(login, callback);

        return "请求中...";
    }

    @Override
    public String queryRoles(MyCallback.HTTPCallback callback) {
        Call<ResponseBody> queryRoles = API.list.queryRoles();
        callList.add(queryRoles);

        NetUtils.enqueue(queryRoles, callback);

        return "请求中...";
    }
}

==================================================================

public class LoginActivity extends BaseActivity implements LoginControl.View {

    LoginControl.Presenter presenter = new LoginPresenter(this);
    private SharedPreferences sp;
    private SharedPreferences.Editor ed;
    EditText etUser;
    EditText etPaw;

    @Override
    protected int bindLayout() {
        return R.layout.activity_login;
    }

    @Override
    protected void initView(View view) {
        super.initView(view);

        etUser = getView(R.id.et_user);
        etPaw = getView(R.id.et_paw);

        getView(R.id.v_bg).setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                if (API.OFFLINE) startActivity(I.toTest(LoginActivity.this));
                return true;
            }
        });

    }

    @Override
    protected void onStart() {
        super.onStart();
        L.i("登陆页开始");
        // 取消等待框
        dismissProgressDialog();

        //判断本地是否存在使用者身份信息
        sp = getSharedPreferences("info", MODE_PRIVATE);
        ed = sp.edit();
        String user_identity = sp.getString("user_identity", "");

        if (user_identity == "") {
            //do nothing
        } else {
            ed.clear();
            ed.commit();
        }
    }

    @Override
    protected void doBusiness(Context mContext) {
        super.doBusiness(mContext);

        //getView(R.id.tv_reset_paw).setOnClickListener(this);
        getView(R.id.btn_login).setOnClickListener(this);
    }

    @Override
    protected void onClickNotFast(View view, int viewId) {
        super.onClickNotFast(view, viewId);

        switch (viewId) {

//            case R.id.tv_reset_paw:
//                resetPaw();
//                break;
            case R.id.btn_login:
                verify();
                break;

            default:
                break;
        }
    }

    /**
     * 登录
     */
    @Override
    public void verify() {


        String user = etUser.getText().toString();
        String paw = etPaw.getText().toString();

        if ("".equals(user)) {
            showUserErr("用户名不能为空");
            return;
        } else if ("".equals(paw)) {
            showPawErr("密码不能为空");
            return;
        } else {

        }

        // 等待框
        showProgressDialog("", "登录中...", false);

        // 登录
        presenter.login(user, paw);
    }


    /**
     * 重置密码
     */
    @Override
    public void resetPaw() {
        String user = etUser.getText().toString();
        startActivity(I.toResetPaw(this, user));
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        presenter.onDestroy();
    }

    @Override
    public void showUserErr(String msg) {
        showToast(msg);
    }

    @Override
    public void showPawErr(String msg) {
        showToast(msg);
    }

    //登录失败
    @Override
    public void loginFailure(String msg) {
        // 取消等待框
        dismissProgressDialog();
        // 提示失败消息
        showToast(msg);

    }

    //登陆成功
    @Override
    public void loginSucceed(String code, String msg, String id) {
        // 取消等待框
        dismissProgressDialog();

        //吐司显示
        showToast(msg);

        //存到sp
        ed.putString("user_identity", code);
        ed.commit();

        //别名和标签 code:标签 id:别名
        setJPush(code, id);
        L.i("code==>" + code + "   id==>" + id);

        //跳转
        if (!getTorF()) {
            finish();
            return;
        }
        switch (code) {
            case "inventory_keeper":
                // 库管
                startActivity(I.toKuguan(this));
                break;
            case "sorter":
                // 分拣
                startActivity(I.toFenjian(this));
                break;
            case "general_manager":
                // 管理
                startActivity(I.toGuanli(this));
                break;
            case "sales_manager":
                // 销售
                startActivity(I.toXiaoshou(this));
                break;
            case "sys_manager":
                // 系统管理员
//                startActivity(I.toXTGuanli(this));
                startActivity(I.toFenjian(this));
                break;
            default:
                // 其他
                L.w("身份不存在");
                showToast("身份不存在");
                break;
        }
        LoginActivity.this.finish();
    }

    //设置别名和标签
    private void setJPush(String tags, String alias) {

        Set<String> tagSet = new HashSet<>(Arrays.asList(tags));

        JPushInterface.setAlias(this, 1, alias);
        JPushInterface.setTags(this, 2, tagSet);
    }

    //获取启动页带来的值
    private boolean getTorF() {
        boolean flag = false;
        boolean f = getIntent().getBooleanExtra("flag", false);
        L.i("flag--->" + f);
        flag = f;
        L.i("flag===>" + flag);
        return flag;
    }
}

======================================================================

public class LoginPresenter extends BasePresenter implements LoginControl.Presenter {

    private LoginControl.View view;
    private LoginControl.Model model;
    private String appName;

    public LoginPresenter(LoginControl.View view) {
        this.view = view;
        model = new LoginModel();
    }

    @Override
    public void onDestroy() {
        model.onDestroy();
    }

    @Override
    public String login(final String user, final String paw) {

        // 身份模拟
//        final int identity = Integer.parseInt(user);
        // 密码模拟
//        final boolean pawOK = "123456".equals(paw);

        L.i("user = " + user + ", paw = " + paw + ", S.md5(paw) = " + S.md5(paw));
        model.requestLogin(user, S.md5(paw), new MyCallback.HTTPCallback() {

            @Override
            public void callback(Headers headers, int code, String body) {
                L.d("code = " + code + ", body = " + body);
                if (code == 200) {

                    try {
                        // 假数据
                        if (API.OFFLINE) body = API.Service.login;
                        JSONObject jsonObject = new JSONObject(body);
                        L.i("仅登陆成功返回" + body);
                        /*final String id = jsonObject.getJSONObject("result").getString("id");
                        L.i("唯一id===>"+id);*/

                        if ("change".equals(jsonObject.getString("succ"))) {
                            view.resetPaw();
                        } else if ("ok".equals(jsonObject.getString("succ"))) {
                            final String id = jsonObject.getJSONObject("result").getString("id");
                            L.i("唯一id===>" + id);
                            model.queryRoles(new MyCallback.HTTPCallback() {
                                @Override
                                public void callback(Headers headers, int code, String body) {
                                    L.i("headers = " + headers + ", code = " + code + ", body = " + body);
                                    L.i("登陆并获取身份成功返回" + body);
                                    if (code == 200) {
                                        try {

                                            if (API.OFFLINE) body = API.Service.queryRoles;
                                            JSONObject jsonObject = new JSONObject(body);
                                            if ("ok".equals(jsonObject.getString("succ"))) {
                                                String roleCode = jsonObject.getJSONArray("result").getJSONObject(0).getString("roleCode");

                                                L.i(roleCode);
                                                view.loginSucceed(roleCode, "登录成功", id);

                                            } else {
                                                L.e("登录失败===》获取用户身份非ok");
                                                view.loginFailure(jsonObject.getString("msg"));
                                                L.w(jsonObject.getString("msg"));
                                            }
                                        } catch (Exception e) {
                                            e.printStackTrace();
                                            L.e("登录失败===》获取用户身份异常");
                                            view.loginFailure("登录失败");
                                        }
                                    } else {
                                        L.e("登录失败===》获取用户身份非200");
                                        view.loginFailure("登录失败");
                                    }
                                }
                            });


                        } else {
                            L.e("登录失败===》纯登陆返回的不是ok也不是change");
                            view.loginFailure(jsonObject.getString("msg"));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        L.e("登录失败===》纯登陆异常");
                        view.loginFailure("登录失败");
                    }
                } else {
                    L.e("登录失败===》纯登陆非200");
                    view.loginFailure("登录失败");
                }
            }
        });

        return "登录中...";
    }
}

==============================================================