Was passiert auf Systemebene bei einem eingehenden Anruf?

Question

Ich habe den gesamten Quellcode für den Master-Zweig von https://android.googlesource.com/platform/frameworks/base/+/master heruntergeladen und versuche, die Kette von Ereignissen bei einem eingehenden Anruf zu entschlüsseln.

Ich nehme an, dass der ACTION_ANSWER Intent gestartet wurde, aber darüber hinaus nicht weiß, was vorher oder nachher passiert.

Kann jemand helfen?

Answer 1

die bei CallNotifier, indem Sie beginnen lassen:

/** * Telefon App-Modul, das für Telefonzustandsänderungen und verschiedene andere * Ereignisse horcht von der Telefonie-Schicht, und löst alle resultierenden UI Verhalten * (wie das Starten der Rufton und eingehenden Anruf UI, Play-In-Anruf Töne, * Mitteilungen zu aktualisieren, Anrufprotokoll Einträge schreiben, usw.) */

Eine der Botschaften, dass dieser Handler antwortet ist: CallStateMonitor.PHONE_NEW_RINGING_CONNECTION:

case CallStateMonitor.PHONE_NEW_RINGING_CONNECTION: 
    log("RINGING... (new)"); 
    onNewRingingConnection((AsyncResult) msg.obj); 
    mSilentRingerRequested = false; 
    break; 

onNewRingingConnection(AsyncResult) schließlich (und im Allgemeinen ringAndNotifyOfIncomingCall(Connection c) Fall) aufruft:

private void ringAndNotifyOfIncomingCall(Connection c) { 
    if (PhoneUtils.isRealIncomingCall(c.getState())) { 
     mRinger.ring(); 
    } else { 
     if (VDBG) log("- starting call waiting tone..."); 
      if (mCallWaitingTonePlayer == null) { 
       mCallWaitingTonePlayer = new InCallTonePlayer(
             InCallTonePlayer.TONE_CALL_WAITING); 
       mCallWaitingTonePlayer.start(); 
      } 
    } 

    // CallModeler.onNewRingingConnection(Connection) 
    mCallModeler.onNewRingingConnection(c); 
} 

CallModeler.onNewRingingConnection(Connection) (Link) befestigt Hörer benachrichtigt:

for (int i = 0; i < mListeners.size(); ++i) { 
    mListeners.get(i).onIncoming(call); 
} 

Diese Listener implementieren Schnittstelle. CallHandlerServiceProxy ist ein solcher Zuhörer, und seine onIncoming(Call) Rückruf Brände CallHandlerServiceProxy.processIncoming(Call):

private void processIncoming(Call call) { 
    .... 
    // ICallHandlerService 
    mCallHandlerServiceGuarded.onIncoming(call, 
        RejectWithTextMessageManager.loadCannedResponses()); 
    .... 
} 

CallHandlerService definiert ein ICallHandlerService.Stub Mitglied und seine onIncoming(Call, List<String>) Methode wie folgt aussieht:

@Override 
public void onIncoming(Call call, List<String> textResponses) { 
    .... 
    mMainHandler.sendMessage(mMainHandler.obtainMessage(
        ON_UPDATE_CALL_WITH_TEXT_RESPONSES, incomingCall)); 
    .... 
} 

Dies ist, wie mMainHandler Griffe Fall ON_UPDATE_CALL_WITH_TEXT_RESPONSES:

case ON_UPDATE_CALL_WITH_TEXT_RESPONSES: 
    AbstractMap.SimpleEntry<Call, List<String>> entry 
        = (AbstractMap.SimpleEntry<Call, List<String>>) msg.obj; 
    Log.i(TAG, "ON_INCOMING_CALL: " + entry.getKey()); 

    // CallList 
    mCallList.onIncoming(entry.getKey(), entry.getValue()); 
    break; 

CallList verwaltet eine Liste der Listener, die CallList.Listener implementieren, und löst ihr onIncomingCall(Call)-Ereignis aus der CallList.onIncoming(Call, List<String>)-Methode aus.Jetzt

, lassen Sie sich bei InCallPresenter aussehen:

/** * nimmt Updates von der Anrufliste und benachrichtigt die InCallActivity (UI) * die Änderungen. * Verantwortlich für das Starten der Aktivität für einen neuen Anruf und Beenden der Aktivität, wenn alle Anrufe * getrennt sind. * Erstellt und verwaltet den Anrufstatus und stellt ein Listener-Muster für die Moderatoren * bereit, die die Statusänderungen des Anrufers im Status abhören möchten. * TODO: Diese Klasse ist an diesem Punkt eher ein Zustand Maschine geworden. Überlegen Sie, umzubenennen. */

InCallPresenter implementiert CallList.Listener-Schnittstelle und ist für den Start InCallActivity verantwortlich, die die Benutzeroberfläche für alle Telefon bezogene Operationen zur Verfügung stellt. Der folgende Kommentar (aus InCallPresenter.startOrFinishUi(InCallState)) bringt die oben genannte Kette von Ereignissen zusammen:

/* A new Incoming call means that the user needs to be notified of the 
    the call (since it wasn't them who initiated it). We do this 
    through full screen notifications and happens indirectly through {@link 
    StatusBarListener}. The process for incoming calls is as follows: 

    1) CallList   - Announces existence of new INCOMING call 
    2) InCallPresenter - Gets announcement and calculates that the new 
          InCallState should be set to INCOMING. 
    3) InCallPresenter - This method is called to see if we need to 
          start or finish the app given the new state. 
    4) StatusBarNotifier - Listens to InCallState changes. InCallPresenter 
          calls StatusBarNotifier explicitly to issue a 
          FullScreen Notification that will either start the 
          InCallActivity or show the user a top-level 
          notification dialog if the user is in 
          an immersive app. That notification can also start 
          the InCallActivity.   
    5) InCallActivity - Main activity starts up and at the end of its 
          onCreate will call InCallPresenter::setActivity() 
          to let the presenter know that start-up is complete. 
        [ AND NOW YOU'RE IN THE CALL. voila! ] */ 

Ich hoffe, dass dies Ihre Frage beantwortet, oder zumindest, zeigt Ihnen, wo Sie suchen. Fühlen Sie sich frei, alles zu korrigieren, was ich übersehen/falsch interpretiert habe.

Answer 2

haben einen Blick auf diese Grep code InCallScreen.java

else if (action.equals(Intent.ACTION_ANSWER)) { 
     internalAnswerCall(); 
     app.setRestoreMuteOnInCallResume(false); 
     return InCallInitStatus.SUCCESS; 

Answer 3

Hoffnung unten-Code Sie Hilfe.

@Override 
    public void onCallStateChanged(int state, String incomingNumber) { 
     super.onCallStateChanged(state, incomingNumber); 
     switch(state){ 
     case TelephonyManager.CALL_STATE_IDLE: 
      //Not in call: Play music 

      break; 
     case TelephonyManager.CALL_STATE_OFFHOOK: 
      //A call is dialing, active or on hold 

      break; 
     case TelephonyManager.CALL_STATE_RINGING: 
      //Incoming call: Pause music 

      break; 

     }    
    } 

Die Google-Referenz
http://developer.android.com/reference/android/telephony/TelephonyManager.html