Android——MVP架构模式之入门demo

什么是MVP？

MVP（Model - View - Presenter ， 模型 - 视图 - 表示器）模式则是由IBM开发出来的一个针对C++和java的编程模型，大概出现于2000年，是MVC模式的一个变种，主要用来隔离UI、UI逻辑和业务逻辑，数据。

MVP与MVC的区别？

MVP——Model-View-presenter 它是MVC模式的变种，UI容易变化的，且是多样的，一样的数据会有N种显示方式，业务逻辑也是比较容易变化的，为了使得Appcation具有较大的弹性，我们期望将UI、逻辑（UI的逻辑和业务逻辑） 和数据隔离离开来，而MVP是一个很好的选择。
Presenter代替了Controller，它比Controller担当更多的任务，也更加复杂，Presenter处理事件，执行相应的逻辑，这些逻辑映射到Model的Command以操作Model，那些处理UI如何工作的代码基本上都位于Presenter中。Presenter如同一个乐队的指挥家，表现和协调整个Appcation，它负责创建和协调其他对象。
Model和View使用Observer模式进行沟通，而Presenter和View则使用Mediator模式进行通信，Presenter操作Model则使用Command模式来进行的。基本设计和MVC相同，Model存储数据，View是Model的表现，Presenter协调两者之间的通信。在MVP中View接收到事件，然后会将它们传递到Presenter，如何具体处理这些事件，将由Presenter来完成。

MVP的设计图如下：

MVC设计图：

为什么使用MVP模式？MVP模式是怎样工作的呢？
请参考以下两篇文章：

Android中使用MVP模式简介

MVP模式在Android开发中的应用

关于以上的讲述，还有几篇比较好的文章，大家可以深入了解：
MVP：
Android 架构演化之路

Android中的MVP

The Clean Architecture

MVC：
框架模式 MVC 在Android中的使用

从MVC框架看MVC架构的设计

走入我们今天的主题，MVP模式的demo项目结构：

只做了一个简单的登录操作，下面看下整体效果：

接下来我们看下代码：
LoginActivity类：

package com.lai.mvp.app.Login;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.TextView;

import com.lai.mvp.app.R;
import com.lai.mvp.app.main.MainActivity;
import com.lai.mvp.app.register.RegisterActivity;

public class LoginActivity extends Activity implements LoginView, View.OnClickListener {

    private ProgressBar progressBar;
    private EditText username;
    private EditText password;
    private LoginPresenter presenter;
    private TextView tv_register;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        progressBar = (ProgressBar) findViewById(R.id.progress);
        username = (EditText) findViewById(R.id.username);
        password = (EditText) findViewById(R.id.password);
        tv_register = (TextView) findViewById(R.id.tv_register);
        findViewById(R.id.button).setOnClickListener(this);

        presenter = new LoginPresenterImpl(this);
        //这个注册的textView只是为了测试浮动提示的效果
        tv_register.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(LoginActivity.this, RegisterActivity.class));
            }
        });
    }

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

    @Override
    public void showProgress() {
        progressBar.setVisibility(View.VISIBLE);
    }

    @Override
    public void hideProgress() {
        progressBar.setVisibility(View.GONE);
    }

    @Override
    public void setUsernameError() {
        username.setError(getString(R.string.username_error));
    }

    @Override
    public void setPasswordError() {
        password.setError(getString(R.string.password_error));
    }

    @Override
    public void navigateToHome() {
        startActivity(new Intent(this, MainActivity.class));
        finish();
    }

    @Override
    public void onClick(View v) {
        presenter.validateCredentials(username.getText().toString(), password.getText().toString());
    }
}

登录界面操作非常简单，实现了LoginView中的方法，下面是LoginView接口：

package com.lai.mvp.app.Login;

public interface LoginView {
    void showProgress();//显示progress

    void hideProgress();//隐藏progress

    void setUsernameError();//用户名错误

    void setPasswordError();//密码错误

    void navigateToHome();//成功进入主页
}

Model操作也很简单，不废话了，直入主题：
LoginModel：

