Android MVP framework package

reference

Android Activity and Fragment base class encapsulation

Android ButterKnife basics

structure

Basic framework

BaseActivity

public abstract class BaseActivity extends AppCompatActivity implements IBaseView {
    
    

    /**
     * 获取布局文件ID
     *
     * @return 返回布局ID
     */
    protected abstract int getContentViewId();

    /**
     * 初始化控件
     */
    protected void initView() {
    
    

    }

    /**
     * 初始化数据
     */
    protected void initData() {
    
    
    }

    /**
     * 初始化设备
     */
    protected void initDevice() {
    
    
    }

    /**
     * 初始化监听器
     */
    protected void addListeners() {
    
    
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        setContentView(getContentViewId());
        //绑定ButterKnife
        ButterKnife.bind(this);
        init();
    }

    /**
     * 初始化
     */
    private void init(){
    
    
        initView();
        initData();
        initDevice();
        addListeners();
    }

    @Override
    public Context getContext() {
    
    
        return this;
    }
}

BaseFragment

public abstract class BaseFragment extends Fragment implements IBaseView {
    
    

    private Unbinder unbinder;

    /**
     * 获取布局文件ID
     * @return 返回布局ID
     */
    protected abstract int getContentViewId();

    /**
     * 初始化控件
     */
    protected void initView() {
    
    

    }

    /**
     * 初始化数据
     */
    protected void initData() {
    
    
    }

    /**
     * 初始化设备
     */
    protected void initDevice() {
    
    
    }

    /**
     * 初始化监听器
     */
    protected void addListeners() {
    
    
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    
    
        View rootView = inflater.inflate(getContentViewId(), container, false);
        unbinder = ButterKnife.bind(this, rootView);
        return rootView;
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
    
    
        super.onViewCreated(view, savedInstanceState);
        init();
    }

    /**
     * 初始化
     */
    private void init(){
    
    
        initView();
        initData();
        initDevice();
        addListeners();
    }

    @Override
    public Context getContext() {
    
    
        return getActivity();
    }

    @Override
    public void onDestroyView() {
    
    
        super.onDestroyView();
        unbinder.unbind();
    }
}

IBaseView

public interface IBaseView {
    
    
    Context getContext();
}

Static proxy

IProxy

public interface IProxy {
    
    

    void bindPresenter();

    void unbindPresenter();
}

ProxyImpl

public class ProxyImpl implements IProxy {
    
    

    private IBaseView mView;
    private List<BaseMvpPresenter> mInjectPresenters;

    public ProxyImpl(IBaseView view) {
    
    
        this.mView = view;
        mInjectPresenters = new ArrayList<>();
    }


    @SuppressWarnings({
    
    "unchecked", "TryWithIdenticalCatches"})
    @Override
    public void bindPresenter() {
    
    
        //获得已经申明的变量，包括私有的
        Field[] fields = mView.getClass().getDeclaredFields();
        for (Field field : fields) {
    
    
            //获取变量上面的注解类型
            InjectPresenter injectPresenter = field.getAnnotation(InjectPresenter.class);
            if (injectPresenter != null) {
    
    
                try {
    
    
                    Class<? extends BaseMvpPresenter> type = (Class<? extends BaseMvpPresenter>) field.getType();
                    BaseMvpPresenter mInjectPresenter = type.newInstance();
                    mInjectPresenter.attachView(mView);
                    field.setAccessible(true);
                    field.set(mView, mInjectPresenter);
                    mInjectPresenters.add(mInjectPresenter);
                } catch (IllegalAccessException e) {
    
    
                    e.printStackTrace();
                } catch (InstantiationException e) {
    
    
                    e.printStackTrace();
                } catch (ClassCastException e) {
    
    
                    e.printStackTrace();
                    throw new RuntimeException("SubClass must extends Class:BaseMvpPresenter");
                }
            }
        }
    }

    @Override
    public void unbindPresenter() {
    
    
        for (BaseMvpPresenter presenter : mInjectPresenters) {
    
    
            presenter.detachView();
        }
        mInjectPresenters.clear();
        mInjectPresenters = null;
    }
}

ProxyActivity

public class ProxyActivity<V extends IBaseView> extends ProxyImpl {
    
    

    public ProxyActivity(V view) {
    
    
        super(view);
    }
}

ProxyFragment

public class ProxyFragment<V extends IBaseView> extends ProxyImpl {
    
    
    public ProxyFragment(V view) {
    
    
        super(view);
    }
}

Annotation interface

InjectPresenter

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface InjectPresenter {
    
    
}

MVP framework

BaseMvpActivity

public abstract class BaseMvpActivity extends BaseActivity {
    
    


    private ProxyActivity mProxyActivity;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        mProxyActivity = createProxyActivity();
        mProxyActivity.bindPresenter();
    }

    @SuppressWarnings("unchecked")
    private ProxyActivity createProxyActivity() {
    
    
        if (mProxyActivity == null) {
    
    
            return new ProxyActivity(this);
        }
        return mProxyActivity;
    }

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

BaseMvpFragment

public abstract class BaseMvpFragment extends BaseFragment {
    
    

    private ProxyFragment mProxyFragment;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
    
    
        mProxyFragment = createProxyFragment();
        mProxyFragment.bindPresenter();
        return super.onCreateView(inflater, container, savedInstanceState);
    }

    @SuppressWarnings("unchecked")
    private ProxyFragment createProxyFragment() {
    
    
        if (mProxyFragment == null) {
    
    
            return new ProxyFragment(this);
        }
        return mProxyFragment;
    }

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

IBasePresenter

public interface IBasePresenter<V extends IBaseView> {
    
    
    /**
     * 创建视图
     * @param view 视图
     */
    void attachView(V view);

    /**
     * 销毁视图
     */
    void detachView();
}

BaseMvpPresenter

public abstract class BaseMvpPresenter<V extends IBaseView, M extends BaseMvpModel> implements IBasePresenter {
    
    

    private SoftReference<IBaseView> mReferenceView;
    private V mProxyView;
    private M mModel;

    @SuppressWarnings({
    
    "unchecked", "TryWithIdenticalCatches"})
    @Override
    public void attachView(IBaseView view) {
    
    
        //使用软引用创建对象
        mReferenceView = new SoftReference<>(view);
        //使用动态代理做统一的逻辑判断 aop 思想
        mProxyView = (V) Proxy.newProxyInstance(view.getClass().getClassLoader(), view.getClass().getInterfaces(), new InvocationHandler() {
    
    
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
    
    
                if (mReferenceView == null || mReferenceView.get() == null) {
    
    
                    return null;
                }
                return method.invoke(mReferenceView.get(), objects);
            }
        });

        //通过获得泛型类的父类，拿到泛型的接口类实例，通过反射来实例化 model
        ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        if (type != null) {
    
    
            Type[] types = type.getActualTypeArguments();
            try {
    
    
                mModel = (M) ((Class<?>) types[1]).newInstance();
            } catch (IllegalAccessException e) {
    
    
                e.printStackTrace();
            } catch (InstantiationException e) {
    
    
                e.printStackTrace();
            }
        }

    }

    @SuppressWarnings("unchecked")
    public V getView() {
    
    
        return mProxyView;
    }

    protected M getModel() {
    
    
        return mModel;
    }

    @Override
    public void detachView() {
    
    
        mReferenceView.clear();
        mReferenceView = null;
    }
}

BaseMvpModel

public abstract class BaseMvpModel {
    
    
}