Android4.0（Phone）拨号启动过程分析（二）

InCallScreen处理来电和拨号的界面，接通电话也是这个界面，接下来分析InCallScreen类是如何处理拨号流程的；

@Override
	protected void onCreate(Bundle icicle) {
		Log.i(LOG_TAG, "onCreate()...  this = " + this);
		Profiler.callScreenOnCreate();
		super.onCreate(icicle);

		// Make sure this is a voice-capable device.
		if (!PhoneApp.sVoiceCapable) {
			// There should be no way to ever reach the InCallScreen on a
			// non-voice-capable device, since this activity is not exported by
			// our manifest, and we explicitly disable any other external APIs
			// like the CALL intent and ITelephony.showCallScreen().
			// So the fact that we got here indicates a phone app bug.
			Log.wtf(LOG_TAG, "onCreate() reached on non-voice-capable device");
			finish();
			return;
		}
		// 获取PhoneApp实例
		mApp = PhoneApp.getInstance();
		// 设置通话界面
		mApp.setInCallScreenInstance(this);

		// 添加这个标记可以让Activity显示在锁屏的上方
		int flags = WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
		if (mApp.getPhoneState() == Phone.State.OFFHOOK) {
			// While we are in call, the in-call screen should dismiss the
			// keyguard.
			// This allows the user to press Home to go directly home without
			// going through
			// an insecure lock screen.
			// But we do not want to do this if there is no active call so we do
			// not
			// bypass the keyguard if the call is not answered or declined.
			// 解除锁屏。只有锁屏界面不是加密的才能解锁。如果锁屏界面是加密的，那么用户解锁之后才能看到此窗口，除非设置了FLAG_SHOW_WHEN_LOCKED选项。
			flags |= WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD;
		}
		getWindow().addFlags(flags);

		// Also put the system bar (if present on this device) into
		// "lights out" mode any time we're the foreground activity.
		WindowManager.LayoutParams params = getWindow().getAttributes();
		params.systemUiVisibility = View.SYSTEM_UI_FLAG_LOW_PROFILE;
		getWindow().setAttributes(params);

		setPhone(mApp.phone); // Sets mPhone

		mCM = mApp.mCM;
		log("- onCreate: phone state = " + mCM.getState());

		mBluetoothHandsfree = mApp.getBluetoothHandsfree();
		if (VDBG)
			log("- mBluetoothHandsfree: " + mBluetoothHandsfree);

		if (mBluetoothHandsfree != null) {
			// The PhoneApp only creates a BluetoothHandsfree instance in the
			// first place if BluetoothAdapter.getDefaultAdapter()
			// succeeds. So at this point we know the device is BT-capable.
			mAdapter = BluetoothAdapter.getDefaultAdapter();
			mAdapter.getProfileProxy(getApplicationContext(),
					mBluetoothProfileServiceListener, BluetoothProfile.HEADSET);

		}

		requestWindowFeature(Window.FEATURE_NO_TITLE);

		// Inflate everything in incall_screen.xml and add it to the screen.
		setContentView(R.layout.incall_screen);
		// 初始化CallCard以及InCallTouchUi等截面
		initInCallScreen();
		// 注册关于Phone状态改变的监听事件，这也就是为什么Phone状态改变之后InCallScreen能够收到变化消息的原因，这一点我们在来电流程中也有提及；
		registerForPhoneStates();

		// No need to change wake state here; that happens in onResume() when we
		// are actually displayed.

		// Handle the Intent we were launched with, but only if this is the
		// the very first time we're being launched (ie. NOT if we're being
		// re-initialized after previously being shut down.)
		// Once we're up and running, any future Intents we need
		// to handle will come in via the onNewIntent() method.
		if (icicle == null) {
			if (DBG)
				log("onCreate(): this is our very first launch, checking intent...");
			// 该方法用于处理InCallScreen收到的Intent信息
			internalResolveIntent(getIntent());
		}

		Profiler.callScreenCreated();
		if (DBG)
			log("onCreate(): exit");
	}