package com.lai.mvp.app.Login;

public interface LoginModel {

    interface OnLoginFinishedListener {
        void onUsernameError();//用户名错误

        void onPasswordError();//密码错误

        void onSuccess();//成功
    }
    //连接登录时的操作
    void login(String username, String password, OnLoginFinishedListener listener);

}

实现Model中的接口：
LoginModelImpl：

package com.lai.mvp.app.Login;

import android.os.Handler;
import android.text.TextUtils;

public class LoginModelImpl implements LoginModel {

    @Override
    public void login(final String username, final String password, final OnLoginFinishedListener listener) {
       //模拟登录。创建一个2s后处理程序的操作
        new Handler().postDelayed(new Runnable() {
            @Override public void run() {
                boolean error = false;
                //判断字符是否为空
                if (TextUtils.isEmpty(username)){
                    listener.onUsernameError();
                    error = true;
                }
                if (TextUtils.isEmpty(password)){
                    listener.onPasswordError();
                    error = true;
                }
                if (!error){
                    listener.onSuccess();
                }
            }
        }, 2000);
    }
}

这边做了字符是否为空的判断，与后面的LoginPresenterImpl 构造中实现通信，在LoginActivity中直接操作用户名密码为空后的操作，效果如下：

这里说明了Model和View必须要通过Presenter才能完成通信，所以Presenter是连接View和Model的中间者，我也是用了接口的方式去实现了，看代码：
LoginPresenter：

package com.lai.mvp.app.Login;

public interface LoginPresenter {

    void validateCredentials(String username, String password);//验证用户名密码

    void onDestroy();
}

而需要操作的事情，全部放在PresenterImpl中，在前面的LoginActivity中也并没有看到一些逻辑性的操作：
LoginPresenterImpl ：

package com.lai.mvp.app.Login;

public class LoginPresenterImpl implements LoginPresenter, LoginModel.OnLoginFinishedListener {

    private LoginView loginView;
    private LoginModel loginModel;

    public LoginPresenterImpl(LoginView loginView) {
        this.loginView = loginView;
        this.loginModel = new LoginModelImpl();
    }

    /**
     * 校验用户名密码
     * @param username
     * @param password
     */
    @Override
    public void validateCredentials(String username, String password) {
        if (loginView != null) {
            loginView.showProgress();
        }
        loginModel.login(username, password, this);
    }

    @Override
    public void onDestroy() {
        loginView = null;
    }
    //用户名错误
    @Override
    public void onUsernameError() {
        if (loginView != null) {
            loginView.setUsernameError();
            loginView.hideProgress();
        }
    }
    //密码错误
    @Override
    public void onPasswordError() {
        if (loginView != null) {
            loginView.setPasswordError();
            loginView.hideProgress();
        }
    }
    //成功之后
    @Override
    public void onSuccess() {
        if (loginView != null) {
            loginView.navigateToHome();
        }
    }
}

在Activity中（也就是View），它是直接跟Presenter接触的，并不是跟Model碰面，在设计图中可以看出，加载代码的逻辑，就更清晰了。在LoginActivity中也有了LoginPresenter presenter=new LoginPresenterImpl(this)；去完成与Presenter的交接，所以整个流程也就这样形成了。

MainActivity的操作也是一样的，代码我就不贴出来了，整体来说，代码清晰度好了很多（逻辑方面，不是指代码量）,平时在开发中，我们大多都是把所有的逻辑操作，写在LoginActivity中，不仅代码量大，而且看起来也比较复杂，但是，请注意，我们虽然只做了一个简单的登录操作，有没有发现，我们项目中，多出了很多class？所以MVP架构模式只适合大点的项目，简单的demo没必要，这点需要慎重，如果你的项目用了MVP模式，必须要写下去。

好了，在这当中我还插了一个自定义view的小例子，先看下效果：

这个view类通用的，贴出来给大家：

