/**
 * Presenter层调用UseCaseHandler去执行逻辑处理
 * 处理完回调上层结果 通知界面刷新
 *
 * @param title
 * @param description
 */
private void createTask(String title, String description) {
    Task newTask = new Task(title, description);
    if (newTask.isEmpty()) {
        mAddTaskView.showEmptyTaskError();
    } else {
        mUseCaseHandler.execute(mSaveTask, new SaveTask.RequestValues(newTask),
                new UseCase.UseCaseCallback<SaveTask.ResponseValue>() {
                    @Override
                    public void onSuccess(SaveTask.ResponseValue response) {
                        mAddTaskView.showTasksList();
                    }

                    @Override
                    public void onError() {
                        showSaveError();
                    }
                });
    }
}
/**
 * 每个Presenter对应一个UseCaseHandler
 * UseCaseHandler中进行具体的逻辑处理
 *
 * @param useCase
 * @param values
 * @param callback
 * @param <T>
 * @param <R>
 */
public <T extends UseCase.RequestValues, R extends UseCase.ResponseValue> void execute(
        final UseCase<T, R> useCase, T values, UseCase.UseCaseCallback<R> callback) {
    //设置请求过程中需要的参数
    useCase.setRequestValues(values);
    //设置请求完成后的回调
    useCase.setUseCaseCallback(new UiCallbackWrapper(callback, this));

    EspressoIdlingResource.increment();

    //逻辑处理放在非UI线程
    mUseCaseScheduler.execute(new Runnable() {
        @Override
        public void run() {
            useCase.run();
            if (!EspressoIdlingResource.getIdlingResource().isIdleNow()) {
                EspressoIdlingResource.decrement();
            }
        }
    });
}

/**
 * 具体的业务处理
 * GetTasks.java
 *
 * @param values 上层传来的参数
 */
@Override
protected void executeUseCase(final RequestValues values) {
    if (values.isForceUpdate()) {
        mTasksRepository.refreshTasks();
    }

    //此逻辑在非UI线程执行
    //并对数据仓储设置回调
    mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
        @Override
        public void onTasksLoaded(List<Task> tasks) {
            TasksFilterType currentFiltering = values.getCurrentFiltering();
            TaskFilter taskFilter = mFilterFactory.create(currentFiltering);

            List<Task> tasksFiltered = taskFilter.filter(tasks);
            ResponseValue responseValue = new ResponseValue(tasksFiltered);
            //处理结果回调上层进行处理( mAddTaskView.showTasksList();)
            getUseCaseCallback().onSuccess(responseValue);
        }

        @Override
        public void onDataNotAvailable() {
            ////处理结果回调上层进行处理( showSaveError();)
            getUseCaseCallback().onError();
        }
    });
}

AddEditTaskActivity:初始化View层和Presenter层 并实现Presenter和View的绑定
AddEditTaskContract:定义了View和Presenter的接口
AddEditTaskFragment:View层实现了AddEditTaskContract中的View接口
AddEditTaskPresenter :Presenter层 实现了AddEditTaskContract的Presenter接口

public interface AddEditTaskContract {

    interface View extends BaseView<Presenter> {

        void showEmptyTaskError();

        void showTasksList();

        void setTitle(String title);

        void setDescription(String description);

        boolean isActive();
    }

    interface Presenter extends BasePresenter {

        void saveTask(String title, String description);

        void populateTask();

        boolean isDataMissing();
    }
}

//实现View层的接口
public class AddEditTaskFragment extends Fragment implements AddEditTaskContract.View {

    //点击事件交给Presenter层去处理
    fab.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            mPresenter.saveTask(mTitle.getText().toString(), mDescription.getText().toString());
        }
    });

    //Presenter层处理完逻辑 回调之View层展现
    @Override
    public void showEmptyTaskError() {
        Snackbar.make(mTitle, getString(R.string.empty_task_message), Snackbar.LENGTH_LONG).show();
    }

    @Override
    public void showTasksList() {
        getActivity().setResult(Activity.RESULT_OK);
        getActivity().finish();
    }