private void initInCallScreen() {
		if (VDBG)
			log("initInCallScreen()...");

		// Have the WindowManager filter out touch events that are "too fat".
		getWindow().addFlags(
				WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES);

		mInCallPanel = (ViewGroup) findViewById(R.id.inCallPanel);

		// Initialize the CallCard.
		mCallCard = (CallCard) findViewById(R.id.callCard);
		if (VDBG)
			log("  - mCallCard = " + mCallCard);
		mCallCard.setInCallScreenInstance(this);

		//初始化界面的UI布局
		initInCallTouchUi();

		// 助手类跟踪enabledness / UI控件的状态
		mInCallControlState = new InCallControlState(this, mCM);

		//助手类运行“Manage conference”的用户界面
		mManageConferenceUtils = new ManageConferenceUtils(this, mCM);

		// The DTMF Dialpad.
		// TODO: Don't inflate this until the first time it's needed.
		ViewStub stub = (ViewStub) findViewById(R.id.dtmf_twelve_key_dialer_stub);
		stub.inflate();
		//DTMF拨号盘初始化  
		mDialerView = (DTMFTwelveKeyDialerView) findViewById(R.id.dtmf_twelve_key_dialer_view);
		if (DBG)
			log("- Found dialerView: " + mDialerView);

		// Sanity-check that (regardless of the device) at least the
		// dialer view is present:
		if (mDialerView == null) {
			Log.e(LOG_TAG, "onCreate: couldn't find dialerView",
					new IllegalStateException());
		}
		//创建DTMFTwelveKeyDialer实例
		mDialer = new DTMFTwelveKeyDialer(this, mDialerView);
	}

private void registerForPhoneStates() {
		if (!mRegisteredForPhoneStates) {
			mCM.registerForPreciseCallStateChanged(mHandler,
					PHONE_STATE_CHANGED, null);
			mCM.registerForDisconnect(mHandler, PHONE_DISCONNECT, null);
			mCM.registerForMmiInitiate(mHandler, PhoneApp.MMI_INITIATE, null);
			// register for the MMI complete message. Upon completion,
			// PhoneUtils will bring up a system dialog instead of the
			// message display class in PhoneUtils.displayMMIComplete().
			// We'll listen for that message too, so that we can finish
			// the activity at the same time.
			mCM.registerForMmiComplete(mHandler, PhoneApp.MMI_COMPLETE, null);
			mCM.registerForCallWaiting(mHandler, PHONE_CDMA_CALL_WAITING, null);
			mCM.registerForPostDialCharacter(mHandler, POST_ON_DIAL_CHARS, null);
			mCM.registerForSuppServiceFailed(mHandler, SUPP_SERVICE_FAILED,
					null);
			mCM.registerForIncomingRing(mHandler, PHONE_INCOMING_RING, null);
			mCM.registerForNewRingingConnection(mHandler,
					PHONE_NEW_RINGING_CONNECTION, null);
			mRegisteredForPhoneStates = true;
		}
	}