package com.lai.mvp.app.view;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.TypedArray;
import android.os.Build;
import android.os.Bundle;
import android.os.Parcelable;
import android.text.Editable;
import android.text.InputType;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.View;
import android.widget.EditText;
import android.widget.FrameLayout;
import android.widget.TextView;

import com.lai.mvp.app.R;

public class FloatLabel extends FrameLayout {

    private static final String SAVE_STATE_KEY_EDIT_TEXT = "saveStateEditText";
    private static final String SAVE_STATE_KEY_LABEL = "saveStateLabel";
    private static final String SAVE_STATE_PARENT = "saveStateParent";
    private static final String SAVE_STATE_TAG = "saveStateTag";
    private static final String SAVE_STATE_KEY_FOCUS = "saveStateFocus";

    /**
     * 参照编辑
     */
    private EditText mEditText;

    /**
     * 当初始化完成后，孩子的意见可以不再增加
     */
    private boolean mInitComplete = false;

    /**
     * 参考用作标签的方法
     */
    private TextView mLabel;

    /**
     * label标签消失
     */
    private LabelAnimator mLabelAnimator = new DefaultLabelAnimator();

    /**
     *  label是否显示
     */
    private boolean mLabelShowing;

    /**
     * 保存状态，如果有任何等待恢复
     */
    private Bundle mSavedState;

    /**
     *
     * 一旦更新文本，则设置为true
     */
    private boolean mSkipAnimation = false;

    /**
     * 对标签的TextView提供自定义动画界面。
     */
    public interface LabelAnimator {

        /**
         * 当标签变成可见的时候
         *
         * @param label TextView不可见
         */
        public void onDisplayLabel(View label);

        /**
         * 当标签变成不可见的时候
         *
         * @param label
         */
        public void onHideLabel(View label);
    }

    public FloatLabel(Context context) {
        this(context, null, 0);
    }

    public FloatLabel(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public FloatLabel(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context, attrs, defStyle);
    }

    @Override
    public void addView(View child) {
        if (mInitComplete) {
            throw new UnsupportedOperationException("You cannot add child views to a FloatLabel");
        } else {
            super.addView(child);
        }
    }

    @Override
    public void addView(View child, int index) {
        if (mInitComplete) {
            throw new UnsupportedOperationException("You cannot add child views to a FloatLabel");
        } else {
            super.addView(child, index);
        }
    }

    @Override
    public void addView(View child, int index, android.view.ViewGroup.LayoutParams params) {
        if (mInitComplete) {
            throw new UnsupportedOperationException("You cannot add child views to a FloatLabel");
        } else {
            super.addView(child, index, params);
        }
    }

    @Override
    public void addView(View child, int width, int height) {
        if (mInitComplete) {
            throw new UnsupportedOperationException("You cannot add child views to a FloatLabel");
        } else {
            super.addView(child, width, height);
        }
    }

    @Override
    public void addView(View child, android.view.ViewGroup.LayoutParams params) {
        if (mInitComplete) {
            throw new UnsupportedOperationException("You cannot add child views to a FloatLabel");
        } else {
            super.addView(child, params);
        }
    }

    /**
     * Returns the EditText portion of this View
     *
     * @return the EditText portion of this View
     */
    public EditText getEditText() {
        return mEditText;
    }

    /**
     * Returns the label portion of this View
     *
     * @return the label portion of this View
     */
    public TextView getLabel() {
        return mLabel;
    }

    /**
     * Sets the text to be displayed above the EditText if the EditText is
     * nonempty or as the EditText hint if it is empty
     *
     * @param resid int String resource ID
     */
    public void setLabel(int resid) {
        setLabel(getContext().getString(resid));
    }

    /**
     * Sets the text to be displayed above the EditText if the EditText is
     * nonempty or as the EditText hint if it is empty
     *
     * @param hint CharSequence to set as the label
     */
    public void setLabel(CharSequence hint) {
        mEditText.setHint(hint);
        mLabel.setText(hint);
    }