//实现Presenter的接口
public class AddEditTaskPresenter implements AddEditTaskContract.Presenter,
        TasksDataSource.GetTaskCallback {
    //处理View层发送来的请求
    @Override
    public void saveTask(String title, String description) {
        if (isNewTask()) {
            createTask(title, description);
        } else {
            updateTask(title, description);
        }
    }
    
    private void updateTask(String title, String description) {
        if (isNewTask()) {
            throw new RuntimeException("updateTask() was called but task is new.");
        }
        //交于综合数据仓库去处理数据
        mTasksRepository.saveTask(new Task(title, description, mTaskId));
        //处理完后回调View层展示处理结果
        mAddTaskView.showTasksList(); // After an edit, go back to the list.
    }
}

//初始化View层
if (addEditTaskFragment == null) {
    addEditTaskFragment = AddEditTaskFragment.newInstance();
}

boolean shouldLoadDataFromRepo = true;

// Prevent the presenter from loading data from the repository if this is a config change.
if (savedInstanceState != null) {
    // Data might not have loaded when the config change happen, so we saved the state.
    shouldLoadDataFromRepo = savedInstanceState.getBoolean(SHOULD_LOAD_DATA_FROM_REPO_KEY);
    }

//初始化View层和Presenter层 并实现Presenter和View的绑定
mAddEditTaskPresenter = new AddEditTaskPresenter(
    taskId,
    Injection.provideTasksRepository(getApplicationContext()),
    addEditTaskFragment,
    shouldLoadDataFromRepo);

private void updateTask(String title, String description) {
    if (isNewTask()) {
        throw new RuntimeException("updateTask() was called but task is new.");
    }
    //交于综合数据仓库去处理数据
    mTasksRepository.saveTask(new Task(title, description, mTaskId));
    //处理完后回调View层展示处理结果
    mAddTaskView.showTasksList(); // After an edit, go back to the list.
}

/**
 * 综合数据仓储处理
 * TasksRepository.java
 * @param task
 */
@Override
public void saveTask(@NonNull Task task) {
    checkNotNull(task);
    //远程数据仓储处理
    mTasksRemoteDataSource.saveTask(task);
    //本地数据仓储处理
    mTasksLocalDataSource.saveTask(task);

    // 加入本地缓存
    if (mCachedTasks == null) {
        mCachedTasks = new LinkedHashMap<>();
    }
    mCachedTasks.put(task.getId(), task);
}

/**
 * 本地数据存储
 * 因为操作数据库需要放在非UI线程处理
 * TasksLocalDataSource.java
 * @param task
 */
@Override
public void saveTask(@NonNull final Task task) {
    checkNotNull(task);
    //启动线程 在非UI进程进行数据库操作
    Runnable saveRunnable = new Runnable() {
        @Override
        public void run() {
            mTasksDao.insertTask(task);
        }
    };
    mAppExecutors.diskIO().execute(saveRunnable);
}

/**
 * 远程数据操作处理
 * 此处代码为模拟的
 * TasksRemoteDataSource.java
 *
 * @param task
 */
@Override
public void saveTask(@NonNull Task task) {
    TASKS_SERVICE_DATA.put(task.getId(), task);
}

class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare();
        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
        Looper.loop();
    }
}

private static void prepare(boolean quitAllowed) {
	if (sThreadLocal.get() != null) {
		throw new RuntimeException("Only one Looper may be created per thread");
        }
	sThreadLocal.set(new Looper(quitAllowed));//保证每个线程只有一个Looper对象
    }