private void internalResolveIntent(Intent intent) {
		if (intent == null || intent.getAction() == null) {
			return;
		}
		String action = intent.getAction();
		if (DBG)
			log("internalResolveIntent: action=" + action);

		// In gingerbread and earlier releases, the InCallScreen used to
		// directly handle certain intent actions that could initiate phone
		// calls, namely ACTION_CALL and ACTION_CALL_EMERGENCY, and also
		// OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING.
		//
		// But it doesn't make sense to tie those actions to the InCallScreen
		// (or especially to the *activity lifecycle* of the InCallScreen).
		// Instead, the InCallScreen should only be concerned with running the
		// onscreen UI while in a call. So we've now offloaded the call-control
		// functionality to a new module called CallController, and OTASP calls
		// are now launched from the OtaUtils startInteractiveOtasp() or
		// startNonInteractiveOtasp() methods.
		//
		// So now, the InCallScreen is only ever launched using the ACTION_MAIN
		// action, and (upon launch) performs no functionality other than
		// displaying the UI in a state that matches the current telephony
		// state.

		if (action.equals(intent.ACTION_MAIN)) {
			// This action is the normal way to bring up the in-call UI.
			//
			// Most of the interesting work of updating the onscreen UI (to
			// match the current telephony state) happens in the
			// syncWithPhoneState() => updateScreen() sequence that happens in
			// onResume().
			//
			// But we do check here for one extra that can come along with the
			// ACTION_MAIN intent:

			if (intent.hasExtra(SHOW_DIALPAD_EXTRA)) {
				// SHOW_DIALPAD_EXTRA can be used here to specify whether the
				// DTMF
				// dialpad should be initially visible. If the extra isn't
				// present at all, we just leave the dialpad in its previous
				// state.

				boolean showDialpad = intent.getBooleanExtra(
						SHOW_DIALPAD_EXTRA, false);
				if (VDBG)
					log("- internalResolveIntent: SHOW_DIALPAD_EXTRA: "
							+ showDialpad);

				// If SHOW_DIALPAD_EXTRA is specified, that overrides whatever
				// the previous state of inCallUiState.showDialpad was.
				mApp.inCallUiState.showDialpad = showDialpad;
			}
			// ...and in onResume() we'll update the onscreen dialpad state to
			// match the InCallUiState.

			return;
		}

		if (action.equals(OtaUtils.ACTION_DISPLAY_ACTIVATION_SCREEN)) {
			// Bring up the in-call UI in the OTASP-specific "activate" state;
			// see OtaUtils.startInteractiveOtasp(). Note that at this point
			// the OTASP call has not been started yet; we won't actually make
			// the call until the user presses the "Activate" button.

			if (!TelephonyCapabilities.supportsOtasp(mPhone)) {
				throw new IllegalStateException(
						"Received ACTION_DISPLAY_ACTIVATION_SCREEN intent on non-OTASP-capable device: "
								+ intent);
			}

			setInCallScreenMode(InCallScreenMode.OTA_NORMAL);
			if ((mApp.cdmaOtaProvisionData != null)
					&& (!mApp.cdmaOtaProvisionData.isOtaCallIntentProcessed)) {
				mApp.cdmaOtaProvisionData.isOtaCallIntentProcessed = true;
				mApp.cdmaOtaScreenState.otaScreenState = CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION;
			}
			return;
		}

		// Various intent actions that should no longer come here directly:
		if (action.equals(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING)) {
			// This intent is now handled by the InCallScreenShowActivation
			// activity, which translates it into a call to
			// OtaUtils.startInteractiveOtasp().
			throw new IllegalStateException(
					"Unexpected ACTION_PERFORM_CDMA_PROVISIONING received by InCallScreen: "
							+ intent);
		} else if (action.equals(Intent.ACTION_CALL)
				|| action.equals(Intent.ACTION_CALL_EMERGENCY)) {
			// ACTION_CALL* intents go to the OutgoingCallBroadcaster, which now
			// translates them into CallController.placeCall() calls rather than
			// launching the InCallScreen directly.
			throw new IllegalStateException(
					"Unexpected CALL action received by InCallScreen: "
							+ intent);
		} else if (action.equals(ACTION_UNDEFINED)) {
			// This action is only used for internal bookkeeping; we should
			// never actually get launched with it.
			Log.wtf(LOG_TAG,
					"internalResolveIntent: got launched with ACTION_UNDEFINED");
			return;
		} else {
			Log.wtf(LOG_TAG,
					"internalResolveIntent: unexpected intent action: "
							+ action);
			// But continue the best we can (basically treating this case
			// like ACTION_MAIN...)
			return;
		}
	}