    /**
     * Specifies a new LabelAnimator to handle calls to show/hide the label
     *
     * @param labelAnimator LabelAnimator to use; null causes use of the default LabelAnimator
     */
    public void setLabelAnimator(LabelAnimator labelAnimator) {
        if (labelAnimator == null) {
            mLabelAnimator = new DefaultLabelAnimator();
        } else {
            mLabelAnimator = labelAnimator;
        }
    }

    /**
     * Sets the EditText's text with animation
     *
     * @param resid int String resource ID
     */
    public void setText(int resid) {
        mEditText.setText(resid);
    }

    /**
     * Sets the EditText's text with label animation
     *
     * @param text  char[] text
     * @param start int start of char array to use
     * @param len   int characters to use from the array
     */
    public void setText(char[] text, int start, int len) {
        mEditText.setText(text, start, len);
    }

    /**
     * Sets the EditText's text with label animation
     *
     * @param resid int String resource ID
     * @param type  TextView.BufferType
     */
    public void setText(int resid, TextView.BufferType type) {
        mEditText.setText(resid, type);
    }

    /**
     * Sets the EditText's text with label animation
     *
     * @param text CharSequence to set
     */
    public void setText(CharSequence text) {
        mEditText.setText(text);
    }

    /**
     * Sets the EditText's text with label animation
     *
     * @param text CharSequence to set
     * @param type TextView.BufferType
     */
    public void setText(CharSequence text, TextView.BufferType type) {
        mEditText.setText(text, type);
    }

    /**
     * Sets the EditText's text without animating the label
     *
     * @param resid int String resource ID
     */
    public void setTextWithoutAnimation(int resid) {
        mSkipAnimation = true;
        mEditText.setText(resid);
    }

    /**
     * Sets the EditText's text without animating the label
     *
     * @param text  char[] text
     * @param start int start of char array to use
     * @param len   int characters to use from the array
     */
    public void setTextWithoutAnimation(char[] text, int start, int len) {
        mSkipAnimation = true;
        mEditText.setText(text, start, len);
    }

    /**
     * Sets the EditText's text without animating the label
     *
     * @param resid int String resource ID
     * @param type  TextView.BufferType
     */
    public void setTextWithoutAnimation(int resid, TextView.BufferType type) {
        mSkipAnimation = true;
        mEditText.setText(resid, type);
    }

    /**
     * Sets the EditText's text without animating the label
     *
     * @param text CharSequence to set
     */
    public void setTextWithoutAnimation(CharSequence text) {
        mSkipAnimation = true;
        mEditText.setText(text);
    }

    /**
     * Sets the EditText's text without animating the label
     *
     * @param text CharSequence to set
     * @param type TextView.BufferType
     */
    public void setTextWithoutAnimation(CharSequence text, TextView.BufferType type) {
        mSkipAnimation = true;
        mEditText.setText(text, type);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        final int childLeft = getPaddingLeft();
        final int childRight = right - left - getPaddingRight();

        int childTop = getPaddingTop();
        final int childBottom = bottom - top - getPaddingBottom();

        layoutChild(mLabel, childLeft, childTop, childRight, childBottom);
        layoutChild(mEditText, childLeft, childTop + mLabel.getMeasuredHeight(), childRight, childBottom);
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
    private void layoutChild(View child, int parentLeft, int parentTop, int parentRight, int parentBottom) {
        if (child.getVisibility() != GONE) {
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();

            final int width = child.getMeasuredWidth();
            final int height = child.getMeasuredHeight();

            int childLeft;
            final int childTop = parentTop + lp.topMargin;

            int gravity = lp.gravity;
            if (gravity == -1) {
                gravity = Gravity.TOP | Gravity.START;
            }

            final int layoutDirection;
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
                layoutDirection = LAYOUT_DIRECTION_LTR;
            } else {
                layoutDirection = getLayoutDirection();
            }

            final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);

            switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                case Gravity.CENTER_HORIZONTAL:
                    childLeft = parentLeft + (parentRight - parentLeft - width) / 2 + lp.leftMargin - lp.rightMargin;
                    break;
                case Gravity.END:
                    childLeft = parentRight - width - lp.rightMargin;
                    break;
                case Gravity.START:
                default:
                    childLeft = parentLeft + lp.leftMargin;
            }

