1 前言
很早就在开始关注Android的架构方面的东西了，在android开发中，我们不外乎这三种架构：MVC，MVP，MVVM。关于这三者的简单介绍如下：
- 1 MVC
MVC的经典架构如下：
MVC简单的来说就是通过Controller去操作Model层，同时去更新View层显示。另外View层也会与Model层有交互。造成这三者之间的耦合比较大。
比如我们在平常的Android开发中，View层就是xml文件以及各种控件，Controller角色由我们的Activity或者Fragment扮演，而model层就是各种数据及其封装了，我们在开发中一般来说是这样做得：
Activity或者Fragment： 初始化各种View，设置各种View的显示及绑定事件，加载Model层数据，根据各个控件的点击等动作，完成各个界面逻辑的炒作等，比如跳转界面，更改View显示等。
View: 控件事件处理，例如点击事件中做逻辑操作，一般需要更新Model层数据;控件更新显示等
Model： 数据的进一步处理，例如校验，组装，更改，以及对上层的封装等。
我们发现作为Controller的职责是在太多，而对某个View来说，也可以直接更新Model层，这就造成了Controller的代码量很大，我曾见过在项目中，一个Activity的代码量达到了2000多行的。这样的工程既不利于后期维护，也不利于测试。是在不是一个明智的选择。
- 2 MVP
作为一个MVC的改良版，MVP的结构如下：
View：主要负责界面的显示及跟数据无关的逻辑，比如设置控件的点击事件等
Presenter:主要负责View与Model的交互
Model:数据部分
MVP很好的解决了View层与Model层的分离，使之交互都是通过Presenter层来做，这样做得好处有以下几点：
1 便于单元测试，因为对于Model层或者Presenter来说，都是一些接口，便于编写测试用例
2 维护性提高，对于View层来说的改动不影响Presenter和Model层的改动。
最主要的好处就是以上两点，坏处也有以下几点：
1 代码量增加，特别是需要新增加View与Presenter，及Presenter类
2 View与 Presenter的交互的接口的粒度不好把握，这个需要深入的理解业务才能好好解决。
MVP的核心是：
View层不持有Model层对象任何引用，当然参数里面和临时变量里可以有Model层对象，只持有Presenter层对象引用，任何需要更新或者操作数据的，都间接通过Presenter对象去操作数据。而Model层想要操作View层是无法实现的，必须通过Presenter层。
Presenter层持有View层对象的引用，除此之外不持有其他的UI控件等的引用，Model层会把想要更新View的操作委托Presenter去操作，而Presenter层会把更新View操作交给View层对象去操作。
比如举个例子：
一个Activity上要显示一个TextView的内容，内容来源于数据库，这样一个需求用MVP来实现就是：
View层：
定义一个显示TextView内容的接口：
/**
* Created by qiyei2015 on 2017/4/1.
* 1273482124@qq.com
*/
public interface View {
void showText(String msg);
}然后Activity实现这个接口：
/**
* Created by qiyei2015 on 2017/4/1.
* 1273482124@qq.com
*/
public class MyActivity extends Activity implements View {
private TextView mTextView;
/**
* Presenter引用
*/
private MyPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_my);
mTextView = (TextView) findViewById(R.id.tv);
mPresenter = new MyPresenter(this);
}
/**
* UI 操作。显示text
* @param msg
*/
@Override
public void showText(String msg) {
mTextView.setText(msg);
}
}而Presenter的定义如下：
/**
* Created by qiyei2015 on 2017/3/29.
* 1273482124@qq.com
*/
public interface BasePresenter {
/**
* 用于View的初始化
*/
void start();
}这里定义一个BasePresenter中的start()表示数据初始化。
/**
* Created by qiyei2015 on 2017/4/1.
* 1273482124@qq.com
*/
public class MyPresenter implements BasePresenter{
private View mView;
@Override
public void start() {
//查询数据
String s = "hello this is a simple MVP";
mView.showText(s);
}
public MyPresenter(View view){
mView = view;
}
}这样，我们Presenter的代码也写完了，但是我们还需要注意一个问题，就是什么时候显示这个字符串呢？当然取决于我们的业务啦，注意，这里简写了Model层的代码。
我们一般在Activity的onResume()中去显示字符串，这样我们直接调用如下代码即可：
@Override
protected void onResume() {
super.onResume();
mPresenter.start();
}
可以看到，在View层，我们把操作转给了Presenter对象，而Presenter从Model层获取数据，再调用View层对象引用来更新UI。结果如下：
- 3 MVVM
MVVM最早是由微软提出的
从图中看出，它和MVP的区别貌似不大，只不过是presenter层换成了viewmodel层，还有一点就是view层和viewmodel层是相互绑定的关系，这意味着当你更新viewmodel层的数据的时候，view层会相应的变动ui。
我们很难去说MVP和MVVM这两个MVC的变种孰优孰劣，还是要具体情况具体分析。另外，关于MVVM我还不是很熟悉，后期再分析吧。
注：架构只是一种思维方式，不管是MVC，MVP，还是MVVM，都只是一种思考问题解决问题的思维，其目的是要解决编程过程中，模块内部高内聚，模块与模块之间低耦合，可维护性，易测试等问题
2 Google 官方MVP示例 todoapp解析
- 1todo功能解析
todo是一个android官方的用于展示MVP架构的例子，它的主要功能就是一个可以添加task的小程序。并且能展示task。四个界面（功能）：
其中，View层是Fragment来充当，另外，官方多了一个Contract(契约类)，主要用来管理View与Presenter的交互。项目的包结构如下：
另外：androidTest（UI层测试）、androidTestMock（UI层测试mock数据支持）、test（业务层单元测试）、mock（业务层单元测试mock数据支持）如下：
app以每个功能为一个包，界面、功能代码结构以及测试代码结构非常清晰。可作为我们在实际项目中的参考。
- 2项目总体架构图如下：
Fragment作为View，View和Presenter通过Activity来进行关联，Presenter对数据的调用是通过TasksRepository来完成的，而TasksRepository维护着它自己的数据源和实现。
现在我们开始分析：我们以列表界面的分析为例：
业务分析：
列表界面的业务主要有以下：
1 task列表的展示，没有就显示为空
2 点击Float bar 添加task
3 三个菜单的操作
我们主要分析：列表的展示及添加一个新的task这两个业务。
首先，我们先看两个类，BaseView与BasePresenter,分别是View与Presenter的基类。
package com.example.android.architecture.blueprints.todoapp;
public interface BaseView<T> {
/**
* 设置View的Presenter引用
* @param presenter
*/
void setPresenter(T presenter);
}setPresenter的调用时机是presenter实现类的构造函数中，通过View对象的引用来调用，这样就能保证View层中的Presenter对象引用能被赋值。如此View中的事件请求便通过调用presenter来实现。
package com.example.android.architecture.blueprints.todoapp;
public interface BasePresenter {
/**
* 一般在View的onCreate 或者onResume调用，用做初始化
*/
void start();
}该方法的作用是Presenter开始获取数据，一般做一些初始化或者启动的工作，其调用时机是在Fragment类的onResume方法中通过View层的Presenter引用来调用。
接下来，我们看Contract契约类（接口）,主要管理了View与Presenter的交互
使用契约类来统一管理view与presenter的所有的接口，这种方式使得view与presenter中有哪些功能，一目了然，维护起来也很方便。我们来看TasksContract
package com.example.android.architecture.blueprints.todoapp.tasks;
import android.support.annotation.NonNull;
import com.example.android.architecture.blueprints.todoapp.BaseView;
import com.example.android.architecture.blueprints.todoapp.data.Task;
import com.example.android.architecture.blueprints.todoapp.BasePresenter;
import java.util.List;
/**
* This specifies the contract between the view and the presenter.
*/
public interface TasksContract {
interface View extends BaseView<Presenter> {
void setLoadingIndicator(boolean active);
/**
* 根据 tasks显示 task列表
* @param tasks
*/
void showTasks(List<Task> tasks);
/**
* 添加一个Task
*/
void showAddTask();
/**
* 显示某个task详细信息
* @param taskId
*/
void showTaskDetailsUi(String taskId);
void showTaskMarkedComplete();
void showTaskMarkedActive();
void showCompletedTasksCleared();
void showLoadingTasksError();
void showNoTasks();
void showActiveFilterLabel();
void showCompletedFilterLabel();
void showAllFilterLabel();
void showNoActiveTasks();
void showNoCompletedTasks();
void showSuccessfullySavedMessage();
boolean isActive();
void showFilteringPopUpMenu();
}
interface Presenter extends BasePresenter {
void result(int requestCode, int resultCode);
/**
* 从Model层加载所有的task
* @param forceUpdate
*/
void loadTasks(boolean forceUpdate);
/**
* 添加一个新的task
*/
void addNewTask();
void openTaskDetails(@NonNull Task requestedTask);
void completeTask(@NonNull Task completedTask);
void activateTask(@NonNull Task activeTask);
void clearCompletedTasks();
void setFiltering(TasksFilterType requestType);
TasksFilterType getFiltering();
}
}可以看到，TaskContract里面定义了两个内部接口View与Presenter,分别描述了View与Presenter的行为及功能，可以参考上面的注释。
TaskFragment 这里作为View层实现了TasksContract.View接口，TaskPresenter作为Presenter层实现了TasksContract.Presenter接口。我们先来分析一下TaskActivity 这个类。
package com.example.android.architecture.blueprints.todoapp.tasks;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.VisibleForTesting;
import android.support.design.widget.NavigationView;
import android.support.test.espresso.IdlingResource;
import android.support.v4.view.GravityCompat;
import android.support.v4.widget.DrawerLayout;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.MenuItem;
import com.example.android.architecture.blueprints.todoapp.Injection;
import com.example.android.architecture.blueprints.todoapp.R;
import com.example.android.architecture.blueprints.todoapp.statistics.StatisticsActivity;
import com.example.android.architecture.blueprints.todoapp.util.ActivityUtils;
import com.example.android.architecture.blueprints.todoapp.util.EspressoIdlingResource;
public class TasksActivity extends AppCompatActivity {
private static final String CURRENT_FILTERING_KEY = "CURRENT_FILTERING_KEY";
private DrawerLayout mDrawerLayout;
private TasksPresenter mTasksPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.tasks_act);
// Set up the toolbar.
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
ActionBar ab = getSupportActionBar();
ab.setHomeAsUpIndicator(R.drawable.ic_menu);
ab.setDisplayHomeAsUpEnabled(true);
// Set up the navigation drawer.
mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
mDrawerLayout.setStatusBarBackground(R.color.colorPrimaryDark);
NavigationView navigationView = (NavigationView) findViewById(R.id.nav_view);
if (navigationView != null) {
setupDrawerContent(navigationView);
}
TasksFragment tasksFragment =
(TasksFragment) getSupportFragmentManager().findFragmentById(R.id.contentFrame);
if (tasksFragment == null) {
// Create the fragment
tasksFragment = TasksFragment.newInstance();
ActivityUtils.addFragmentToActivity(
getSupportFragmentManager(), tasksFragment, R.id.contentFrame);
}
// Create the presenter
mTasksPresenter = new TasksPresenter(
Injection.provideTasksRepository(getApplicationContext()), tasksFragment);
// Load previously saved state, if available.
if (savedInstanceState != null) {
TasksFilterType currentFiltering =
(TasksFilterType) savedInstanceState.getSerializable(CURRENT_FILTERING_KEY);
mTasksPresenter.setFiltering(currentFiltering);
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
outState.putSerializable(CURRENT_FILTERING_KEY, mTasksPresenter.getFiltering());
super.onSaveInstanceState(outState);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case android.R.id.home:
// Open the navigation drawer when the home icon is selected from the toolbar.
mDrawerLayout.openDrawer(GravityCompat.START);
return true;
}
return super.onOptionsItemSelected(item);
}
private void setupDrawerContent(NavigationView navigationView) {
navigationView.setNavigationItemSelectedListener(
new NavigationView.OnNavigationItemSelectedListener() {
@Override
public boolean onNavigationItemSelected(MenuItem menuItem) {
switch (menuItem.getItemId()) {
case R.id.list_navigation_menu_item:
// Do nothing, we're already on that screen
break;
case R.id.statistics_navigation_menu_item:
Intent intent =
new Intent(TasksActivity.this, StatisticsActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
| Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);
break;
default:
break;
}
// Close the navigation drawer when an item is selected.
menuItem.setChecked(true);
mDrawerLayout.closeDrawers();
return true;
}
});
}
@VisibleForTesting
public IdlingResource getCountingIdlingResource() {
return EspressoIdlingResource.getIdlingResource();
}
}可以看到TaskActivity相当于一个TaskFragment与TaskPresenter的托管者，它管理了View与Presenter层对象的创建，并将二者联系起来。然后就是一些Toolbar以及DrawerLayout的初始化等，其他的就再也没有任何逻辑了。我们重点来看下面两句代码：
TasksFragment tasksFragment =
(TasksFragment) getSupportFragmentManager().findFragmentById(R.id.contentFrame);
if (tasksFragment == null) {
// Create the fragment
tasksFragment = TasksFragment.newInstance();
ActivityUtils.addFragmentToActivity(
getSupportFragmentManager(), tasksFragment, R.id.contentFrame);
}
// Create the presenter
mTasksPresenter = new TasksPresenter(
Injection.provideTasksRepository(getApplicationContext()), tasksFragment);
这里就是创建View层与Presenter层对象，先来看看TaskFragment：
package com.example.android.architecture.blueprints.todoapp.tasks;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.widget.PopupMenu;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import com.example.android.architecture.blueprints.todoapp.R;
import com.example.android.architecture.blueprints.todoapp.addedittask.AddEditTaskActivity;
import com.example.android.architecture.blueprints.todoapp.data.Task;
import com.example.android.architecture.blueprints.todoapp.taskdetail.TaskDetailActivity;
import java.util.ArrayList;
import java.util.List;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Display a grid of {@link Task}s. User can choose to view all, active or completed tasks.
*/
public class TasksFragment extends Fragment implements TasksContract.View {
/**
* Presenter 层引用，所有的与Model层相关的逻辑都交给它来完成
*/
private TasksContract.Presenter mPresenter;
private TasksAdapter mListAdapter;
private View mNoTasksView;
private ImageView mNoTaskIcon;
private TextView mNoTaskMainView;
private TextView mNoTaskAddView;
private LinearLayout mTasksView;
private TextView mFilteringLabelView;
public TasksFragment() {
// Requires empty public constructor
}
public static TasksFragment newInstance() {
return new TasksFragment();
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mListAdapter = new TasksAdapter(new ArrayList<Task>(0), mItemListener);
}
@Override
public void onResume() {
super.onResume();
mPresenter.start();
}
@Override
public void setPresenter(@NonNull TasksContract.Presenter presenter) {
mPresenter = checkNotNull(presenter);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
mPresenter.result(requestCode, resultCode);
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View root = inflater.inflate(R.layout.tasks_frag, container, false);
// Set up tasks view
ListView listView = (ListView) root.findViewById(R.id.tasks_list);
listView.setAdapter(mListAdapter);
mFilteringLabelView = (TextView) root.findViewById(R.id.filteringLabel);
mTasksView = (LinearLayout) root.findViewById(R.id.tasksLL);
// Set up no tasks view
mNoTasksView = root.findViewById(R.id.noTasks);
mNoTaskIcon = (ImageView) root.findViewById(R.id.noTasksIcon);
mNoTaskMainView = (TextView) root.findViewById(R.id.noTasksMain);
mNoTaskAddView = (TextView) root.findViewById(R.id.noTasksAdd);
mNoTaskAddView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showAddTask();
}
});
// Set up floating action button
FloatingActionButton fab =
(FloatingActionButton) getActivity().findViewById(R.id.fab_add_task);
fab.setImageResource(R.drawable.ic_add);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPresenter.addNewTask();
}
});
// Set up progress indicator
final ScrollChildSwipeRefreshLayout swipeRefreshLayout =
(ScrollChildSwipeRefreshLayout) root.findViewById(R.id.refresh_layout);
swipeRefreshLayout.setColorSchemeColors(
ContextCompat.getColor(getActivity(), R.color.colorPrimary),
ContextCompat.getColor(getActivity(), R.color.colorAccent),
ContextCompat.getColor(getActivity(), R.color.colorPrimaryDark)
);
// Set the scrolling view in the custom SwipeRefreshLayout.
swipeRefreshLayout.setScrollUpChild(listView);
swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
mPresenter.loadTasks(false);
}
});
setHasOptionsMenu(true);
return root;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_clear:
mPresenter.clearCompletedTasks();
break;
case R.id.menu_filter:
showFilteringPopUpMenu();
break;
case R.id.menu_refresh:
mPresenter.loadTasks(true);
break;
}
return true;
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
inflater.inflate(R.menu.tasks_fragment_menu, menu);
}
@Override
public void showFilteringPopUpMenu() {
PopupMenu popup = new PopupMenu(getContext(), getActivity().findViewById(R.id.menu_filter));
popup.getMenuInflater().inflate(R.menu.filter_tasks, popup.getMenu());
popup.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
public boolean onMenuItemClick(MenuItem item) {
switch (item.getItemId()) {
case R.id.active:
mPresenter.setFiltering(TasksFilterType.ACTIVE_TASKS);
break;
case R.id.completed:
mPresenter.setFiltering(TasksFilterType.COMPLETED_TASKS);
break;
default:
mPresenter.setFiltering(TasksFilterType.ALL_TASKS);
break;
}
mPresenter.loadTasks(false);
return true;
}
});
popup.show();
}
/**
* Listener for clicks on tasks in the ListView.
*/
TaskItemListener mItemListener = new TaskItemListener() {
@Override
public void onTaskClick(Task clickedTask) {
mPresenter.openTaskDetails(clickedTask);
}
@Override
public void onCompleteTaskClick(Task completedTask) {
mPresenter.completeTask(completedTask);
}
@Override
public void onActivateTaskClick(Task activatedTask) {
mPresenter.activateTask(activatedTask);
}
};
@Override
public void setLoadingIndicator(final boolean active) {
if (getView() == null) {
return;
}
final SwipeRefreshLayout srl =
(SwipeRefreshLayout) getView().findViewById(R.id.refresh_layout);
// Make sure setRefreshing() is called after the layout is done with everything else.
srl.post(new Runnable() {
@Override
public void run() {
srl.setRefreshing(active);
}
});
}
@Override
public void showTasks(List<Task> tasks) {
mListAdapter.replaceData(tasks);
mTasksView.setVisibility(View.VISIBLE);
mNoTasksView.setVisibility(View.GONE);
}
@Override
public void showNoActiveTasks() {
showNoTasksViews(
getResources().getString(R.string.no_tasks_active),
R.drawable.ic_check_circle_24dp,
false
);
}
@Override
public void showNoTasks() {
showNoTasksViews(
getResources().getString(R.string.no_tasks_all),
R.drawable.ic_assignment_turned_in_24dp,
false
);
}
@Override
public void showNoCompletedTasks() {
showNoTasksViews(
getResources().getString(R.string.no_tasks_completed),
R.drawable.ic_verified_user_24dp,
false
);
}
@Override
public void showSuccessfullySavedMessage() {
showMessage(getString(R.string.successfully_saved_task_message));
}
private void showNoTasksViews(String mainText, int iconRes, boolean showAddView) {
mTasksView.setVisibility(View.GONE);
mNoTasksView.setVisibility(View.VISIBLE);
mNoTaskMainView.setText(mainText);
mNoTaskIcon.setImageDrawable(getResources().getDrawable(iconRes));
mNoTaskAddView.setVisibility(showAddView ? View.VISIBLE : View.GONE);
}
@Override
public void showActiveFilterLabel() {
mFilteringLabelView.setText(getResources().getString(R.string.label_active));
}
@Override
public void showCompletedFilterLabel() {
mFilteringLabelView.setText(getResources().getString(R.string.label_completed));
}
@Override
public void showAllFilterLabel() {
mFilteringLabelView.setText(getResources().getString(R.string.label_all));
}
@Override
public void showAddTask() {
Intent intent = new Intent(getContext(), AddEditTaskActivity.class);
startActivityForResult(intent, AddEditTaskActivity.REQUEST_ADD_TASK);
}
@Override
public void showTaskDetailsUi(String taskId) {
// in it's own Activity, since it makes more sense that way and it gives us the flexibility
// to show some Intent stubbing.
Intent intent = new Intent(getContext(), TaskDetailActivity.class);
intent.putExtra(TaskDetailActivity.EXTRA_TASK_ID, taskId);
startActivity(intent);
}
@Override
public void showTaskMarkedComplete() {
showMessage(getString(R.string.task_marked_complete));
}
@Override
public void showTaskMarkedActive() {
showMessage(getString(R.string.task_marked_active));
}
@Override
public void showCompletedTasksCleared() {
showMessage(getString(R.string.completed_tasks_cleared));
}
@Override
public void showLoadingTasksError() {
showMessage(getString(R.string.loading_tasks_error));
}
private void showMessage(String message) {
Snackbar.make(getView(), message, Snackbar.LENGTH_LONG).show();
}
@Override
public boolean isActive() {
return isAdded();
}
private static class TasksAdapter extends BaseAdapter {
private List<Task> mTasks;
private TaskItemListener mItemListener;
public TasksAdapter(List<Task> tasks, TaskItemListener itemListener) {
setList(tasks);
mItemListener = itemListener;
}
public void replaceData(List<Task> tasks) {
setList(tasks);
notifyDataSetChanged();
}
private void setList(List<Task> tasks) {
mTasks = checkNotNull(tasks);
}
@Override
public int getCount() {
return mTasks.size();
}
@Override
public Task getItem(int i) {
return mTasks.get(i);
}
@Override
public long getItemId(int i) {
return i;
}
@Override
public View getView(int i, View view, ViewGroup viewGroup) {
View rowView = view;
if (rowView == null) {
LayoutInflater inflater = LayoutInflater.from(viewGroup.getContext());
rowView = inflater.inflate(R.layout.task_item, viewGroup, false);
}
final Task task = getItem(i);
TextView titleTV = (TextView) rowView.findViewById(R.id.title);
titleTV.setText(task.getTitleForList());
CheckBox completeCB = (CheckBox) rowView.findViewById(R.id.complete);
// Active/completed task UI
completeCB.setChecked(task.isCompleted());
if (task.isCompleted()) {
rowView.setBackgroundDrawable(viewGroup.getContext()
.getResources().getDrawable(R.drawable.list_completed_touch_feedback));
} else {
rowView.setBackgroundDrawable(viewGroup.getContext()
.getResources().getDrawable(R.drawable.touch_feedback));
}
completeCB.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (!task.isCompleted()) {
mItemListener.onCompleteTaskClick(task);
} else {
mItemListener.onActivateTaskClick(task);
}
}
});
rowView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
mItemListener.onTaskClick(task);
}
});
return rowView;
}
}
public interface TaskItemListener {
void onTaskClick(Task clickedTask);
void onCompleteTaskClick(Task completedTask);
void onActivateTaskClick(Task activatedTask);
}
}可以看到，TaskFragment作为View层持有一个TasksContract.Presenter mPresenter;对象，没有持有任何Model层对象，比如List < Task > ,Task对象等，当然有很多的View控件对象，这个肯定是必须的。
在TaskFragment的setPresenter中我们给TasksContract.Presenter mPresenter对象进行了赋值，保证了不为空。
接着我们来看看TaskPresenter的代码：
package com.example.android.architecture.blueprints.todoapp.tasks;
import android.app.Activity;
import android.support.annotation.NonNull;
import com.example.android.architecture.blueprints.todoapp.addedittask.AddEditTaskActivity;
import com.example.android.architecture.blueprints.todoapp.data.Task;
import com.example.android.architecture.blueprints.todoapp.data.source.TasksDataSource;
import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository;
import com.example.android.architecture.blueprints.todoapp.util.EspressoIdlingResource;
import java.util.ArrayList;
import java.util.List;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Listens to user actions from the UI ({@link TasksFragment}), retrieves the data and updates the
* UI as required.
*/
public class TasksPresenter implements TasksContract.Presenter {
private final TasksRepository mTasksRepository;
private final TasksContract.View mTasksView;
private TasksFilterType mCurrentFiltering = TasksFilterType.ALL_TASKS;
private boolean mFirstLoad = true;
public TasksPresenter(@NonNull TasksRepository tasksRepository, @NonNull TasksContract.View tasksView) {
mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null");
mTasksView = checkNotNull(tasksView, "tasksView cannot be null!");
mTasksView.setPresenter(this);
}
@Override
public void start() {
loadTasks(false);
}
@Override
public void result(int requestCode, int resultCode) {
// If a task was successfully added, show snackbar
if (AddEditTaskActivity.REQUEST_ADD_TASK == requestCode && Activity.RESULT_OK == resultCode) {
mTasksView.showSuccessfullySavedMessage();
}
}
@Override
public void loadTasks(boolean forceUpdate) {
// Simplification for sample: a network reload will be forced on first load.
loadTasks(forceUpdate || mFirstLoad, true);
mFirstLoad = false;
}
/**
* @param forceUpdate Pass in true to refresh the data in the {@link TasksDataSource}
* @param showLoadingUI Pass in true to display a loading icon in the UI
*/
private void loadTasks(boolean forceUpdate, final boolean showLoadingUI) {
if (showLoadingUI) {
mTasksView.setLoadingIndicator(true);
}
if (forceUpdate) {
mTasksRepository.refreshTasks();
}
// The network request might be handled in a different thread so make sure Espresso knows
// that the app is busy until the response is handled.
EspressoIdlingResource.increment(); // App is busy until further notice
mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
@Override
public void onTasksLoaded(List<Task> tasks) {
List<Task> tasksToShow = new ArrayList<Task>();
// This callback may be called twice, once for the cache and once for loading
// the data from the server API, so we check before decrementing, otherwise
// it throws "Counter has been corrupted!" exception.
if (!EspressoIdlingResource.getIdlingResource().isIdleNow()) {
EspressoIdlingResource.decrement(); // Set app as idle.
}
// We filter the tasks based on the requestType
for (Task task : tasks) {
switch (mCurrentFiltering) {
case ALL_TASKS:
tasksToShow.add(task);
break;
case ACTIVE_TASKS:
if (task.isActive()) {
tasksToShow.add(task);
}
break;
case COMPLETED_TASKS:
if (task.isCompleted()) {
tasksToShow.add(task);
}
break;
default:
tasksToShow.add(task);
break;
}
}
// The view may not be able to handle UI updates anymore
if (!mTasksView.isActive()) {
return;
}
if (showLoadingUI) {
mTasksView.setLoadingIndicator(false);
}
processTasks(tasksToShow);
}
@Override
public void onDataNotAvailable() {
// The view may not be able to handle UI updates anymore
if (!mTasksView.isActive()) {
return;
}
mTasksView.showLoadingTasksError();
}
});
}
private void processTasks(List<Task> tasks) {
if (tasks.isEmpty()) {
// Show a message indicating there are no tasks for that filter type.
processEmptyTasks();
} else {
// Show the list of tasks
mTasksView.showTasks(tasks);
// Set the filter label's text.
showFilterLabel();
}
}
private void showFilterLabel() {
switch (mCurrentFiltering) {
case ACTIVE_TASKS:
mTasksView.showActiveFilterLabel();
break;
case COMPLETED_TASKS:
mTasksView.showCompletedFilterLabel();
break;
default:
mTasksView.showAllFilterLabel();
break;
}
}
private void processEmptyTasks() {
switch (mCurrentFiltering) {
case ACTIVE_TASKS:
mTasksView.showNoActiveTasks();
break;
case COMPLETED_TASKS:
mTasksView.showNoCompletedTasks();
break;
default:
mTasksView.showNoTasks();
break;
}
}
@Override
public void addNewTask() {
mTasksView.showAddTask();
}
@Override
public void openTaskDetails(@NonNull Task requestedTask) {
checkNotNull(requestedTask, "requestedTask cannot be null!");
mTasksView.showTaskDetailsUi(requestedTask.getId());
}
@Override
public void completeTask(@NonNull Task completedTask) {
checkNotNull(completedTask, "completedTask cannot be null!");
mTasksRepository.completeTask(completedTask);
mTasksView.showTaskMarkedComplete();
loadTasks(false, false);
}
@Override
public void activateTask(@NonNull Task activeTask) {
checkNotNull(activeTask, "activeTask cannot be null!");
mTasksRepository.activateTask(activeTask);
mTasksView.showTaskMarkedActive();
loadTasks(false, false);
}
@Override
public void clearCompletedTasks() {
mTasksRepository.clearCompletedTasks();
mTasksView.showCompletedTasksCleared();
loadTasks(false, false);
}
/**
* Sets the current task filtering type.
*
* @param requestType Can be {@link TasksFilterType#ALL_TASKS},
* {@link TasksFilterType#COMPLETED_TASKS}, or
* {@link TasksFilterType#ACTIVE_TASKS}
*/
@Override
public void setFiltering(TasksFilterType requestType) {
mCurrentFiltering = requestType;
}
@Override
public TasksFilterType getFiltering() {
return mCurrentFiltering;
}
}可以看到，TaskPresenter中有View层的引用对象 mTasksView，在TaskPresenter的构造方法中，我们设置了TasksContract.View 引用对象，并且给View对象设置了Presenter，这样View层与Presenter就联系起来了。
在TaskFragment 的onResume()中我们调用了mPresenter.start();这样就能完成初始的Task列表的显示了。
我们重点来分析，列表的显示。是由TaskFragment 的showTasks()完成的
@Override
public void showTasks(List<Task> tasks) {
mListAdapter.replaceData(tasks);
mTasksView.setVisibility(View.VISIBLE);
mNoTasksView.setVisibility(View.GONE);
}可以看到，这里的工作很简单，将mListAdapter中的数据替换成tasks即可。和我们平常使用Adapter并无任何区别。那么showTasks()是在哪里调用的呢？答案就是在TaskPresenter的loadTasks()中，详细见下：
public class TasksPresenter implements TasksContract.Presenter {
private final TasksRepository mTasksRepository;
private final TasksContract.View mTasksView;
private TasksFilterType mCurrentFiltering = TasksFilterType.ALL_TASKS;
private boolean mFirstLoad = true;
public TasksPresenter(@NonNull TasksRepository tasksRepository, @NonNull TasksContract.View tasksView) {
mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null");
mTasksView = checkNotNull(tasksView, "tasksView cannot be null!");
mTasksView.setPresenter(this);
}
@Override
public void start() {
loadTasks(false);
}
.....
@Override
public void loadTasks(boolean forceUpdate) {
// Simplification for sample: a network reload will be forced on first load.
loadTasks(forceUpdate || mFirstLoad, true);
mFirstLoad = false;
}
/**
* @param forceUpdate Pass in true to refresh the data in the {@link TasksDataSource}
* @param showLoadingUI Pass in true to display a loading icon in the UI
*/
private void loadTasks(boolean forceUpdate, final boolean showLoadingUI) {
if (showLoadingUI) {
mTasksView.setLoadingIndicator(true);
}
if (forceUpdate) {
mTasksRepository.refreshTasks();
}
// The network request might be handled in a different thread so make sure Espresso knows
// that the app is busy until the response is handled.
EspressoIdlingResource.increment(); // App is busy until further notice
mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
@Override
public void onTasksLoaded(List<Task> tasks) {
List<Task> tasksToShow = new ArrayList<Task>();
// This callback may be called twice, once for the cache and once for loading
// the data from the server API, so we check before decrementing, otherwise
// it throws "Counter has been corrupted!" exception.
if (!EspressoIdlingResource.getIdlingResource().isIdleNow()) {
EspressoIdlingResource.decrement(); // Set app as idle.
}
// We filter the tasks based on the requestType
for (Task task : tasks) {
switch (mCurrentFiltering) {
case ALL_TASKS:
tasksToShow.add(task);
break;
case ACTIVE_TASKS:
if (task.isActive()) {
tasksToShow.add(task);
}
break;
case COMPLETED_TASKS:
if (task.isCompleted()) {
tasksToShow.add(task);
}
break;
default:
tasksToShow.add(task);
break;
}
}
// The view may not be able to handle UI updates anymore
if (!mTasksView.isActive()) {
return;
}
if (showLoadingUI) {
mTasksView.setLoadingIndicator(false);
}
processTasks(tasksToShow);
}
@Override
public void onDataNotAvailable() {
// The view may not be able to handle UI updates anymore
if (!mTasksView.isActive()) {
return;
}
mTasksView.showLoadingTasksError();
}
});
}
private void processTasks(List<Task> tasks) {
if (tasks.isEmpty()) {
// Show a message indicating there are no tasks for that filter type.
processEmptyTasks();
} else {
// Show the list of tasks
mTasksView.showTasks(tasks);
// Set the filter label's text.
showFilterLabel();
}
}
.....
}
，可以看到显示列表的过程就是这样，总结起来就是：
TaskFragment#onResume() -> TaskPresenter#loadTasks(boolean forceUpdate) -> TaskPresenter#loadTasks(boolean forceUpdate, final boolean showLoadingUI) -> TaskPresenter#processTasks(List tasks) -> TaskFragment#showTasks(List tasks);
这里是显示task列表的逻辑，我们再来看一下添加task的逻辑。
首先出发添加task 的操作在View层中：
// Set up floating action button
FloatingActionButton fab =
(FloatingActionButton) getActivity().findViewById(R.id.fab_add_task);
fab.setImageResource(R.drawable.ic_add);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPresenter.addNewTask();
}
});
可以看到，TaskFragment 直接将操作转移给了TaskPresenter层。
@Override
public void addNewTask() {
mTasksView.showAddTask();
}TaskPresenter直接将操作又转移给了TaskFragment.
@Override
public void showAddTask() {
Intent intent = new Intent(getContext(), AddEditTaskActivity.class);
startActivityForResult(intent, AddEditTaskActivity.REQUEST_ADD_TASK);
}可以看到，TaskFragment的showAddTask()中做了具体的界面操作，具体来说就是跳转到添加task的页面，从而完成了add task的操作。
为什么TaskFragment 和TaskPresenter 不直接跳转到AddEditTaskActivity页面呢？这是因为在MVP中，页面跳转可能涉及到Model层的操作(这里并没有)，因此需要Presenter的参与,而由于跳转页面这个操作设计到context及具体的页面跳转，是View层干的事，因此最后必须又转发给View层，倘若需要Model层数据的支持，可以在转发给View层前，将数据添加进去。
这里只分析了两个业务，其他的业务也相似，读者自行分析。记住核心的一点：View层不能持有Model层的引用，不能直接去更新Model层，必须通过Presenter层，Presenter层中也不能直接操作View及相关的UI控件，必须通过View层的引用来操作。
以上就是对View与Presenter层的分析，下一篇会分析Presenter与Model层的交互
总结：
View与Model分离使工程的整体架构和代码结构非常清晰（不再是所有的业务和逻辑都糅合在Activity、Fragment里了），易于理解和上手。
由于将UI代码与业务代码进行了拆分，整体的可测试性非常的好，UI层和业务层可以分别进行单元测试。
由于架构的引入，虽然代码量有了一定的上升，但是由于界限非常清晰，各个类和层的职责都非常明确且单一，后期的扩展，维护都会更加容易。
768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