// Create the CallNotifer singleton, which handles
			// asynchronous events from the telephony layer (like
			// launching the incoming-call UI when an incoming call comes
			// in.)
			notifier = CallNotifier.init(this, phone, ringer, mBtHandsfree,
					new CallLogAsync());

/**
     * Initialize the singleton CallNotifier instance.
     * This is only done once, at startup, from PhoneApp.onCreate().
     */
    /* package */ static CallNotifier init(PhoneApp app, Phone phone, Ringer ringer,
                                           BluetoothHandsfree btMgr, CallLogAsync callLog) {
        synchronized (CallNotifier.class) {
            if (sInstance == null) {
                sInstance = new CallNotifier(app, phone, ringer, btMgr, callLog);
            } else {
                Log.wtf(LOG_TAG, "init() called multiple times!  sInstance = " + sInstance);
            }
            return sInstance;
        }
    }

/** Private constructor; @see init() */
    private CallNotifier(PhoneApp app, Phone phone, Ringer ringer,
                         BluetoothHandsfree btMgr, CallLogAsync callLog) {
        mApplication = app;
        mCM = app.mCM;
        mCallLog = callLog;

        mAudioManager = (AudioManager) mApplication.getSystemService(Context.AUDIO_SERVICE);
        //跟CallManager注册通知，跟Framework通訊
        registerForNotifications();

        // Instantiate the ToneGenerator for SignalInfo and CallWaiting
        // TODO: We probably don't need the mSignalInfoToneGenerator instance
        // around forever. Need to change it so as to create a ToneGenerator instance only
        // when a tone is being played and releases it after its done playing.
        try {
            mSignalInfoToneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL,
                    TONE_RELATIVE_VOLUME_SIGNALINFO);
        } catch (RuntimeException e) {
            Log.w(LOG_TAG, "CallNotifier: Exception caught while creating " +
                    "mSignalInfoToneGenerator: " + e);
            mSignalInfoToneGenerator = null;
        }

        mRinger = ringer;
        mBluetoothHandsfree = btMgr;

        TelephonyManager telephonyManager = (TelephonyManager)app.getSystemService(
                Context.TELEPHONY_SERVICE);
        telephonyManager.listen(mPhoneStateListener,
                PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR
                | PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR);
    }

private void registerForNotifications() {
        mCM.registerForNewRingingConnection(this, PHONE_NEW_RINGING_CONNECTION, null);
        mCM.registerForPreciseCallStateChanged(this, PHONE_STATE_CHANGED, null);
        mCM.registerForDisconnect(this, PHONE_DISCONNECT, null);
        mCM.registerForUnknownConnection(this, PHONE_UNKNOWN_CONNECTION_APPEARED, null);
        mCM.registerForIncomingRing(this, PHONE_INCOMING_RING, null);
        mCM.registerForCdmaOtaStatusChange(this, EVENT_OTA_PROVISION_CHANGE, null);
        mCM.registerForCallWaiting(this, PHONE_CDMA_CALL_WAITING, null);
        mCM.registerForDisplayInfo(this, PHONE_STATE_DISPLAYINFO, null);
        mCM.registerForSignalInfo(this, PHONE_STATE_SIGNALINFO, null);
        mCM.registerForInCallVoicePrivacyOn(this, PHONE_ENHANCED_VP_ON, null);
        mCM.registerForInCallVoicePrivacyOff(this, PHONE_ENHANCED_VP_OFF, null);
        mCM.registerForRingbackTone(this, PHONE_RINGBACK_TONE, null);
        mCM.registerForResendIncallMute(this, PHONE_RESEND_MUTE, null);
    }

@Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case PHONE_NEW_RINGING_CONNECTION:
                log("RINGING... (new)");
                onNewRingingConnection((AsyncResult) msg.obj);
                mSilentRingerRequested = false;
                break;

            case PHONE_INCOMING_RING:
                // repeat the ring when requested by the RIL, and when the user has NOT
                // specifically requested silence.
                if (msg.obj != null && ((AsyncResult) msg.obj).result != null) {
                    PhoneBase pb =  (PhoneBase)((AsyncResult)msg.obj).result;

                    if ((pb.getState() == Phone.State.RINGING)
                            && (mSilentRingerRequested == false)) {
                        if (DBG) log("RINGING... (PHONE_INCOMING_RING event)");
                        mRinger.ring();
                    } else {
                        if (DBG) log("RING before NEW_RING, skipping");
                    }
                }
                break;

            case PHONE_STATE_CHANGED:
                onPhoneStateChanged((AsyncResult) msg.obj);
                break;

            case PHONE_DISCONNECT:
                if (DBG) log("DISCONNECT");
                onDisconnect((AsyncResult) msg.obj);
                break;

            case PHONE_UNKNOWN_CONNECTION_APPEARED:
                onUnknownConnectionAppeared((AsyncResult) msg.obj);
                break;

            case RINGER_CUSTOM_RINGTONE_QUERY_TIMEOUT:
                // CallerInfo query is taking too long!  But we can't wait
                // any more, so start ringing NOW even if it means we won't
                // use the correct custom ringtone.
                Log.w(LOG_TAG, "CallerInfo query took too long; manually starting ringer");

                // In this case we call onCustomRingQueryComplete(), just
                // like if the query had completed normally.  (But we're
                // going to get the default ringtone, since we never got
                // the chance to call Ringer.setCustomRingtoneUri()).
                onCustomRingQueryComplete();
                break;

            case PHONE_MWI_CHANGED:
                onMwiChanged(mApplication.phone.getMessageWaitingIndicator());
                break;

            case PHONE_BATTERY_LOW:
                onBatteryLow();
                break;

            case PHONE_CDMA_CALL_WAITING:
                if (DBG) log("Received PHONE_CDMA_CALL_WAITING event");
                onCdmaCallWaiting((AsyncResult) msg.obj);
                break;

            case CDMA_CALL_WAITING_REJECT:
                Log.i(LOG_TAG, "Received CDMA_CALL_WAITING_REJECT event");
                onCdmaCallWaitingReject();
                break;

            case CALLWAITING_CALLERINFO_DISPLAY_DONE:
                Log.i(LOG_TAG, "Received CALLWAITING_CALLERINFO_DISPLAY_DONE event");
                mCallWaitingTimeOut = true;
                onCdmaCallWaitingReject();
                break;

            case CALLWAITING_ADDCALL_DISABLE_TIMEOUT:
                if (DBG) log("Received CALLWAITING_ADDCALL_DISABLE_TIMEOUT event ...");
                // Set the mAddCallMenuStateAfterCW state to true
                mApplication.cdmaPhoneCallState.setAddCallMenuStateAfterCallWaiting(true);
                mApplication.updateInCallScreen();
                break;

            case PHONE_STATE_DISPLAYINFO:
                if (DBG) log("Received PHONE_STATE_DISPLAYINFO event");
                onDisplayInfo((AsyncResult) msg.obj);
                break;

            case PHONE_STATE_SIGNALINFO:
                if (DBG) log("Received PHONE_STATE_SIGNALINFO event");
                onSignalInfo((AsyncResult) msg.obj);
                break;

            case DISPLAYINFO_NOTIFICATION_DONE:
                if (DBG) log("Received Display Info notification done event ...");
                CdmaDisplayInfo.dismissDisplayInfoRecord();
                break;

            case EVENT_OTA_PROVISION_CHANGE:
                if (DBG) log("EVENT_OTA_PROVISION_CHANGE...");
                mApplication.handleOtaspEvent(msg);
                break;

            case PHONE_ENHANCED_VP_ON:
                if (DBG) log("PHONE_ENHANCED_VP_ON...");
                if (!mVoicePrivacyState) {
                    int toneToPlay = InCallTonePlayer.TONE_VOICE_PRIVACY;
                    new InCallTonePlayer(toneToPlay).start();
                    mVoicePrivacyState = true;
                    // Update the VP icon:
                    if (DBG) log("- updating notification for VP state...");
                    mApplication.notificationMgr.updateInCallNotification();
                }
                break;

            case PHONE_ENHANCED_VP_OFF:
                if (DBG) log("PHONE_ENHANCED_VP_OFF...");
                if (mVoicePrivacyState) {
                    int toneToPlay = InCallTonePlayer.TONE_VOICE_PRIVACY;
                    new InCallTonePlayer(toneToPlay).start();
                    mVoicePrivacyState = false;
                    // Update the VP icon:
                    if (DBG) log("- updating notification for VP state...");
                    mApplication.notificationMgr.updateInCallNotification();
                }
                break;

            case PHONE_RINGBACK_TONE:
                onRingbackTone((AsyncResult) msg.obj);
                break;

            case PHONE_RESEND_MUTE:
                onResendMute();
                break;

            case UPDATE_IN_CALL_NOTIFICATION:
                mApplication.notificationMgr.updateInCallNotification();
                break;

            default:
                // super.handleMessage(msg);
        }
    }