            child.layout(childLeft, childTop, childLeft + width, childTop + height);
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        // Restore any state that's been pending before measuring
        if (mSavedState != null) {
            Parcelable childState = mSavedState.getParcelable(SAVE_STATE_KEY_EDIT_TEXT);
            mEditText.onRestoreInstanceState(childState);
            childState = mSavedState.getParcelable(SAVE_STATE_KEY_LABEL);
            mLabel.onRestoreInstanceState(childState);
            if (mSavedState.getBoolean(SAVE_STATE_KEY_FOCUS, false)) {
                mEditText.requestFocus();
            }
            mSavedState = null;
        }
        measureChild(mEditText, widthMeasureSpec, heightMeasureSpec);
        measureChild(mLabel, widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension(measureWidth(widthMeasureSpec), measureHeight(heightMeasureSpec));
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        if (state instanceof Bundle) {
            final Bundle savedState = (Bundle) state;
            if (savedState.getBoolean(SAVE_STATE_TAG, false)) {
                // Save our state for later since children will have theirs restored after this
                // and having more than one FloatLabel in an Activity or Fragment means you have
                // multiple views of the same ID
                mSavedState = savedState;
                super.onRestoreInstanceState(savedState.getParcelable(SAVE_STATE_PARENT));
                return;
            }
        }

        super.onRestoreInstanceState(state);
    }

    @Override
    protected Parcelable onSaveInstanceState() {
        final Parcelable superState = super.onSaveInstanceState();
        final Bundle saveState = new Bundle();
        saveState.putParcelable(SAVE_STATE_KEY_EDIT_TEXT, mEditText.onSaveInstanceState());
        saveState.putParcelable(SAVE_STATE_KEY_LABEL, mLabel.onSaveInstanceState());
        saveState.putBoolean(SAVE_STATE_KEY_FOCUS, mEditText.isFocused());
        saveState.putBoolean(SAVE_STATE_TAG, true);
        saveState.putParcelable(SAVE_STATE_PARENT, superState);

        return saveState;
    }

    private int measureHeight(int heightMeasureSpec) {
        int specMode = MeasureSpec.getMode(heightMeasureSpec);
        int specSize = MeasureSpec.getSize(heightMeasureSpec);

        int result = 0;
        if (specMode == MeasureSpec.EXACTLY) {
            result = specSize;
        } else {
            result = mEditText.getMeasuredHeight() + mLabel.getMeasuredHeight();
            result += getPaddingTop() + getPaddingBottom();
            result = Math.max(result, getSuggestedMinimumHeight());

            if (specMode == MeasureSpec.AT_MOST) {
                result = Math.min(result, specSize);
            }
        }

        return result;
    }

    private int measureWidth(int widthMeasureSpec) {
        int specMode = MeasureSpec.getMode(widthMeasureSpec);
        int specSize = MeasureSpec.getSize(widthMeasureSpec);

        int result = 0;
        if (specMode == MeasureSpec.EXACTLY) {
            result = specSize;
        } else {
            result = Math.max(mEditText.getMeasuredWidth(), mLabel.getMeasuredWidth());
            result = Math.max(result, getSuggestedMinimumWidth());
            result += getPaddingLeft() + getPaddingRight();
            if (specMode == MeasureSpec.AT_MOST) {
                result = Math.min(result, specSize);
            }
        }

        return result;
    }