private Looper(boolean quitAllowed) {
 //每个Looper唯一对应一个MessageQueue 即一个线程对应一个Looper 一个MessageQueue
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

public static void loop() {
	final Looper me = myLooper();
		if (me == null) {
			throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        for (;;) {//无限循环
            Message msg = queue.next(); // might block
            if (msg == null) {
                return;
            }
            msg.target.dispatchMessage(msg);//回调dispatchMessage方法
            msg.recycleUnchecked();
        }
    }

boolean enqueueMessage(Message msg, long when) {
	synchronized (this) {
		if (mQuitting) {
			IllegalStateException e = new IllegalStateException(msg.target + " sending message to a Handler on a dead thread");
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; 
                prev.next = msg;
                // 最后一个p为null 将message插入到倒数第二个位置
            }
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

/**
 * Returns the unique device ID, for example, the IMEI for GSM and the MEID
 * or ESN for CDMA phones. Return null if device ID is not available.
 *
 * <p>Requires Permission:
 *   {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
 */
public String getDeviceId() {
    try {
        ITelephony telephony = getITelephony();
        if (telephony == null)
            return null;
        return telephony.getDeviceId(mContext.getOpPackageName());
    } catch (RemoteException ex) {
        return null;
    } catch (NullPointerException ex) {
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        Main mMain = new Main();
        try {
            mMain.other();
        } catch (Exception e ) {
            // 必须catch 不然无法编译通过
        }

        // 无须catch 可以編譯運行通過
        mMain.runtimeException();
        mMain.error();
    }

    private void error() throws Error {
        throw new Error("error" );
    }

    private void other() throws Exception {
        throw new Exception("other");
    }

    private void runtimeException() throws RuntimeException {
        throw new RuntimeException("runtimeException");
    }
}

/**
 * The interface used to return responses from activity
 */
oneway interface IActivityResponse {
    /**
     * onResult
     */
    void onResult(int code, Bundle value);

    /**
     * onError
     */
    void onError(int error, String message);

    /**
     * onCancel
     */
    void onCancel();
}

public class ActivityResponse implements Parcelable {
    // creator
    public static final Creator<ActivityResponse> CREATOR = new Creator<ActivityResponse>() {
        public ActivityResponse createFromParcel(Parcel source) {
            return new ActivityResponse(source);
        }

        public ActivityResponse[] newArray(int size) {
            return new ActivityResponse[size];
        }
    };
    /**
     * 日志
     */
    private static final String TAG = "ActivityResponse";
    /**
     * 响应接口对象
     */
    private IActivityResponse response = null;

    /**
     * 构造函数
     *
     * @param response IAccountResponse对象
     */
    public ActivityResponse(IActivityResponse response) {
        this.response = response;
    }

    /**
     * 构造函数
     *
     * @param parcel Parcel对象
     */
    public ActivityResponse(Parcel parcel) {
        response = IActivityResponse.Stub.asInterface(parcel.readStrongBinder());
    }

    /**
     * 回调并返回结果
     *
     * @param result 数据结果
     */
    public void onResult(Bundle result) {
        try {
            response.onResult(result);
        } catch (DeadObjectException e) {
            LOG.e(TAG, "[result:" + result
                    + "] on result failed(DeadObjectException)", e);
        } catch (RemoteException e) {
            LOG.e(TAG, "[result:" + result
                    + "] on result failed(RemoteException)", e);
        } catch (Throwable e) {
            LOG.e(TAG, "[result:" + result
                    + "] on result failed(Throwable)", e);
        }
    }

    /**
     * 发生错误时的回调
     *
     * @param error   错误码
     * @param message 错误信息
     */
    public void onError(int error, String message) {
        try {
            response.onError(error, message);
        } catch (DeadObjectException e) {
            LOG.e(TAG, "[error:" + error + "][message:" + message
                    + "] on error failed(DeadObjectException)", e);
        } catch (RemoteException e) {
            LOG.e(TAG, "[error:" + error + "][message:" + message
                    + "] on error failed(RemoteException)", e);
        } catch (Throwable e) {
            LOG.e(TAG, "[error:" + error + "][message:" + message
                    + "] on error failed(Throwable)", e);
        }
    }

    /**
     * 发生取消时的回调
     */
    public void onCancel() {
        try {
            response.onCancel();
        } catch (DeadObjectException e) {
            LOG.e(TAG, "on cancel failed(DeadObjectException)", e);
        } catch (RemoteException e) {
            LOG.e(TAG, "on cancel failed(RemoteException)", e);
        } catch (Throwable e) {
            LOG.e(TAG, "on cancel failed(Throwable)", e);
        }
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeStrongBinder(response.asBinder());
    }

i.putExtra("activityResponse", 
        new ActivityResponse(new IActivityResponse.Stub(){
            @Override 
            public void onResult(Bundle value) throws RemoteException {
                
            }
            
            @Override 
            public void onError(int error, String message) throws RemoteException {
                
            }

            @Override
            public void onCancel() throws RemoteException {

            }
        }));

ActivityResponse response = getIntent().getParcelableExtra("activityResponse");

if (null != response) {
    response.onError(error, message);
}

ActivityResponse response = getIntent().getParcelableExtra("activityResponse");

if (null != response) {
    response.onResult(result);
}

ActivityResponse response = getIntent().getParcelableExtra("activityResponse");

if (null != response) {
    response.onCancel();
}