case PHONE_STATE_CHANGED:
                onPhoneStateChanged((AsyncResult) msg.obj);
                break;

/**
     * Updates the phone UI in response to phone state changes.
     *
     * Watch out: certain state changes are actually handled by their own
     * specific methods:
     *   - see onNewRingingConnection() for new incoming calls
     *   - see onDisconnect() for calls being hung up or disconnected
     */
    private void onPhoneStateChanged(AsyncResult r) {
        Phone.State state = mCM.getState();
        if (VDBG) log("onPhoneStateChanged: state = " + state);

        // Turn status bar notifications on or off depending upon the state
        // of the phone.  Notification Alerts (audible or vibrating) should
        // be on if and only if the phone is IDLE.
        mApplication.notificationMgr.statusBarHelper
                .enableNotificationAlerts(state == Phone.State.IDLE);

        Phone fgPhone = mCM.getFgPhone();
        if (fgPhone.getPhoneType() == Phone.PHONE_TYPE_CDMA) {
            if ((fgPhone.getForegroundCall().getState() == Call.State.ACTIVE)
                    && ((mPreviousCdmaCallState == Call.State.DIALING)
                    ||  (mPreviousCdmaCallState == Call.State.ALERTING))) {
                if (mIsCdmaRedialCall) {
                    int toneToPlay = InCallTonePlayer.TONE_REDIAL;
                    new InCallTonePlayer(toneToPlay).start();
                }
                // Stop any signal info tone when call moves to ACTIVE state
                stopSignalInfoTone();
            }
            mPreviousCdmaCallState = fgPhone.getForegroundCall().getState();
        }

        // Have the PhoneApp recompute its mShowBluetoothIndication
        // flag based on the (new) telephony state.
        // There's no need to force a UI update since we update the
        // in-call notification ourselves (below), and the InCallScreen
        // listens for phone state changes itself.
        mApplication.updateBluetoothIndication(false);

        // Update the proximity sensor mode (on devices that have a
        // proximity sensor).
        mApplication.updatePhoneState(state);

        if (state == Phone.State.OFFHOOK) {
            // stop call waiting tone if needed when answering
            if (mCallWaitingTonePlayer != null) {
                mCallWaitingTonePlayer.stopTone();
                mCallWaitingTonePlayer = null;
            }

            if (VDBG) log("onPhoneStateChanged: OFF HOOK");
            // make sure audio is in in-call mode now
            PhoneUtils.setAudioMode(mCM);

            // if the call screen is showing, let it handle the event,
            // otherwise handle it here.
            if (!mApplication.isShowingCallScreen()) {
                mApplication.setScreenTimeout(PhoneApp.ScreenTimeoutDuration.DEFAULT);
                mApplication.requestWakeState(PhoneApp.WakeState.SLEEP);
            }

            // Since we're now in-call, the Ringer should definitely *not*
            // be ringing any more.  (This is just a sanity-check; we
            // already stopped the ringer explicitly back in
            // PhoneUtils.answerCall(), before the call to phone.acceptCall().)
            // TODO: Confirm that this call really *is* unnecessary, and if so,
            // remove it!
            if (DBG) log("stopRing()... (OFFHOOK state)");
            mRinger.stopRing();

            // Post a request to update the "in-call" status bar icon.
            //
            // We don't call NotificationMgr.updateInCallNotification()
            // directly here, for two reasons:
            // (1) a single phone state change might actually trigger multiple
            //   onPhoneStateChanged() callbacks, so this prevents redundant
            //   updates of the notification.
            // (2) we suppress the status bar icon while the in-call UI is
            //   visible (see updateInCallNotification()).  But when launching
            //   an outgoing call the phone actually goes OFFHOOK slightly
            //   *before* the InCallScreen comes up, so the delay here avoids a
            //   brief flicker of the icon at that point.

            if (DBG) log("- posting UPDATE_IN_CALL_NOTIFICATION request...");
            // Remove any previous requests in the queue
            removeMessages(UPDATE_IN_CALL_NOTIFICATION);
            final int IN_CALL_NOTIFICATION_UPDATE_DELAY = 1000;  // msec
            sendEmptyMessageDelayed(UPDATE_IN_CALL_NOTIFICATION,
                                    IN_CALL_NOTIFICATION_UPDATE_DELAY);
        }

        if (fgPhone.getPhoneType() == Phone.PHONE_TYPE_CDMA) {
            Connection c = fgPhone.getForegroundCall().getLatestConnection();
            if ((c != null) && (PhoneNumberUtils.isLocalEmergencyNumber(c.getAddress(),
                                                                        mApplication))) {
                if (VDBG) log("onPhoneStateChanged: it is an emergency call.");
                Call.State callState = fgPhone.getForegroundCall().getState();
                if (mEmergencyTonePlayerVibrator == null) {
                    mEmergencyTonePlayerVibrator = new EmergencyTonePlayerVibrator();
                }

                if (callState == Call.State.DIALING || callState == Call.State.ALERTING) {
                    mIsEmergencyToneOn = Settings.System.getInt(
                            mApplication.getContentResolver(),
                            Settings.System.EMERGENCY_TONE, EMERGENCY_TONE_OFF);
                    if (mIsEmergencyToneOn != EMERGENCY_TONE_OFF &&
                        mCurrentEmergencyToneState == EMERGENCY_TONE_OFF) {
                        if (mEmergencyTonePlayerVibrator != null) {
                            mEmergencyTonePlayerVibrator.start();
                        }
                    }
                } else if (callState == Call.State.ACTIVE) {
                    if (mCurrentEmergencyToneState != EMERGENCY_TONE_OFF) {
                        if (mEmergencyTonePlayerVibrator != null) {
                            mEmergencyTonePlayerVibrator.stop();
                        }
                    }
                }
            }
        }

        if ((fgPhone.getPhoneType() == Phone.PHONE_TYPE_GSM)
                || (fgPhone.getPhoneType() == Phone.PHONE_TYPE_SIP)) {
            Call.State callState = mCM.getActiveFgCallState();
            if (!callState.isDialing()) {
                // If call get activated or disconnected before the ringback
                // tone stops, we have to stop it to prevent disturbing.
                if (mInCallRingbackTonePlayer != null) {
                    mInCallRingbackTonePlayer.stopTone();
                    mInCallRingbackTonePlayer = null;
                }
            }
        }
    }                    

Phone.State.OFFHOOK    挂断

Phone.State.RINGING      正在来电铃声状态

Phone.State.IDLE               空间状态
例如在通过结束后关闭InCallScreen界面可以添加以下代码

if(Phone.State.OFFHOOK == state){
    finish();
}

Android4.0（Phone）拨号启动过程分析（二）,,5-wow.com