    /**
     * Initializes the view's default values and values from attrs, if not null
     *
     * @param context  Context to access styled attributes
     * @param attrs    AttributeSet from constructor or null
     * @param defStyle int resource ID of style to use for defaults
     */
    private void init(Context context, AttributeSet attrs, int defStyle) {
        // Load custom attributes
        final int layout;
        int editTextId = R.id.edit_text;
        int floatLabelId = R.id.float_label;
        final CharSequence text;
        final CharSequence hint;
        final ColorStateList hintColor;
        final int floatLabelColor;
        final int imeOptions;
        final int inputType;
        final int nextFocusDownId;
        final int nextFocusForwardId;
        final int nextFocusLeftId;
        final int nextFocusRightId;
        final int nextFocusUpId;

        if (attrs == null) {
            layout = R.layout.float_label;
            text = null;
            hint = null;
            hintColor = null;
            floatLabelColor = 0;
            imeOptions = 0;
            inputType = 0;
            nextFocusDownId = NO_ID;
            nextFocusForwardId = NO_ID;
            nextFocusLeftId = NO_ID;
            nextFocusRightId = NO_ID;
            nextFocusUpId = NO_ID;
        } else {
            final TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.FloatLabel, defStyle, 0);

            // Main attributes
            layout = a.getResourceId(R.styleable.FloatLabel_android_layout, R.layout.float_label);
            editTextId = a.getResourceId(R.styleable.FloatLabel_editTextId, R.id.edit_text);
            floatLabelId = a.getResourceId(R.styleable.FloatLabel_labelId, R.id.float_label);
            text = a.getText(R.styleable.FloatLabel_android_text);
            hint = a.getText(R.styleable.FloatLabel_android_hint);
            hintColor = a.getColorStateList(R.styleable.FloatLabel_android_textColorHint);
            floatLabelColor = a.getColor(R.styleable.FloatLabel_floatLabelColor, 0);
            imeOptions = a.getInt(R.styleable.FloatLabel_android_imeOptions, 0);
            inputType = a.getInt(R.styleable.FloatLabel_android_inputType, InputType.TYPE_CLASS_TEXT);

            // Next focus views
            nextFocusDownId = a.getResourceId(R.styleable.FloatLabel_android_nextFocusDown, NO_ID);
            nextFocusForwardId = a.getResourceId(R.styleable.FloatLabel_android_nextFocusForward, NO_ID);
            nextFocusLeftId = a.getResourceId(R.styleable.FloatLabel_android_nextFocusLeft, NO_ID);
            nextFocusRightId = a.getResourceId(R.styleable.FloatLabel_android_nextFocusRight, NO_ID);
            nextFocusUpId = a.getResourceId(R.styleable.FloatLabel_android_nextFocusUp, NO_ID);

            // Done with TypedArray
            a.recycle();
        }

        inflate(context, layout, this);
        mEditText = (EditText) findViewById(editTextId);
        if (mEditText == null) {
            // fallback to default value
            mEditText = (EditText) findViewById(R.id.edit_text);
        }
        if (mEditText == null) {
            throw new RuntimeException(
                    "Your layout must have an EditText whose ID is @id/edit_text");
        }
        if (editTextId != R.id.edit_text) {
            mEditText.setId(editTextId);
        }
        mEditText.setHint(hint);
        mEditText.setText(text);
        if (hintColor != null) {
            mEditText.setHintTextColor(hintColor);
        }
        if (imeOptions != 0) {
            mEditText.setImeOptions(imeOptions);
        }
        if (inputType != 0) {
            mEditText.setInputType(inputType);
        }
        // Set all next focus views
        mEditText.setNextFocusDownId(nextFocusDownId);
        mEditText.setNextFocusForwardId(nextFocusForwardId);
        mEditText.setNextFocusLeftId(nextFocusLeftId);
        mEditText.setNextFocusRightId(nextFocusRightId);
        mEditText.setNextFocusUpId(nextFocusUpId);

        // Set up the label view
        mLabel = (TextView) findViewById(floatLabelId);
        if (mLabel == null) {
            // fallback to default value
            mLabel = (TextView) findViewById(R.id.float_label);
        }
        if (mLabel == null) {
            throw new RuntimeException(
                    "Your layout must have a TextView whose ID is @id/float_label");
        }
        if (floatLabelId != R.id.float_label) {
            mLabel.setId(floatLabelId);
        }
        mLabel.setText(mEditText.getHint());
        if (floatLabelColor != 0)
            mLabel.setTextColor(floatLabelColor);

        // Listen to EditText to know when it is empty or nonempty
        mEditText.addTextChangedListener(new EditTextWatcher());

