一個MVP模式的實例

在MVP模式中，P通過接口依賴 M 和 V，且 P 盡量少的依賴其他類。
MVP三個角色就像三個領導，分別負責：數據，視圖，業(yè)務 三大邏輯。
而項目中的其他類，就相當于專業(yè)人員，負責好自己的崗位工作，隨時等候領導的調用。

PacketProgressActivity.java （MVP模式的V）
// 通訊等待界面

代碼邏輯

// 啟動入口：
// 入參：包類型，組包信息
public static void actionStart(Context context, int packetType, Bundle info) {
        mPacketType = packetType;
        Intent intent = new Intent(context, PacketProgressActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
        intent.putExtra(PacketTypes.class.getSimpleName(), packetType);
        if (info != null) {
            intent.putExtra(PACKET_INFO, info);
        }
        context.startActivity(intent);
}
// 包類型，組包信息 都放入 intent，接著啟動自己

調用鏈條

--> PacketProgressActivity.onCreate （ V 端）

{
        super.onCreate(savedInstanceState);
        --> BaseMvpActivity.onCreate
        {
          // 實例化了 Presenter  （ P 端）
          mPresenter = createPresenter();
          {
              return   StrategySelector.selectPresenterStrategy(mPacketType);           
          }
          // p 
          mPresenter.attachView((V) this);
         }  
        init();
}

--> PacketProgressActivity.init （V 端）

{
    // 初始化視圖組件
    // 初始化 Presenter,使得 Presenter 持有 V 和 M 的引用
    mPresenter.init();
    {
        mViewInterface = mViewRef.get(); // 持有 V 的引用
        mModelInterface = new PacketOperationModel(this); // 持有 M 的引用
    }
    // 請求發(fā)送 報文包，入參：intent
    // 業(yè)務轉移給 P
    mPresenter.requestSendPacket(getIntent());
}

// BasePacketPresenter.java （MVP模式的 P 端）
// （子類）SignInPacketPresenter.java
--> SignInPacketPresenter.requestSendPacket

{
    // 不同子類的特定邏輯
    handleIcDownload(); // 以簽到子類為例子，緩存一個簽到后要調用的函數。
    {
        AidlPboc pboc = DeviceServiceManager.getInstance().getPbocManager();
        int aidQueryResult = 0;
        Intent intent = new Intent();
        try {
            // 是否存在 公鑰
            aidQueryResult = pboc.isExistAidPublicKey();
        }
        // 公鑰不存在，則緩存后續(xù)操作
        switch (aidQueryResult) {
            case -0x01:
            case -0x02:
                intent.putExtra(PacketTypes.class.getSimpleName()
                        , PacketTypes.PACKET_IC_PARA_STATUS_QUERY);
                mHandleCache.addRequestCache(intent);
                break;
            case -0x03:
                intent.putExtra(PacketTypes.class.getSimpleName()
                        , PacketTypes.PACKET_IC_CAPK_STATUS_QUERY);
                mHandleCache.addRequestCache(intent);
                break;
            default:
                break;
        }
    }
    // 調用父類的邏輯
    super.requestSendPacket(typeIntent);
}

--> BasePacketPresenter.requestSendPacket （P 端）

{
    // 發(fā)送報文包
    // 業(yè)務交給 model 端
    mModelInterface.sendPacket(mPacketType, mPacketExtraInfo);

}

--> PacketOperationModel.sendPacket （M 端）

{
    // M 端 組包
    mPacket = StrategySelector.selectPacketStrategy(packetType, info);
    // 網絡通訊，交給專業(yè)人員，異步任務類
    mPacketTransferTask = new PacketTransferTask(mContext, this, mPacket);
    mPacketTransferTask.execute(sendPacket);
}

--> PacketTransferTask.doInBackground （專業(yè)人員 端）

{
    //  類通訊結束，返回結果
    return SocketEvent.SOCKET_ERROR_CONNECT;
    return SocketEvent.SOCKET_SUCCESS;
}

--> PacketTransferTask.onPostExecute （專業(yè)人員 端）

{
    // 接收到包完成，回調函數
    // 報告 M 端
    mModelInterface.onReceivePacket(socketResult, mReceivePacket);
}

--> PacketOperationModel.onReceivePacket （M 端）

{
    // M 端進行數據處理
    // 包不為空，就解包
    if (receivedPacket != null) {
            mPacket.clearPacket();
            mPacket.parsePacket(receivedPacket);
            //result = checkMac(receivedPacket);
            result = true;
        }
    // 處理結果 報告 Presenter 
        if (!result) {
            mPacketPresenter.handleMacError();
        } else {
            mPacketPresenter.handlePacket(socketResult, mPacketResendNum);
        }
}

--> BasePacketPresenter.handlePacket （ P 端）

// 收到包后，首先判斷是否還需要下載其他包
// 如果需要，把任務添加到 緩存對象 mHandleCache
if (mModelInterface.getProcessRequired() != 0) {
            LogUtil.i("mModelInterface.getProcessRequired(): " + mModelInterface.getProcessRequired());
            Intent intent = new Intent();
            switch (mModelInterface.getProcessRequired()) {
                /**
                 * 下傳終端磁條卡參數
                 */
                case 1:
                    intent.putExtra(PacketTypes.class.getSimpleName()
                            , PacketTypes.PACKET_PARAM_TRANS);
                    mHandleCache.addRequestCache(intent);
                    break;
                /**
                 * 上傳終端磁條卡狀態(tài)信息
                 */
                case 2:
                    intent.putExtra(PacketTypes.class.getSimpleName()
                            , PacketTypes.PACKET_STATUS_UPLOAD);
                    mHandleCache.addRequestCache(intent);
                    break;
                /**
                 * 重新簽到
                 */
                case 3:
                    intent.putExtra(PacketTypes.class.getSimpleName()
                            , PacketTypes.PACKET_SIGN_UP);
                    mHandleCache.addRequestCache(intent);
                    break;
                /**
                 * 通知終端發(fā)起更新公鑰信息操作
                 */
                case 4:
                    intent.putExtra(PacketTypes.class.getSimpleName()
                            , PacketTypes.PACKET_IC_CAPK_STATUS_QUERY);
                    mHandleCache.addRequestCache(intent);
                    break;
                /**
                 * 下載終端IC卡參數
                 */
                case 5:
                    intent.putExtra(PacketTypes.class.getSimpleName()
                            , PacketTypes.PACKET_IC_PARA_STATUS_QUERY);
                    mHandleCache.addRequestCache(intent);
                    break;
                /**
                 * TMS參數下載
                 */
                case 6:
                    break;
                default:
                    break;
            }
        }
handlePacketSocketResult(socketResult, packetResendNum);

--> (子類)SignInPacketPresenter.handlePacketSocketResult （ P 端）

if ("success".equals(bundle.getString(RESULT_DETAIL))) {
            if (!packetInfo.getIsSignUp()) {
                packetInfo.setIsSignUp(true);
                mViewInterface.showResult(bundle, null);
                return;
            }
            if (isLogin) {
                mViewInterface.showResult(bundle, AmountInputActivity.class);
            } else {
                mViewInterface.showResult(bundle, null);
            }
        } else {
            mViewInterface.showResult(bundle, null);
        }

--> PacketProgressActivity.showResult （ V 端）

// 判斷是否需要后續(xù)通訊
// 判斷是否有緩存
        if (!mHandleCache.isRequestEmpty()) {
            mPresenter.handleRequestCache(bundle, targetActivity);
            return;
        }

        //
        if (!mHandleCache.isResultEmpty()) {
            mPresenter.handleCenterRequiredResult();
            return;
        }

//  如果沒有后續(xù)通訊，則展示通訊結果
        if (targetActivity != null) {
            Intent intent = new Intent(this, targetActivity);
            if (bundle != null) {
                intent.putExtra(PacketResultActivity.class.getSimpleName(), bundle);
            }
            if (targetActivity == AmountInputActivity.class) {
                ClientInfoManager.getConsumeData().setConsumeType(PacketTypes.PACKET_CONSUME);
                ConsumeAmountInputActivity.actionStart(this, null, getString(R.string.title_consume));
            } else {
                startActivity(intent);
            }
        } else {
            PacketResultActivity.actionStart(this, bundle);
        }
        finish();