        // Check current state of EditText
        if (mEditText.getText().length() == 0) {
            mLabel.setAlpha(0);
            mLabelShowing = false;
        } else {
            mLabel.setVisibility(View.VISIBLE);
            mLabelShowing = true;
        }

        // Mark init as complete to prevent accidentally breaking the view by
        // adding children
        mInitComplete = true;
    }

    /**
     * LabelAnimator that uses the traditional float label Y shift and fade.
     *
     * @author Ian G. Clifton
     */
    private static class DefaultLabelAnimator implements LabelAnimator {

        @Override
        public void onDisplayLabel(View label) {
            final float offset = label.getHeight() / 2;
            final float currentY = label.getY();
            if (currentY != offset) {
                label.setY(offset);
            }
            label.animate().alpha(1).y(0);
        }

        @Override
        public void onHideLabel(View label) {
            final float offset = label.getHeight() / 2;
            final float currentY = label.getY();
            if (currentY != 0) {
                label.setY(0);
            }
            label.animate().alpha(0).y(offset);
        }
    }

    /**
     * TextWatcher that notifies FloatLabel when the EditText changes between
     * having text and not having text or vice versa.
     *
     * @author Ian G. Clifton
     */
    private class EditTextWatcher implements TextWatcher {
        @Override
        public void afterTextChanged(Editable s) {
            if (mSkipAnimation) {
                mSkipAnimation = false;
                if (s.length() == 0) {
                    // TextView label should be gone
                    if (mLabelShowing) {
                        mLabel.setAlpha(0);
                        mLabelShowing = false;
                    }
                } else if (!mLabelShowing) {
                    // TextView label should be visible
                    mLabel.setAlpha(1);
                    mLabel.setY(0);
                    mLabelShowing = true;
                }
                return;
            }
            if (s.length() == 0) {
                // Text is empty; TextView label should be invisible
                if (mLabelShowing) {
                    mLabelAnimator.onHideLabel(mLabel);
                    mLabelShowing = false;
                }
            } else if (!mLabelShowing) {
                // Text is nonempty; TextView label should be visible
                mLabelShowing = true;
                mLabelAnimator.onDisplayLabel(mLabel);
            }
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            // Ignored
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            // Ignored
        }
    }
}

在values新建的attrs.xml中添加如下：

<declare-styleable name="FloatLabel">
        <attr name="android:hint" />
        <attr name="android:imeOptions" />
        <attr name="android:inputType" />
        <attr name="android:layout" />
        <attr name="android:nextFocusDown" />
        <attr name="android:nextFocusForward" />
        <attr name="android:nextFocusLeft" />
        <attr name="android:nextFocusRight" />
        <attr name="android:nextFocusUp" />
        <attr name="android:text" />
        <attr name="android:textColorHint" />
        <attr name="floatLabelColor" format="color" />
        <attr name="labelId" format="reference" />
        <attr name="editTextId" format="reference" />
    </declare-styleable>

再新建一个ids.xml，加上：

    <item type="id" name="float_label" />
    <item type="id" name="edit_text" />

然后在layout中写一个float_label.xml 添加以下布局：

<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android">

    <TextView
        android:id="@id/float_label"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:focusable="false"
        android:focusableInTouchMode="false"
        android:lines="1"
        android:textIsSelectable="true"
        android:textAppearance="?android:attr/textAppearanceSmall" />

    <EditText
        android:id="@id/edit_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="-7dp"
        android:inputType="text|textAutoCorrect|textCapSentences|textAutoComplete" />

</merge>

之后就可以直接使用了，例如：

<com.lai.mvp.app.view.FloatLabel
        android:id="@+id/label_phone"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginLeft="10dip"
        android:layout_marginRight="10dip"
        android:layout_marginTop="10dip"
        android:hint="手机号"
        android:layout="@layout/float_label"
        app:floatLabelColor="#00f0ff"
        android:textColorHint="#c5c5c5"
       />

本篇结束了，源码下载地址如下：

下载地址