前面分析了电话拨号界面及电话呼叫界面，由于Android的电话Phone设计的很复杂，因此先从UI层入手分析。想要了解Android的电话拨号UI，请查看Android电话拨号UI分析，电话拨号UI在Contacts包中。想要了解Android电话呼叫UI，请查看Android电话Phone UI分析，该UI在Phone包中，了解完电话想要UI后，还必须首先了解Android的Phone设计框架，Android电话Phone设计框架介绍介绍了Phone的框架设计及Phone进程的启动，本文以源码的形式介绍Android的电话拨打流程。点击Launcher上的拨号图标，首先进入电话拨号界面，前面已经分析了，该UI在Contacts包中，启动显示的是DialtactsActivity，关于DialtactsActivity的布局解析、UI布局在Android电话拨号UI分析中有详细的分析，这里不在重复介绍。我们从点击拨号按钮开始分析电话的拨号流程：

DialpadFragment.java

[html] view plain copy
  1. publicViewonCreateView(LayoutInflaterinflater,ViewGroupcontainer,BundlesavedState){
  2. ...
  3. //Checkwhetherweshouldshowtheonscreen"Dial"button.
  4. mDialButton=mAdditionalButtonsRow.findViewById(R.id.dialButton);
  5. if(r.getBoolean(R.bool.config_show_onscreen_dial_button)){
  6. mDialButton.setOnClickListener(this);
  7. }else{
  8. mDialButton.setVisibility(View.GONE);//It'sVISIBLEbydefault
  9. mDialButton=null;
  10. }
  11. ...

拨号按钮的单击事件响应：

[java] view plain copy
  1. publicvoidonClick(Viewview){
  2. switch(view.getId()){
  3. caseR.id.dialButton:{
  4. mHaptic.vibrate();
  5. dialButtonPressed();
  6. return;
  7. }
  8. ...
  9. }
  10. }

调用dialButtonPressed()函数发起电话呼叫

[java] view plain copy
  1. publicvoiddialButtonPressed(){
  2. if(mDigits==null){
  3. Log.e(TAG,"dialButtonPressed,mDigits==null");
  4. return;
  5. }
  6. //未输入号码处理
  7. if(isDigitsEmpty()){
  8. handleDialButtonClickWithEmptyDigits();
  9. }else{
  10. finalStringnumber=mDigits.getText().toString();
  11. //"persist.radio.otaspdial"isatemporaryhackneededforonecarrier'sautomated
  12. //testequipment.
  13. if(number!=null&&!TextUtils.isEmpty(mProhibitedPhoneNumberRegexp)
  14. &&number.matches(mProhibitedPhoneNumberRegexp)
  15. &&(SystemProperties.getInt("persist.radio.otaspdial",0)!=1)){
  16. Log.i(TAG,"Thephonenumberisprohibitedexplicitlybyarule.");
  17. if(getActivity()!=null){
  18. DialogFragmentdialogFragment=ErrorDialogFragment.newInstance(
  19. R.string.dialog_phone_call_prohibited_title);
  20. dialogFragment.show(getFragmentManager(),"phone_prohibited_dialog");
  21. }
  22. //号码输入不正确.
  23. mDigits.getText().clear();
  24. }elseif(number!=null&&(number.startsWith(",")||number.startsWith(";"))){
  25. mDigits.getText().clear();
  26. if(getActivity()!=null){
  27. Toast.makeText(getActivity(),getText(R.string.invalid_number),
  28. Toast.LENGTH_SHORT).show();
  29. }
  30. }else{
  31. //启动电话呼叫界面
  32. finalIntentintent=ContactsUtils.getCallIntent(number,(getActivity()instanceofDialtactsActivity?
  33. ((DialtactsActivity)getActivity()).getCallOrigin():null));
  34. startActivity(intent);
  35. mClearDigitsOnStop=true;
  36. mDigits.getText().clear();
  37. if(mFlagIntentNumber){
  38. getActivity().finish();
  39. }
  40. }
  41. }
  42. }

函数首先对输入的号码进行检查，如果没有输入号码，直接按下拨号按钮，则调用handleDialButtonClickWithEmptyDigits函数来处理

[java] view plain copy
  1. privatevoidhandleDialButtonClickWithEmptyDigits(){
  2. if(phoneIsCdma()&&phoneIsOffhook()){
  3. //ThisisreallyCDMAspecific.OnGSMisitpossible
  4. //tobeoffhookandwantedtoadda3rdpartyusing
  5. //theredialfeature.
  6. startActivity(newFlashIntent());
  7. }else{
  8. if(mDigits!=null&&!TextUtils.isEmpty(mLastNumberDialed)){
  9. //Recallthelastnumberdialed.
  10. mDigits.setText(mLastNumberDialed);
  12. //...andmovethecursortotheendofthedigitsstring,
  13. //soyou'llbeabletodeletedigitsusingtheDelete
  14. //button(justasifyouhadtypedthenumbermanually.)
  15. //
  16. //NoteweusemDigits.getText().length()here,not
  17. //mLastNumberDialed.length(),sincetheEditTextwidgetnow
  18. //containsa*formatted*versionofmLastNumberDialed(dueto
  19. //mTextWatcher)anditslengthmayhavechanged.
  20. mDigits.setSelection(mDigits.getText().length());
  21. }else{
  22. //There'sno"lastnumberdialed"orthe
  23. //backgroundqueryisstillrunning.There's
  24. //nothingusefulfortheDialbuttontodoin
  25. //thiscase.Note:withasoftdialbutton,this
  26. //canneverhappenssincethedialbuttonis
  27. //disabledundertheseconditons.
  28. playTone(ToneGenerator.TONE_PROP_NACK);
  29. }
  30. }
  31. }

如果号码输入正确合法，则使用ContactsUtils工具类来创建一个Intent。

DialtactsActivity.java

[java] view plain copy
  1. publicStringgetCallOrigin(){
  2. return!isDialIntent(getIntent())?CALL_ORIGIN_DIALTACTS:null;
  3. }
  5. /**Returnstrueifthegivenintentcontainsaphonenumbertopopulatethedialerwith*/
  6. privatebooleanisDialIntent(Intentintent){
  7. finalStringaction=intent.getAction();
  8. if(Intent.ACTION_DIAL.equals(action)||ACTION_TOUCH_DIALER.equals(action)){
  9. returntrue;
  10. }
  11. if(Intent.ACTION_VIEW.equals(action)){
  12. finalUridata=intent.getData();
  13. if(data!=null&&Constants.SCHEME_TEL.equals(data.getScheme())){
  14. returntrue;
  15. }
  16. }
  17. returnfalse;
  18. }

从Launcher点击拨号图标进入的，因此isDialIntent返回true，getCallOrigin返回null

ContactsUtils.java

[java] view plain copy
  1. publicstaticIntentgetCallIntent(Stringnumber,StringcallOrigin){
  2. returngetCallIntent(getCallUri(number),callOrigin);
  3. }
  5. publicstaticIntentgetCallIntent(Uriuri,StringcallOrigin){
  6. finalIntentintent=newIntent(Intent.ACTION_CALL_PRIVILEGED,uri);
  7. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  8. if(callOrigin!=null){
  9. intent.putExtra(DialtactsActivity.EXTRA_CALL_ORIGIN,callOrigin);
  10. }
  11. returnintent;
  12. }

action为Intent.ACTION_CALL_PRIVILEGED，因此使用隐式启动OutgoingCallBroadcaster

因此Phone进程中的OutgoingCallBroadcaster将被启动。google对电话拨号步骤有详细的说明：

/*
* Here's the most typical outgoing call sequence:
*
* (1) OutgoingCallBroadcaster receives a CALL intent and sends the
* NEW_OUTGOING_CALL broadcast
*
* (2) The broadcast finally reaches OutgoingCallReceiver, which stashes
* away a copy of the original CALL intent and launches
* SipCallOptionHandler
*
* (3) SipCallOptionHandler decides whether this is a PSTN or SIP call (and
* in some cases brings up a dialog to let the user choose), and
* ultimately calls CallController.placeCall() (from the
* setResultAndFinish() method) with the stashed-away intent from step
* (2) as the "intent" parameter.
*
* (4) Here in CallController.placeCall() we read the phone number or SIP
* address out of the intent and actually initiate the call, and
* simultaneously launch the InCallScreen to display the in-call UI.
*
* (5) We handle various errors by directing the InCallScreen to
* display error messages or dialogs (via the InCallUiState
* "pending call status code" flag), and in some cases we also
* sometimes continue working in the background to resolve the
* problem (like in the case of an emergency call while in
* airplane mode). Any time that some onscreen indication to the
* user needs to change, we update the "status dialog" info in
* the inCallUiState and (re)launch the InCallScreen to make sure
* it's visible.
*/

如OutgoingCallBroadcaster接收 CALL 和CALL_PRIVILEGED 两种Intents，然后广播出ACTION_NEW_OUTGOING_CALL intent，让别的应用程序有机会去监视这些intent，最后这些呼叫intent又被自己收到转换，启动InCallScreen.

src\com\android\phone\OutgoingCallBroadcaster.java

[java] view plain copy
  1. protectedvoidonCreate(Bundleicicle){
  2. super.onCreate(icicle);
  3. setContentView(R.layout.outgoing_call_broadcaster);
  4. mWaitingSpinner=(ProgressBar)findViewById(R.id.spinner);
  6. Intentintent=getIntent();
  7. if(DBG){
  8. finalConfigurationconfiguration=getResources().getConfiguration();
  9. Log.v(TAG,"onCreate:this="+this+",icicle="+icicle);
  10. Log.v(TAG,"-getIntent()="+intent);
  11. Log.v(TAG,"-configuration="+configuration);
  12. }
  14. if(icicle!=null){
  15. //icicle不为空，表示重新初始化先前关闭的OutgoingCallBroadcaster，
  16. //Inpracticethishappensveryrarely(becausethelifetime
  17. //ofthisactivityissoshort!),butit*can*happenifthe
  18. //frameworkdetectsaconfigurationchangeatexactlythe
  19. //rightmoment;
  20. //Inthiscase,donothing.OuronCreate()methodhasalready
  21. //runonce(withicicle==nullthefirsttime),whichmeans
  22. //thattheNEW_OUTGOING_CALLbroadcastforthisnewcallhas
  23. //alreadybeensent.
  24. Log.i(TAG,"onCreate:non-nullicicle!"
  25. +"Bailingout,notsendingNEW_OUTGOING_CALLbroadcast...");
  26. return;
  27. }
  28. //处理得到的intent
  29. processIntent(intent);
  30. if(DBG)Log.v(TAG,"AttheendofonCreate().isFinishing():"+isFinishing());
  31. }

函数直接调用processIntent函数处理前面发送过来的intent，该方法可以处理以下三种actions，

CALL (action for usual outgoing voicecalls)

CALL_PRIVILEGED (can come from built-inapps like contacts / voice dialer / bluetooth)

CALL_EMERGENCY (from the EmergencyDialerthat's reachable from the lockscreen.)

对于数据为tel: URI的电话处理流程为：OutgoingCallReceiver -> SipCallOptionHandler ->InCallScreen.

对于数据为sip: URI的网络电话，则跳过NEW_OUTGOING_CALL广播，直接调用SipCallOptionHandler处理

对于数据为voicemail: URIs的语音信箱处理同电话处理流程类似

[java] view plain copy
  1. privatevoidprocessIntent(Intentintent){
  2. if(DBG){
  3. Log.v(TAG,"processIntent()="+intent+",thread:"+Thread.currentThread());
  4. }
  5. finalConfigurationconfiguration=getResources().getConfiguration();
  7. //电话拨号只对具有语音通信能力的设备而言
  8. if(!PhoneGlobals.sVoiceCapable){
  9. Log.i(TAG,"Thisdeviceisdetectedasnon-voice-capabledevice.");
  10. handleNonVoiceCapable(intent);
  11. return;
  12. }
  13. //得到相应的Action
  14. Stringaction=intent.getAction();
  15. //从Intent中取出电话号码
  16. Stringnumber=PhoneNumberUtils.getNumberFromIntent(intent,this);
  17. //电话号码检查
  18. if(number!=null){
  19. if(!PhoneNumberUtils.isUriNumber(number)){
  20. //根据键盘map将字符转换为相应的数字
  21. number=PhoneNumberUtils.convertKeypadLettersToDigits(number);
  22. number=PhoneNumberUtils.stripSeparators(number);
  23. }
  24. }else{
  25. Log.w(TAG,"ThenumberobtainedfromIntentisnull.");
  26. }
  27. //如果callNow为true，表示当前为不允许拦截的如紧急拨号，这种情形下就无需这NEW_OUTGOING_CALL流程
  28. booleancallNow;
  30. if(getClass().getName().equals(intent.getComponent().getClassName())){
  31. //IfwewerelauncheddirectlyfromtheOutgoingCallBroadcaster,
  32. //notoneofitsmoreprivilegedaliases,thenmakesurethat
  33. //onlythenon-privilegedactionsareallowed.
  34. if(!Intent.ACTION_CALL.equals(intent.getAction())){
  35. Log.w(TAG,"Attempttodelivernon-CALLaction;forcingtoCALL");
  36. intent.setAction(Intent.ACTION_CALL);
  37. }
  38. }
  40. //检查当前号码是否为紧急号码，只有CALL_PRIVILEGED和CALL_EMERGENCY类型的intent才允许拨打紧急号码
  41. //(NotethattheACTION_CALLcheckbelowdependsontheresultof
  42. //isPotentialLocalEmergencyNumber()ratherthanjustplain
  43. //isLocalEmergencyNumber()
  44. //100%确保第三方应用不允许通过传递如"9111234"这种无效号码来拨打紧急号码
  45. finalbooleanisExactEmergencyNumber=(number!=null)&&PhoneNumberUtils.isLocalEmergencyNumber(number,this);
  46. finalbooleanisPotentialEmergencyNumber=(number!=null)&&PhoneNumberUtils.isPotentialLocalEmergencyNumber(number,this);
  47. if(VDBG){
  48. Log.v(TAG,"-Checkingrestrictionsfornumber'"+number+"':");
  49. Log.v(TAG,"isExactEmergencyNumber="+isExactEmergencyNumber);
  50. Log.v(TAG,"isPotentialEmergencyNumber="+isPotentialEmergencyNumber);
  51. }
  53. if(Intent.ACTION_CALL_PRIVILEGED.equals(action)){
  54. if(isPotentialEmergencyNumber){
  55. Log.i(TAG,"ACTION_CALL_PRIVILEGEDisusedwhilethenumberisapotential"
  56. +"emergencynumber.UseACTION_CALL_EMERGENCYasanactioninstead.");
  57. action=Intent.ACTION_CALL_EMERGENCY;
  58. }else{
  59. action=Intent.ACTION_CALL;
  60. }
  61. if(DBG)Log.v(TAG,"-updatingactionfromCALL_PRIVILEGEDto"+action);
  62. intent.setAction(action);
  63. }
  64. //如果普通拨打的号码为紧急号码，则启动电话拨号器
  65. if(Intent.ACTION_CALL.equals(action)){
  66. if(isPotentialEmergencyNumber){
  67. Log.w(TAG,"Cannotcallpotentialemergencynumber'"+number
  68. +"'withCALLIntent"+intent+".");
  69. Log.i(TAG,"Launchingdefaultdialerinstead...");
  70. //启动默认的电话拨号器DialtactsActivity
  71. IntentinvokeFrameworkDialer=newIntent();
  72. invokeFrameworkDialer.setClassName("com.android.contacts","com.android.contacts.DialtactsActivity");
  73. invokeFrameworkDialer.setAction(Intent.ACTION_DIAL);
  74. invokeFrameworkDialer.setData(intent.getData());
  75. if(DBG)Log.v(TAG,"onCreate():callingstartActivityforDialer:"+invokeFrameworkDialer);
  76. startActivity(invokeFrameworkDialer);
  77. finish();
  78. return;
  79. }
  80. callNow=false;
  81. //如果是紧急拨号，1.通过紧急拨号器拨号；2.ACTION_CALL_PRIVILEGED拨打紧急号码；将callNow设置为true
  82. }elseif(Intent.ACTION_CALL_EMERGENCY.equals(action)){
  83. if(!isPotentialEmergencyNumber){
  84. Log.w(TAG,"Cannotcallnon-potential-emergencynumber"+number
  85. +"withEMERGENCY_CALLIntent"+intent+"."
  86. +"FinishtheActivityimmediately.");
  87. finish();
  88. return;
  89. }
  90. callNow=true;
  91. }else{
  92. Log.e(TAG,"UnhandledIntent"+intent+".FinishtheActivityimmediately.");
  93. finish();
  94. return;
  95. }
  96. //唤醒屏幕
  97. PhoneGlobals.getInstance().wakeUpScreen();
  98. //Ifnumberisnull,we'reprobablytryingtocallanon-existentvoicemailnumber,
  99. //sendanemptyflashorsomethingelseisfishy.Whatevertheproblem,there'sno
  100. //number,sothere'snopointinallowingappstomodifythenumber.
  101. if(TextUtils.isEmpty(number)){
  102. if(intent.getBooleanExtra(EXTRA_SEND_EMPTY_FLASH,false)){
  103. Log.i(TAG,"onCreate:SEND_EMPTY_FLASH...");
  104. PhoneUtils.sendEmptyFlash(PhoneGlobals.getPhone());
  105. finish();
  106. return;
  107. }else{
  108. Log.i(TAG,"onCreate:nulloremptynumber,settingcallNow=true...");
  109. callNow=true;
  110. }
  111. }
  112. //如果是紧急拨号，直接启动拨号界面
  113. if(callNow){
  114. Log.i(TAG,"onCreate():callNowcase!CallingplaceCall():"+intent);
  115. //Initiatetheoutgoingcall,andsimultaneouslylaunchthe
  116. //InCallScreentodisplaythein-callUI:
  117. PhoneGlobals.getInstance().callController.placeCall(intent);
  118. }
  119. //Rememberthecalloriginsothatuserswillbeabletoseeanappropriatescreen
  120. //afterthephonecall.ThisshouldaffectbothphonecallsandSIPcalls.
  121. finalStringcallOrigin=intent.getStringExtra(PhoneGlobals.EXTRA_CALL_ORIGIN);
  122. if(callOrigin!=null){
  123. if(DBG)Log.v(TAG,"-Calloriginispassed("+callOrigin+")");
  124. PhoneGlobals.getInstance().setLatestActiveCallOrigin(callOrigin);
  125. }else{
  126. if(DBG)Log.v(TAG,"-Calloriginisnotpassed.Resetcurrentone.");
  127. PhoneGlobals.getInstance().resetLatestActiveCallOrigin();
  128. }
  129. //Fornow,SIPcallswillbeprocesseddirectlywithouta
  130. //NEW_OUTGOING_CALLbroadcast.
  131. //
  132. //TODO:Inthefuture,though,3rdpartyapps*should*beallowedto
  133. //interceptoutgoingcallstoSIPaddressesaswell.Todothis,weshould
  134. //(1)updatetheNEW_OUTGOING_CALLintentdocumentationtoexplainthis
  135. //case,and(2)passtheoutgoingSIPaddressby*not*overloadingthe
  136. //EXTRA_PHONE_NUMBERextra,butinsteadusinganewseparateextratohold
  137. //theoutgoingSIPaddress.(Besuretodocumentwhetherit'saURIorjust
  138. //aplainaddress,whetheritcouldbeatel:URI,etc.)
  139. Uriuri=intent.getData();
  140. Stringscheme=uri.getScheme();
  141. if(Constants.SCHEME_SIP.equals(scheme)||PhoneNumberUtils.isUriNumber(number)){
  142. Log.i(TAG,"TherequestednumberwasdetectedasSIPcall.");
  143. startSipCallOptionHandler(this,intent,uri,number);
  144. finish();
  145. return;
  146. }
  148. IntentbroadcastIntent=newIntent(Intent.ACTION_NEW_OUTGOING_CALL);
  149. if(number!=null){
  150. broadcastIntent.putExtra(Intent.EXTRA_PHONE_NUMBER,number);
  151. }
  152. PhoneUtils.checkAndCopyPhoneProviderExtras(intent,broadcastIntent);
  153. broadcastIntent.putExtra(EXTRA_ALREADY_CALLED,callNow);
  154. broadcastIntent.putExtra(EXTRA_ORIGINAL_URI,uri.toString());
  155. //Needtoraiseforegroundin-callUIassoonaspossiblewhileallowing3rdpartyapp
  156. //tointercepttheoutgoingcall.
  157. broadcastIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
  158. if(DBG)Log.v(TAG,"-Broadcastingintent:"+broadcastIntent+".");
  159. //发送超时消息，当OutgoingCallReceiver在指定的时间内还未接受到广播时，显示超时
  160. mHandler.sendEmptyMessageDelayed(EVENT_OUTGOING_CALL_TIMEOUT,
  161. OUTGOING_CALL_TIMEOUT_THRESHOLD);
  162. //发送ACTION_NEW_OUTGOING_CALL广播
  163. sendOrderedBroadcastAsUser(broadcastIntent,UserHandle.OWNER,
  164. PERMISSION,newOutgoingCallReceiver(),
  165. null,//scheduler
  166. Activity.RESULT_OK,//initialCode
  167. number,//initialData:initialvaluefortheresultdata
  168. null);//initialExtras
  169. }
首先获取Intent对象，获取拨出的号码。接着判断号码是否为紧急号码，如果是紧急号码，将callNow变量赋值为true，启动InCallScreen，并发送Intent.ACTION_NEW_OUTGOING_CALL广播。
[java] view plain copy
  1. publicvoidonReceive(Contextcontext,Intentintent){
  2. mHandler.removeMessages(EVENT_OUTGOING_CALL_TIMEOUT);
  3. doReceive(context,intent);
  4. if(DBG)Log.v(TAG,"OutgoingCallReceiverisgoingtofinishtheActivityitself.");
  5. finish();
  6. }
直接调用函数doReceive函数来处理ntent.ACTION_NEW_OUTGOING_CALL广播 [java] view plain copy
  1. publicvoiddoReceive(Contextcontext,Intentintent){
  2. if(DBG)Log.v(TAG,"doReceive:"+intent);
  3. booleanalreadyCalled;
  4. Stringnumber;
  5. StringoriginalUri;
  6. alreadyCalled=intent.getBooleanExtra(OutgoingCallBroadcaster.EXTRA_ALREADY_CALLED,false);
  7. if(alreadyCalled){
  8. if(DBG)Log.v(TAG,"CALLalreadyplaced--returning.");
  9. return;
  10. }
  11. number=getResultData();
  12. if(VDBG)Log.v(TAG,"-gotnumberfromresultData:'"+number+"'");
  14. finalPhoneGlobalsapp=PhoneGlobals.getInstance();
  15. //如果电话支持Otasp
  16. if(TelephonyCapabilities.supportsOtasp(app.phone)){
  17. booleanactivateState=(app.cdmaOtaScreenState.otaScreenState
  18. ==OtaUtils.CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION);
  19. booleandialogState=(app.cdmaOtaScreenState.otaScreenState
  20. ==OtaUtils.CdmaOtaScreenState.OtaScreenState
  21. .OTA_STATUS_SUCCESS_FAILURE_DLG);
  22. booleanisOtaCallActive=false;
  24. if((app.cdmaOtaScreenState.otaScreenState
  25. ==OtaUtils.CdmaOtaScreenState.OtaScreenState.OTA_STATUS_PROGRESS)
  26. ||(app.cdmaOtaScreenState.otaScreenState
  27. ==OtaUtils.CdmaOtaScreenState.OtaScreenState.OTA_STATUS_LISTENING)){
  28. isOtaCallActive=true;
  29. }
  31. if(activateState||dialogState){
  32. //TheOTASPsequenceisactive,buteither(1)thecall
  33. //hasn'tstartedyet,or(2)thecallhasendedandwe're
  34. //showingthesuccess/failurescreen.Ineitherofthese
  35. //casesit'sOKtomakeanewoutgoingcall,butweneed
  36. //totakedownanyOTASP-relatedUIfirst.
  37. if(dialogState)app.dismissOtaDialogs();
  38. app.clearOtaState();
  39. app.clearInCallScreenMode();
  40. }elseif(isOtaCallActive){
  41. //TheactualOTASPcallisactive.Don'tallownew
  42. //outgoingcallsatallfromthisstate.
  43. Log.w(TAG,"OTASPcallisactive:disallowinganewoutgoingcall.");
  44. return;
  45. }
  46. }
  47. if(number==null){
  48. if(DBG)Log.v(TAG,"CALLcancelled(nullnumber),returning...");
  49. return;
  50. }elseif(TelephonyCapabilities.supportsOtasp(app.phone)
  51. &&(app.phone.getState()!=PhoneConstants.State.IDLE)
  52. &&(app.phone.isOtaSpNumber(number))){
  53. if(DBG)Log.v(TAG,"Callisactive,a2ndOTAcallcancelled--returning.");
  54. return;
  55. }elseif(PhoneNumberUtils.isPotentialLocalEmergencyNumber(number,context)){
  56. Log.w(TAG,"Cannotmodifyoutgoingcalltoemergencynumber"+number+".");
  57. return;
  58. }
  59. originalUri=intent.getStringExtra(OutgoingCallBroadcaster.EXTRA_ORIGINAL_URI);
  60. if(originalUri==null){
  61. Log.e(TAG,"IntentismissingEXTRA_ORIGINAL_URI--returning.");
  62. return;
  63. }
  64. Uriuri=Uri.parse(originalUri);
  65. number=PhoneNumberUtils.convertKeypadLettersToDigits(number);
  66. number=PhoneNumberUtils.stripSeparators(number);
  68. if(DBG)Log.v(TAG,"doReceive:proceedingwithcall...");
  69. if(VDBG)Log.v(TAG,"-uri:"+uri);
  70. if(VDBG)Log.v(TAG,"-actualnumbertodial:'"+number+"'");
  71. startSipCallOptionHandler(context,intent,uri,number);
  72. }

OutgoingCallReceiver是OutgoingCallBroadcaster的一个内部类，作用是接收OutgoingCallBroadcaster发送的广播，判断是否已经启动InCallScreen。没有启动的话就进行一些初始化，如：对OTA进行初始化。接收到广播之后，从Intent里面取出电话号码及其URi。然后设置Intent为ACTION_CALL，并带上号码和uri。启动InCallScreen。关闭OutgoingCallReceiver。

OTA:Over-the-Air Technology 空中下载技术，是通过移动通信(GSM或CDMA)的空中接口对SIM卡数据及应用进行远程管理的技术。空中接口可以采用WAP、GPRS、CDMA1X及短消息技术。OTA技术的应用，使得移动通信不仅可以提供语音和数据服务，而且还能提供新业务下载。

[java] view plain copy
  1. privatevoidstartSipCallOptionHandler(Contextcontext,Intentintent,
  2. Uriuri,Stringnumber){
  3. if(VDBG){
  4. Log.i(TAG,"startSipCallOptionHandler...");
  5. Log.i(TAG,"-intent:"+intent);
  6. Log.i(TAG,"-uri:"+uri);
  7. Log.i(TAG,"-number:"+number);
  8. }
  9. //创建原始电话拨号intent的副本
  10. IntentnewIntent=newIntent(Intent.ACTION_CALL,uri);
  11. newIntent.putExtra(EXTRA_ACTUAL_NUMBER_TO_DIAL,number);
  12. PhoneUtils.checkAndCopyPhoneProviderExtras(intent,newIntent);
  14. IntentselectPhoneIntent=newIntent(ACTION_SIP_SELECT_PHONE,uri);
  15. selectPhoneIntent.setClass(context,SipCallOptionHandler.class);
  16. selectPhoneIntent.putExtra(EXTRA_NEW_CALL_INTENT,newIntent);
  17. selectPhoneIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  18. if(DBG){
  19. Log.v(TAG,"startSipCallOptionHandler():"+
  20. "callingstartActivity:"+selectPhoneIntent);
  21. }
  22. //启动电话类型选择界面
  23. context.startActivity(selectPhoneIntent);
  24. }
电话类型选择处理：1.读取用户设置；2.弹出对话框让用户选择
src\com\android\phone\SipCallOptionHandler.java [java] view plain copy
  1. publicvoidonCreate(BundlesavedInstanceState){
  2. super.onCreate(savedInstanceState);
  3. Intentintent=getIntent();
  4. Stringaction=intent.getAction();
  5. if(!OutgoingCallBroadcaster.ACTION_SIP_SELECT_PHONE.equals(action)){
  6. Log.wtf(TAG,"onCreate:gotintentaction'"+action+"',expected"
  7. +OutgoingCallBroadcaster.ACTION_SIP_SELECT_PHONE);
  8. finish();
  9. return;
  10. }
  11. //取出原始电话拨号intent的副本
  12. mIntent=(Intent)intent.getParcelableExtra(OutgoingCallBroadcaster.EXTRA_NEW_CALL_INTENT);
  13. if(mIntent==null){
  14. finish();
  15. return;
  16. }
  17. //Allowthisactivitytobevisibleinfrontofthekeyguard.
  18. getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
  19. //-Ifit'sasip:URI,thisisdefinitelyaSIPcall,regardless
  20. //ofwhetherthedataisaSIPaddressoraregularphone
  21. //number.
  22. //-Ifthisisatel:URIbutthedatacontainsan"@"character
  23. //(seePhoneNumberUtils.isUriNumber())weconsiderthattobea
  24. //SIPnumbertoo.
  25. booleanvoipSupported=PhoneUtils.isVoipSupported();
  26. if(DBG)Log.v(TAG,"voipSupported:"+voipSupported);
  27. mSipProfileDb=newSipProfileDb(this);
  28. mSipSharedPreferences=newSipSharedPreferences(this);
  29. mCallOption=mSipSharedPreferences.getSipCallOption();
  30. if(DBG)Log.v(TAG,"Calloption:"+mCallOption);
  31. Uriuri=mIntent.getData();
  32. Stringscheme=uri.getScheme();
  33. mNumber=PhoneNumberUtils.getNumberFromIntent(mIntent,this);
  34. booleanisInCellNetwork=PhoneGlobals.getInstance().phoneMgr.isRadioOn();
  35. booleanisKnownCallScheme=Constants.SCHEME_TEL.equals(scheme)
  36. ||Constants.SCHEME_SIP.equals(scheme);
  37. booleanisRegularCall=Constants.SCHEME_TEL.equals(scheme)
  38. &&!PhoneNumberUtils.isUriNumber(mNumber);
  39. //Bypassthehandlerifthecallschemeisnotsiportel.
  40. if(!isKnownCallScheme){
  41. setResultAndFinish();
  42. return;
  43. }
  44. //CheckifVoIPfeatureissupported.
  45. if(!voipSupported){
  46. if(!isRegularCall){
  47. showDialog(DIALOG_NO_VOIP);
  48. }else{
  49. setResultAndFinish();
  50. }
  51. return;
  52. }
  53. if(!PhoneUtils.hasPhoneProviderExtras(mIntent)){
  54. if(!isNetworkConnected()){
  55. if(!isRegularCall){
  56. //显示无网络错误提示对话框
  57. showDialog(DIALOG_NO_INTERNET_ERROR);
  58. return;
  59. }
  60. }else{
  61. if(mCallOption.equals(Settings.System.SIP_ASK_ME_EACH_TIME)
  62. &&isRegularCall&&isInCellNetwork){
  63. //显示电话类型选择对话框
  64. showDialog(DIALOG_SELECT_PHONE_TYPE);
  65. return;
  66. }
  67. if(!mCallOption.equals(Settings.System.SIP_ADDRESS_ONLY)
  68. ||!isRegularCall){
  69. mUseSipPhone=true;
  70. }
  71. }
  72. }
  73. if(mUseSipPhone){
  74. //Ifthereisnosipprofileanditisaregularcall,thenwe
  75. //shouldusepstnnetworkinstead.
  76. if((mSipProfileDb.getProfilesCount()>0)||!isRegularCall){
  77. startGetPrimarySipPhoneThread();
  78. return;
  79. }else{
  80. mUseSipPhone=false;
  81. }
  82. }
  83. setResultAndFinish();
选择SIP拨号还是PSTN拨号 [java] view plain copy
  1. privatevoidsetResultAndFinish(){
  2. runOnUiThread(newRunnable(){
  3. publicvoidrun(){
  4. if(mOutgoingSipProfile!=null){
  5. if(!isNetworkConnected()){
  6. showDialog(DIALOG_NO_INTERNET_ERROR);
  7. return;
  8. }
  9. if(DBG)Log.v(TAG,"primarySIPURIis"+
  10. mOutgoingSipProfile.getUriString());
  11. createSipPhoneIfNeeded(mOutgoingSipProfile);
  12. mIntent.putExtra(OutgoingCallBroadcaster.EXTRA_SIP_PHONE_URI,
  13. mOutgoingSipProfile.getUriString());
  14. if(mMakePrimary){
  15. mSipSharedPreferences.setPrimaryAccount(
  16. mOutgoingSipProfile.getUriString());
  17. }
  18. }
  19. //mUseSipPhone在SipCallOptionHandler的onCreate函数中被设置为false
  20. if(mUseSipPhone&&mOutgoingSipProfile==null){
  21. showDialog(DIALOG_START_SIP_SETTINGS);
  22. return;
  23. }else{
  24. //Woohoo--it'sfinallyOKtoinitiatetheoutgoingcall!
  25. PhoneGlobals.getInstance().callController.placeCall(mIntent);
  26. }
  27. finish();
  28. }
  29. });
  30. }
src\com\android\phone\CallController.java
[java] view plain copy
  1. publicvoidplaceCall(Intentintent){
  2. log("placeCall()...intent="+intent);
  3. if(VDBG)log("extras="+intent.getExtras());
  4. finalInCallUiStateinCallUiState=mApp.inCallUiState;
  6. if(intent==null){
  7. Log.wtf(TAG,"placeCall:calledwithnullintent");
  8. thrownewIllegalArgumentException("placeCall:calledwithnullintent");
  9. }
  11. Stringaction=intent.getAction();
  12. Uriuri=intent.getData();
  13. if(uri==null){
  14. Log.wtf(TAG,"placeCall:intenthadnodata");
  15. thrownewIllegalArgumentException("placeCall:intenthadnodata");
  16. }
  18. Stringscheme=uri.getScheme();
  19. Stringnumber=PhoneNumberUtils.getNumberFromIntent(intent,mApp);
  20. if(VDBG){
  21. log("-action:"+action);
  22. log("-uri:"+uri);
  23. log("-scheme:"+scheme);
  24. log("-number:"+number);
  25. }
  27. if(!(Intent.ACTION_CALL.equals(action)
  28. ||Intent.ACTION_CALL_EMERGENCY.equals(action)
  29. ||Intent.ACTION_CALL_PRIVILEGED.equals(action))){
  30. Log.wtf(TAG,"placeCall:unexpectedintentaction"+action);
  31. thrownewIllegalArgumentException("Unexpectedaction:"+action);
  32. }
  33. //ChecktoseeifthisisanOTASPcall(the"activation"call
  34. //usedtoprovisionCDMAdevices),andifso,dosome
  35. //OTASP-specificsetup.
  36. Phonephone=mApp.mCM.getDefaultPhone();
  37. if(TelephonyCapabilities.supportsOtasp(phone)){
  38. checkForOtaspCall(intent);
  39. }
  40. mApp.setRestoreMuteOnInCallResume(false);
  41. //Ifaproviderisused,extracttheinfotobuildthe
  42. //overlayandroutethecall.Theoverlaywillbe
  43. //displayedwhentheInCallScreenbecomesvisible.
  44. if(PhoneUtils.hasPhoneProviderExtras(intent)){
  45. inCallUiState.setProviderInfo(intent);
  46. }else{
  47. inCallUiState.clearProviderInfo();
  48. }
  49. //拨号
  50. CallStatusCodestatus=placeCallInternal(intent);
  52. switch(status){
  53. caseSUCCESS:
  54. caseEXITED_ECM:
  55. if(DBG)log("==>placeCall():successfromplaceCallInternal():"+status);
  56. if(status==CallStatusCode.EXITED_ECM){
  57. //Callsucceeded,butwealsoneedtotellthe
  58. //InCallScreentoshowthe"ExitingECM"warning.
  59. inCallUiState.setPendingCallStatusCode(CallStatusCode.EXITED_ECM);
  60. }else{
  61. //Callsucceeded.There'sno"errorcondition"that
  62. //needstobedisplayedtotheuser,soclearoutthe
  63. //InCallUiState's"pendingcallstatuscode".
  64. inCallUiState.clearPendingCallStatusCode();
  65. }
  67. //Notifythephoneappthatacallisbeginningsoitcan
  68. //enabletheproximitysensor
  69. mApp.setBeginningCall(true);
  70. break;
  72. default:
  73. //Anyotherstatuscodeisafailure.
  74. log("==>placeCall():failurecodefromplaceCallInternal():"+status);
  75. //Handlethevariouserrorconditionsthatcanoccurwhen
  76. //initiatinganoutgoingcall,typicallybydirectingthe
  77. //InCallScreentodisplayadiagnosticmessage(viathe
  78. //"pendingcallstatuscode"flag.)
  79. handleOutgoingCallError(status);
  80. break;
  81. }
  82. mApp.displayCallScreen();
  83. }
该函数首先得到拨打的电话号码及默认的Phone对象，调用placeCallInternal发起拨号请求，同时启动电话呼叫界面InCallScreen。

1.拨号流程

[java] view plain copy
  1. privateCallStatusCodeplaceCallInternal(Intentintent){
  2. finalInCallUiStateinCallUiState=mApp.inCallUiState;
  3. finalUriuri=intent.getData();
  4. finalStringscheme=(uri!=null)?uri.getScheme():null;
  5. Stringnumber;
  6. Phonephone=null;
  8. CallStatusCodeokToCallStatus=checkIfOkToInitiateOutgoingCall(
  9. mCM.getServiceState());
  10. try{
  11. number=PhoneUtils.getInitialNumber(intent);
  12. if(VDBG)log("-actualnumbertodial:'"+number+"'");
  13. StringsipPhoneUri=intent.getStringExtra(OutgoingCallBroadcaster.EXTRA_SIP_PHONE_URI);
  14. phone=PhoneUtils.pickPhoneBasedOnNumber(mCM,scheme,number,sipPhoneUri);
  15. if(VDBG)log("-gotPhoneinstance:"+phone+",class="+phone.getClass());
  16. okToCallStatus=checkIfOkToInitiateOutgoingCall(phone.getServiceState().getState());
  17. }catch(PhoneUtils.VoiceMailNumberMissingExceptionex){
  18. if(okToCallStatus!=CallStatusCode.SUCCESS){
  19. if(DBG)log("VoicemailnumbernotreachableincurrentSIMcardstate.");
  20. returnokToCallStatus;
  21. }
  22. if(DBG)log("VoiceMailNumberMissingExceptionfromgetInitialNumber()");
  23. returnCallStatusCode.VOICEMAIL_NUMBER_MISSING;
  24. }
  26. if(number==null){
  27. Log.w(TAG,"placeCall:couldn'tgetaphonenumberfromIntent"+intent);
  28. returnCallStatusCode.NO_PHONE_NUMBER_SUPPLIED;
  29. }
  30. booleanisEmergencyNumber=PhoneNumberUtils.isLocalEmergencyNumber(number,mApp);
  31. booleanisPotentialEmergencyNumber=PhoneNumberUtils.isPotentialLocalEmergencyNumber(number,mApp);
  32. booleanisEmergencyIntent=Intent.ACTION_CALL_EMERGENCY.equals(intent.getAction());
  34. if(isPotentialEmergencyNumber&&!isEmergencyIntent){
  35. Log.e(TAG,"Non-CALL_EMERGENCYIntent"+intent+"attemptedtocallpotentialemergencynumber"+number+".");
  36. returnCallStatusCode.CALL_FAILED;
  37. }elseif(!isPotentialEmergencyNumber&&isEmergencyIntent){
  38. Log.e(TAG,"ReceivedCALL_EMERGENCYIntent"+intent
  39. +"withnon-potential-emergencynumber"+number
  40. +"--failingcall.");
  41. returnCallStatusCode.CALL_FAILED;
  42. }
  43. //Ifwe'retryingtocallanemergencynumber,thenit'sOKto
  44. //proceedincertainstateswherewe'dotherwisebringup
  45. //anerrordialog:
  46. //-Ifwe'reinEMERGENCY_ONLYmode,then(obviously)you'reallowed
  47. //todialemergencynumbers.
  48. //-Ifwe'reOUT_OF_SERVICE,westillattempttomakeacall,
  49. //sincetheradiowillregistertoanyavailablenetwork.
  50. if(isEmergencyNumber
  51. &&((okToCallStatus==CallStatusCode.EMERGENCY_ONLY)
  52. ||(okToCallStatus==CallStatusCode.OUT_OF_SERVICE))){
  53. if(DBG)log("placeCall:Emergencynumberdetectedwithstatus="+okToCallStatus);
  54. okToCallStatus=CallStatusCode.SUCCESS;
  55. if(DBG)log("==>UPDATINGstatusto:"+okToCallStatus);
  56. }
  58. if(okToCallStatus!=CallStatusCode.SUCCESS){
  59. //Ifthisisanemergencycall,launchtheEmergencyCallHelperService
  60. //toturnontheradioandretrythecall.
  61. if(isEmergencyNumber&&(okToCallStatus==CallStatusCode.POWER_OFF)){
  62. Log.i(TAG,"placeCall:TryingtomakeemergencycallwhilePOWER_OFF!");
  63. //Ifneeded,lazilyinstantiateanEmergencyCallHelperinstance.
  64. synchronized(this){
  65. if(mEmergencyCallHelper==null){
  66. mEmergencyCallHelper=newEmergencyCallHelper(this);
  67. }
  68. }
  69. //...andkickoffthe"emergencycallfromairplanemode"sequence.
  70. mEmergencyCallHelper.startEmergencyCallFromAirplaneModeSequence(number);
  71. returnCallStatusCode.SUCCESS;
  72. }else{
  73. if(DBG)log("==>placeCallInternal():non-successstatus:"+okToCallStatus);
  74. returnokToCallStatus;
  75. }
  76. }
  77. //Ok,wecanproceedwiththisoutgoingcall.
  78. inCallUiState.needToShowCallLostDialog=false;
  79. inCallUiState.clearProgressIndication();
  80. UricontactUri=intent.getData();
  81. //真正的电话拨号过程
  82. intcallStatus=PhoneUtils.placeCall(mApp,
  83. phone,
  84. number,
  85. contactUri,
  86. (isEmergencyNumber||isEmergencyIntent),
  87. inCallUiState.providerGatewayUri);
  89. switch(callStatus){
  90. casePhoneUtils.CALL_STATUS_DIALED:
  91. if(VDBG)log("placeCall:PhoneUtils.placeCall()succeededforregularcall'"
  92. +number+"'.");
  93. if(VDBG)log("-inCallUiState.inCallScreenMode="
  94. +inCallUiState.inCallScreenMode);
  95. if(inCallUiState.inCallScreenMode==InCallScreenMode.OTA_NORMAL){
  96. if(VDBG)log("==>OTA_NORMALnote:switchingtoOTA_STATUS_LISTENING.");
  97. mApp.cdmaOtaScreenState.otaScreenState=
  98. CdmaOtaScreenState.OtaScreenState.OTA_STATUS_LISTENING;
  99. }
  101. booleanvoicemailUriSpecified=scheme!=null&&scheme.equals("voicemail");
  102. //Whenvoicemailisrequestedmostlikelytheuserwantstoopen
  103. //dialpadimmediately,soweshowitinthefirstplace.
  104. //Otherwisewewanttomakesuretheusercanseetheregular
  105. //in-callUIwhilethenewcallisdialing,andwhenit
  106. //firstgetsconnected.)
  107. inCallUiState.showDialpad=voicemailUriSpecified;
  109. //Forvoicemails,weaddcontexttexttolettheuserknowthey
  110. //aredialingtheirvoicemail.
  111. //TODO:Thisisonlysethereandbecomesproblematicwhenswappingcalls
  112. inCallUiState.dialpadContextText=voicemailUriSpecified?
  113. phone.getVoiceMailAlphaTag():"";
  115. //Also,incaseapreviouscallwasalreadyactive(i.e.if
  116. //wejustdid"Addcall"),clearoutthe"history"ofDTMF
  117. //digitsyoutyped,tomakesureitdoesn'tpersistfromthe
  118. //previouscalltothenewcall.
  119. //TODO:itwouldbemoreprecisetodothiswhentheactual
  120. //phonestatechangehappens(i.e.whenanewforeground
  121. //callappearsandthepreviouscallmovestothe
  122. //background),buttheInCallScreendoesn'tkeepenough
  123. //staterightnowtonoticethatspecifictransitionin
  124. //onPhoneStateChanged().
  125. inCallUiState.dialpadDigits=null;
  127. //CheckforanobscureECM-relatedscenario:Ifthephone
  128. //iscurrentlyinECM(Emergencycallbackmode)andwe
  129. //dialanon-emergencynumber,thatautomatically
  130. //*cancels*ECM.Sowarntheuseraboutit.
  131. //(SeeInCallScreen.showExitingECMDialog()formoreinfo.)
  132. booleanexitedEcm=false;
  133. if(PhoneUtils.isPhoneInEcm(phone)&&!isEmergencyNumber){
  134. Log.i(TAG,"AbouttoexitECMbecauseofanoutgoingnon-emergencycall");
  135. exitedEcm=true;//thiswillcauseustoreturnEXITED_ECMfromthismethod
  136. }
  138. if(phone.getPhoneType()==PhoneConstants.PHONE_TYPE_CDMA){
  139. //Startthetimerfor3WayCallerInfo
  140. if(mApp.cdmaPhoneCallState.getCurrentCallState()
  141. ==CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE){
  142. //UnmuteforthesecondMOcall
  143. PhoneUtils.setMute(false);
  145. //Thisisa"CDMA3-waycall",whichmeansthatyou'redialinga
  146. //2ndoutgoingcallwhileapreviouscallisalreadyinprogress.
  147. //
  148. //DuetothelimitationsofCDMAthiscalldoesn'tactuallygo
  149. //throughtheDIALING/ALERTINGstates,sowecan'ttellforsure
  150. //when(orif)it'sactuallyanswered.Butwewanttoshow
  151. //*some*indicationofwhat'sgoingonintheUI,sowe"fakeit"
  152. //bydisplayingthe"Dialing"statefor3seconds.
  154. //SetthemThreeWayCallOrigStateDialingstatetotrue
  155. mApp.cdmaPhoneCallState.setThreeWayCallOrigState(true);
  157. //Schedulethe"Dialing"indicationtobetakendownin3seconds:
  158. sendEmptyMessageDelayed(THREEWAY_CALLERINFO_DISPLAY_DONE,
  159. THREEWAY_CALLERINFO_DISPLAY_TIME);
  160. }
  161. }
  163. //Success!
  164. if(exitedEcm){
  165. returnCallStatusCode.EXITED_ECM;
  166. }else{
  167. returnCallStatusCode.SUCCESS;
  168. }
  170. casePhoneUtils.CALL_STATUS_DIALED_MMI:
  171. if(DBG)log("placeCall:specifiednumberwasanMMIcode:'"+number+"'.");
  172. //Thepassed-innumberwasanMMIcode,notaregularphonenumber!
  173. //Thisisn'treallyafailure;theDialermayhavedeliberately
  174. //firedanACTION_CALLintenttodialanMMIcode,likefora
  175. //USSDcall.
  176. //
  177. //PresumablyanMMI_INITIATEmessagewillcomeinshortly
  178. //(andwe'llbringupthe"MMIStarted"dialog),orelse
  179. //anMMI_COMPLETEwillcomein(whichwilltakeustoa
  180. //differentActivity;seePhoneUtils.displayMMIComplete()).
  181. returnCallStatusCode.DIALED_MMI;
  183. casePhoneUtils.CALL_STATUS_FAILED:
  184. Log.w(TAG,"placeCall:PhoneUtils.placeCall()FAILEDfornumber'"
  185. +number+"'.");
  186. //Wecouldn'tsuccessfullyplacethecall;therewassome
  187. //failureinthetelephonylayer.
  188. returnCallStatusCode.CALL_FAILED;
  190. default:
  191. Log.wtf(TAG,"placeCall:unknowncallStatus"+callStatus
  192. +"fromPhoneUtils.placeCall()fornumber'"+number+"'.");
  193. returnCallStatusCode.SUCCESS;//Trytocontinueanyway...
  194. }
  195. }
该函数通过调用PhoneUtils类的placeCall函数进入Framework层异步完成电话呼叫

src\com\android\phone\PhoneUtils.java

[java] view plain copy
  1. publicstaticintplaceCall(Contextcontext,Phonephone,
  2. Stringnumber,UricontactRef,booleanisEmergencyCall,
  3. UrigatewayUri){
  4. finalPhoneGlobalsapp=PhoneGlobals.getInstance();
  5. booleanuseGateway=false;
  6. if(null!=gatewayUri&&
  7. !isEmergencyCall&&
  8. PhoneUtils.isRoutableViaGateway(number)){//FilteroutMMI,OTAandothercodes.
  9. useGateway=true;
  10. }
  12. intstatus=CALL_STATUS_DIALED;
  13. Connectionconnection;
  14. StringnumberToDial;
  15. if(useGateway){
  16. if(null==gatewayUri||!Constants.SCHEME_TEL.equals(gatewayUri.getScheme())){
  17. Log.e(LOG_TAG,"UnsupportedURL:"+gatewayUri);
  18. returnCALL_STATUS_FAILED;
  19. }
  20. //WecanusegetSchemeSpecificPartbecausewedon'tallow#
  21. //inthegatewaynumbers(treatedafragmentdelim.)However
  22. //ifweallowmorecomplexgatewaynumberssequence(with
  23. //passwordsorwhatnot)thatuse#,thismaybreak.
  24. //TODO:NeedtosupportMMIcodes.
  25. numberToDial=gatewayUri.getSchemeSpecificPart();
  26. }else{
  27. numberToDial=number;
  28. }
  30. //RememberifthephonestatewasinIDLEstatebeforethiscall.
  31. //AftercallingCallManager#dial(),getState()willreturndifferentstate.
  32. finalbooleaninitiallyIdle=app.mCM.getState()==PhoneConstants.State.IDLE;
  34. try{
  35. connection=app.mCM.dial(phone,numberToDial);
  36. }catch(CallStateExceptionex){
  37. //CallStateExceptionmeansanewoutgoingcallisnotcurrently
  38. //possible:eithernomorecallslotsexist,orthere'sanother
  39. //callalreadyintheprocessofdialingorringing.
  40. Log.w(LOG_TAG,"Exceptionfromapp.mCM.dial()",ex);
  41. returnCALL_STATUS_FAILED;
  43. //Notethatit'spossibleforCallManager.dial()toreturn
  44. //null*without*throwinganexception;thatindicatesthat
  45. //wedialedanMMI(seebelow).
  46. }
  48. intphoneType=phone.getPhoneType();
  50. //OnGSMphones,nullisreturnedforMMIcodes
  51. if(null==connection){
  52. if(phoneType==PhoneConstants.PHONE_TYPE_GSM&&gatewayUri==null){
  53. if(DBG)log("dialedMMIcode:"+number);
  54. status=CALL_STATUS_DIALED_MMI;
  55. }else{
  56. status=CALL_STATUS_FAILED;
  57. }
  58. }else{
  59. if(phoneType==PhoneConstants.PHONE_TYPE_CDMA){
  60. updateCdmaCallStateOnNewOutgoingCall(app);
  61. }
  63. //Cleanupthenumbertobedisplayed.
  64. if(phoneType==PhoneConstants.PHONE_TYPE_CDMA){
  65. number=CdmaConnection.formatDialString(number);
  66. }
  67. number=PhoneNumberUtils.extractNetworkPortion(number);
  68. number=PhoneNumberUtils.convertKeypadLettersToDigits(number);
  69. number=PhoneNumberUtils.formatNumber(number);
  71. if(gatewayUri==null){
  72. //phone.dial()succeeded:we'renowinanormalphonecall.
  73. //attachtheURItotheCallerInfoObjectifitisthere,
  74. //otherwisejustattachtheUriReference.
  75. //iftheuridoesnothavea"content"scheme,thenwetreat
  76. //itasifitdoesNOThaveauniquereference.
  77. Stringcontent=context.getContentResolver().SCHEME_CONTENT;
  78. if((contactRef!=null)&&(contactRef.getScheme().equals(content))){
  79. ObjectuserDataObject=connection.getUserData();
  80. if(userDataObject==null){
  81. connection.setUserData(contactRef);
  82. }else{
  83. //TODO:Thisbranchisdeadcode,wehave
  84. //justcreatedtheconnectionwhichhas
  85. //nouserdata(null)bydefault.
  86. if(userDataObjectinstanceofCallerInfo){
  87. ((CallerInfo)userDataObject).contactRefUri=contactRef;
  88. }else{
  89. ((CallerInfoToken)userDataObject).currentInfo.contactRefUri=
  90. contactRef;
  91. }
  92. }
  93. }
  94. }else{
  95. //Getthecallerinfosynchronouslybecauseweneedthefinal
  96. //CallerInfoobjecttoupdatethedialednumberwiththeone
  97. //requestedbytheuser(andnottheprovider'sgatewaynumber).
  98. CallerInfoinfo=null;
  99. Stringcontent=phone.getContext().getContentResolver().SCHEME_CONTENT;
  100. if((contactRef!=null)&&(contactRef.getScheme().equals(content))){
  101. info=CallerInfo.getCallerInfo(context,contactRef);
  102. }
  104. //Fallback,lookupcontactusingthephonenumberifthe
  105. //contact'sURIschemewasnotcontent://orifiswasbut
  106. //thelookupfailed.
  107. if(null==info){
  108. info=CallerInfo.getCallerInfo(context,number);
  109. }
  110. info.phoneNumber=number;
  111. connection.setUserData(info);
  112. }
  113. setAudioMode();
  115. if(DBG)log("abouttoactivatespeaker");
  116. //Checkisphoneinanydock,andturnonspeakeraccordingly
  117. finalbooleanspeakerActivated=activateSpeakerIfDocked(phone);
  119. //SeealsosimilarlogicinanswerCall().
  120. if(initiallyIdle&&!speakerActivated&&isSpeakerOn(app)
  121. &&!app.isBluetoothHeadsetAudioOn()){
  122. //Thisisnotanerrorbutmightcauseusers'confusion.Addlogjustincase.
  123. Log.i(LOG_TAG,"Forcingspeakeroffwheninitiatinganewoutgoingcall...");
  124. PhoneUtils.turnOnSpeaker(app,false,true);
  125. }
  126. }
  127. returnstatus;
  128. }
该函数调用framework层的CallManager的dial函数。 [java] view plain copy
  1. publicConnectiondial(Phonephone,StringdialString)throwsCallStateException{
  2. PhonebasePhone=getPhoneBase(phone);
  3. Connectionresult;
  4. if(VDBG){
  5. Log.d(LOG_TAG,"dial("+basePhone+","+dialString+")");
  6. Log.d(LOG_TAG,this.toString());
  7. }
  8. if(!canDial(phone)){
  9. thrownewCallStateException("cannotdialincurrentstate");
  10. }
  11. if(hasActiveFgCall()){
  12. PhoneactivePhone=getActiveFgCall().getPhone();
  13. booleanhasBgCall=!(activePhone.getBackgroundCall().isIdle());
  14. if(DBG){
  15. Log.d(LOG_TAG,"hasBgCall:"+hasBgCall+"sameChannel:"+(activePhone==basePhone));
  16. }
  17. if(activePhone!=basePhone){
  18. if(hasBgCall){
  19. Log.d(LOG_TAG,"Hangup");
  20. getActiveFgCall().hangup();
  21. }else{
  22. Log.d(LOG_TAG,"Switch");
  23. activePhone.switchHoldingAndActive();
  24. }
  25. }
  26. }
  27. result=basePhone.dial(dialString);
  28. if(VDBG){
  29. Log.d(LOG_TAG,"Enddial("+basePhone+","+dialString+")");
  30. Log.d(LOG_TAG,this.toString());
  31. }
  32. returnresult;
  33. }
函数首先取得相应类型的Phone，并判断该Phone的状态，这里得到PhoneProxy类型的Phone，PhoneProxy是所有类型Phone的代理类，在构造PhoneProxy时，把对应类型的Phone保存在其成员变量mActivePhone中，有关Phone，PhoneProxy，GmsPhone，CDMAPhone之间的关系请参看 Android电话Phone设计框架介绍，GSM类型的网络对应GSMPhone，因此这里将调用GSMPhone类的dial函数。

./telephony/java/com/android/internal/telephony/gsm/GSMPhone.java

[java] view plain copy
  1. publicConnectiondial(StringdialString)throwsCallStateException{
  2. returndial(dialString,null);
  3. }

[java] view plain copy
  1. publicConnectiondial(StringdialString,UUSInfouusInfo)throwsCallStateException{
  2. //NeedtomakesuredialStringgetsparsedproperly
  3. StringnewDialString=PhoneNumberUtils.stripSeparators(dialString);
  4. //handlein-callMMIfirstifapplicable
  5. if(handleInCallMmiCommands(newDialString)){
  6. returnnull;
  7. }
  8. //OnlylookattheNetworkportionformmi
  9. StringnetworkPortion=PhoneNumberUtils.extractNetworkPortionAlt(newDialString);
  10. GsmMmiCodemmi=GsmMmiCode.newFromDialString(networkPortion,this);
  11. if(mmi==null){
  12. returnmCT.dial(newDialString,uusInfo);
  13. }elseif(mmi.isTemporaryModeCLIR()){
  14. returnmCT.dial(mmi.dialingNumber,mmi.getCLIRMode(),uusInfo);
  15. }else{
  16. mPendingMMIs.add(mmi);
  17. mMmiRegistrants.notifyRegistrants(newAsyncResult(null,mmi,null));
  18. mmi.processCode();
  19. //FIXMEshouldthisreturnnullorsomethingelse?
  20. returnnull;
  21. }
  22. }
GSMPhone又通过CallTracker来向RIL发送请求，关于CallTracker的类关系请参阅 Android电话Phone设计框架介绍

./telephony/java/com/android/internal/telephony/gsm/GsmCallTracker.java

[java] view plain copy
  1. synchronizedConnectiondial(StringdialString,intclirMode,UUSInfouusInfo)throwsCallStateException{
  2. //notethatthistriggerscallstatechangednotif
  3. clearDisconnected();
  5. if(!canDial()){
  6. thrownewCallStateException("cannotdialincurrentstate");
  7. }
  9. //Thenewcallmustbeassignedtotheforegroundcall.
  10. //Thatcallmustbeidle,soplaceanythingthat's
  11. //thereonhold
  12. if(foregroundCall.getState()==GsmCall.State.ACTIVE){
  13. //thiswillprobablybedonebytheradioanyway
  14. //butthedialmightfailbeforethishappens
  15. //andweneedtomakesuretheforegroundcallisclear
  16. //forthenewlydialedconnection
  17. switchWaitingOrHoldingAndActive();
  19. //Fakelocalstatesothat
  20. //a)foregroundCallisemptyforthenewlydialedconnection
  21. //b)hasNonHangupStateChangedremainsfalseinthe
  22. //nextpoll,sothatwedon'tclearafaileddialingcall
  23. fakeHoldForegroundBeforeDial();
  24. }
  26. if(foregroundCall.getState()!=GsmCall.State.IDLE){
  27. //weshouldhavefailedin!canDial()abovebeforewegethere
  28. thrownewCallStateException("cannotdialincurrentstate");
  29. }
  31. //pendingMO=newGsmConnection(phone.getContext(),checkForTestEmergencyNumber(dialString),
  32. //this,foregroundCall);
  33. booleanisStkCall=getStkCall();
  34. log("GsmCallTrackerdial:isStkCall="+isStkCall);
  35. pendingMO=newGsmConnection(phone.getContext(),dialString,this,foregroundCall,isStkCall,false);
  36. hangupPendingMO=false;
  38. if(pendingMO.address==null||pendingMO.address.length()==0
  39. ||pendingMO.address.indexOf(PhoneNumberUtils.WILD)>=0
  40. ){
  41. //Phonenumberisinvalid
  42. pendingMO.cause=Connection.DisconnectCause.INVALID_NUMBER;
  44. //handlePollCalls()willnoticethiscallnotpresent
  45. //andwillmarkitasdropped.
  46. pollCallsWhenSafe();
  47. }else{
  48. //Alwaysunmutewheninitiatinganewcall
  49. setMute(false);
  51. //cm.dial(pendingMO.address,clirMode,uusInfo,obtainCompleteMessage());
  52. //Addforbug121825Start
  53. StringtmpAddr=pendingMO.address;
  54. if(PhoneNumberUtils.isCustomEmergencyNumber(pendingMO.address)){
  55. Log.d(LOG_TAG,"PendingMOisCustomEmergencycall");
  56. tmpAddr=tmpAddr+"/1";
  57. }
  58. //cm.dial(pendingMO.address,clirMode,uusInfo,isStkCall,obtainCompleteMessage());
  59. cm.dial(tmpAddr,clirMode,uusInfo,isStkCall,obtainCompleteMessage());
  60. //Addforbug121825End
  61. }
  63. updatePhoneState();
  64. phone.notifyPreciseCallStateChanged();
  66. returnpendingMO;
  67. }
cm的类型为CommandsInterface，RIL.java实现了CommandsInterface接口，因此GsmCallTracker最终是通过RIL来发送拨号请求的。

./telephony/java/com/android/internal/telephony/RIL.java

[java] view plain copy
  1. publicvoiddial(Stringaddress,intclirMode,UUSInfouusInfo,booleanisStkCall,Messageresult){
  2. RILRequestrr;
  4. if(address.indexOf('/')==-1){
  5. rr=RILRequest.obtain(RIL_REQUEST_DIAL,result);
  6. }else{
  7. rr=RILRequest.obtain(RIL_REQUEST_DIAL_EMERGENCY_CALL,result);
  8. }
  9. rr.mp.writeString(address);
  10. rr.mp.writeInt(clirMode);
  11. rr.mp.writeInt(0);//UUSinformationisabsent
  12. if(uusInfo==null){
  13. rr.mp.writeInt(0);//UUSinformationisabsent
  14. }else{
  15. rr.mp.writeInt(1);//UUSinformationispresent
  16. rr.mp.writeInt(uusInfo.getType());
  17. rr.mp.writeInt(uusInfo.getDcs());
  18. rr.mp.writeByteArray(uusInfo.getUserData());
  19. }
  20. rr.mp.writeInt(isStkCall?1:0);
  22. if(RILJ_LOGD)riljLog(rr.serialString()+">"+requestToString(rr.mRequest));
  24. send(rr);
  25. }

Java部分的request请求号需要与C/C++部分的请求号保持一致。当需要执行某种AT命令request请求时，则需创建一个新的RILRequest，使用RILRequest的obtain函数,该obtain静态函数用于从其内部维护的一个 RIL request池sPool中取下一个request，得到一个RILRequest对象，它里面的请求号和用于回送结果及处理者handler的消息来自传递的实参。当一个RILRequest对象不再使用时，调用release() 函数将其释放回池中。将RILRequest请求放置到消息队列上，然后sender线程将其写入socket，rild侧通过dispatch线程将请求分发出去。在RIL类中，还维护了一个RILRequest请求列表，RILRequest类中的serial作为其id标识。当sender发送一个RIL请求后，则将其添加到该列表中,若发送时出现异常则需再清除；当请求完成并得到回送的response消息后，使用findAndRemoveRequestFromList函数将其移除。RIL请求执行AT是一个异步的过程：调用者调用RIL类的API函数只是往线程的消息队列上添加了一消息就返回；然后线程在执行无限循环时将其写到socket中，并将RILRequest对象添加到一个列表中；当RILReciever线程收到数据并解析，然后查询系列号后得到这是某个先前的RIL请求后，将AT执行的返回结果放到AsynResult中并赋值给Message中的obj成员后，由Message.sendToTarget送回到调用者并由其处理。

[java] view plain copy
  1. protectedvoidsend(RILRequestrr){
  2. Messagemsg;
  3. if(mSocket==null){
  4. rr.onError(RADIO_NOT_AVAILABLE,null);
  5. rr.release();
  6. return;
  7. }
  8. msg=mSender.obtainMessage(EVENT_SEND,rr);
  9. acquireWakeLock();
  10. msg.sendToTarget();
  11. }
RILSender消息处理过程 [java] view plain copy
  1. classRILSenderextendsHandlerimplementsRunnable{
  2. publicRILSender(Looperlooper){
  3. super(looper);
  4. }
  5. byte[]dataLength=newbyte[4];
  6. publicvoid
  7. run(){
  8. //setupifneeded
  9. }
  11. @Overridepublicvoid
  12. handleMessage(Messagemsg){
  13. RILRequestrr=(RILRequest)(msg.obj);
  14. RILRequestreq=null;
  15. switch(msg.what){
  16. caseEVENT_SEND:
  17. /**
  18. *mRequestMessagePending++alreadyhappenedforevery
  19. *EVENT_SEND,thuswemustmakesure
  20. *mRequestMessagePending--happensonceandonlyonce
  21. */
  22. booleanalreadySubtracted=false;
  23. try{
  24. LocalSockets;
  25. s=mSocket;
  26. if(s==null){
  27. rr.onError(RADIO_NOT_AVAILABLE,null);
  28. rr.release();
  29. if(mRequestMessagesPending>0)
  30. mRequestMessagesPending--;
  31. alreadySubtracted=true;
  32. return;
  33. }
  34. synchronized(mRequestsList){
  35. mRequestsList.add(rr);
  36. mRequestMessagesWaiting++;
  37. }
  38. if(mRequestMessagesPending>0)
  39. mRequestMessagesPending--;
  40. alreadySubtracted=true;
  41. byte[]data;
  42. data=rr.mp.marshall();
  43. rr.mp.recycle();
  44. rr.mp=null;
  45. if(data.length>RIL_MAX_COMMAND_BYTES){
  46. thrownewRuntimeException("Parcellargerthanmaxbytesallowed!"+data.length);
  47. }
  48. //parcellengthinbigendian
  49. dataLength[0]=dataLength[1]=0;
  50. dataLength[2]=(byte)((data.length>>8)&0xff);
  51. dataLength[3]=(byte)((data.length)&0xff);
  52. //Log.v(LOG_TAG,"writingpacket:"+data.length+"bytes");
  53. s.getOutputStream().write(dataLength);
  54. s.getOutputStream().write(data);
  55. }catch(IOExceptionex){
  56. Log.e(LOG_TAG,"IOException",ex);
  57. req=findAndRemoveRequestFromList(rr.mSerial);
  58. //makesurethisrequesthasnotalreadybeenhandled,
  59. //eg,ifRILReceiverclearedthelist.
  60. if(req!=null||!alreadySubtracted){
  61. rr.onError(RADIO_NOT_AVAILABLE,null);
  62. rr.release();
  63. }
  64. }catch(RuntimeExceptionexc){
  65. Log.e(LOG_TAG,"Uncaughtexception",exc);
  66. req=findAndRemoveRequestFromList(rr.mSerial);
  67. //makesurethisrequesthasnotalreadybeenhandled,
  68. //eg,ifRILReceiverclearedthelist.
  69. if(req!=null||!alreadySubtracted){
  70. rr.onError(GENERIC_FAILURE,null);
  71. rr.release();
  72. }
  73. }finally{
  74. //Note:Weare"Done"onlyiftherearenooutstanding
  75. //requestsorreplies.Thusthiscodepathwillonlyrelease
  76. //thewakelockonerrors.
  77. releaseWakeLockIfDone();
  78. }
  79. if(!alreadySubtracted&&mRequestMessagesPending>0){
  80. mRequestMessagesPending--;
  81. }
  82. break;
  83. }
  84. }
  85. }
在处理EVENT_SEND消息时，将请求参数写入到rild套接字中，在 Android电话Phone设计框架介绍中介绍了rild服务进程作为Android电话系统的服务端，接收客户端framework层发送过来的请求，并与modem交互，实现整个拨号过程。关于rild服务在 Android之rild进程启动源码分析已经详细介绍了，至此电话拨号请求的发送过程就完成了。拨号的本质就是应用层Phone进程首先对拨打的号码进行一系列处理，然后进入framework层，通过framework层的电话客户端发送线程将请求通过套接字的方式发送给电话服务进程rild，rild将该请求映射为相应的AT指令发送到modem中。


2.拨号界面显示

在CallController的placeCall函数中，首先将拨号请求发送到rild服务进程，然后启动呼叫界面InCallScreen，Android电话Phone UI分析对InCallScreen的UI布局进行了详细的分析，只有了解InCallScreen的UI布局，才能更好地理解InCallScreen的启动过程。InCallScreen主要是显示通话界面， 并且还负责菜单项各种按键事件和触摸时间的处理。同时本类还复写的finish()方法，所以一般不会被finish掉，调用该方法时它又把自己放回栈中。

src\com\android\phone\PhoneGlobals.java

[java] view plain copy
  1. voiddisplayCallScreen(){
  2. if(VDBG)Log.d(LOG_TAG,"displayCallScreen()...");
  3. //Onnon-voice-capabledevicesweshouldn'teverbetryingto
  4. //bringuptheInCallScreeninthefirstplace.
  5. if(!sVoiceCapable){
  6. Log.w(LOG_TAG,"displayCallScreen()notallowed:non-voice-capabledevice",newThrowable("stackdump"));
  7. return;
  8. }
  9. //启动电话呼叫界面InCallScreen
  10. try{
  11. startActivity(createInCallIntent());
  12. }catch(ActivityNotFoundExceptione){
  13. Log.w(LOG_TAG,"displayCallScreen:transitiontoInCallScreenfailed:"+e);
  14. }
  15. Profiler.callScreenRequested();
  16. }


[java] view plain copy
  1. staticIntentcreateInCallIntent(){
  2. Intentintent=newIntent(Intent.ACTION_MAIN,null);
  3. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
  4. |Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
  5. |Intent.FLAG_ACTIVITY_NO_USER_ACTION);
  6. intent.setClassName("com.android.phone",getCallScreenClassName());
  7. returnintent;
  8. }
  10. privatestaticStringgetCallScreenClassName(){
  11. returnInCallScreen.class.getName();
  12. }

第一次启动InCallScreen，首先调用其onCreate函数

src\com\android\phone\InCallScreen.java
[java] view plain copy
  1. protectedvoidonCreate(Bundleicicle){
  2. Log.i(LOG_TAG,"onCreate()...this="+this);
  3. //获得通话界面被创建的时间
  4. Profiler.callScreenOnCreate();
  5. super.onCreate(icicle);
  6. //Makesurethisisavoice-capabledevice.
  7. if(!PhoneGlobals.sVoiceCapable){
  8. Log.wtf(LOG_TAG,"onCreate()reachedonnon-voice-capabledevice");
  9. finish();
  10. return;
  11. }
  12. mApp=PhoneGlobals.getInstance();
  13. mApp.setInCallScreenInstance(this);
  14. //setthisflagsothisactivitywillstayinfrontofthekeyguard
  15. intflags=WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
  16. |WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
  17. if(mApp.getPhoneState()==PhoneConstants.State.OFFHOOK){
  18. flags|=WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD;
  19. }
  20. WindowManager.LayoutParamslp=getWindow().getAttributes();
  21. lp.flags|=flags;
  22. if(!mApp.proximitySensorModeEnabled()){
  23. //Ifwedon'thaveaproximitysensor,thenthein-callscreenexplicitly
  24. //controlsuseractivity.Thisistopreventspurioustouchesfromwaking
  25. //thedisplay.
  26. lp.inputFeatures|=WindowManager.LayoutParams.INPUT_FEATURE_DISABLE_USER_ACTIVITY;
  27. }
  28. //设置窗体属性
  29. getWindow().setAttributes(lp);
  30. setPhone(mApp.phone);//SetsmPhone
  31. mCM=mApp.mCM;
  32. log("-onCreate:phonestate="+mCM.getState());
  33. mBluetoothAdapter=BluetoothAdapter.getDefaultAdapter();
  34. if(mBluetoothAdapter!=null){
  35. mBluetoothAdapter.getProfileProxy(getApplicationContext(),mBluetoothProfileServiceListener,
  36. BluetoothProfile.HEADSET);
  37. }
  38. //设置窗体显示风格
  39. requestWindowFeature(Window.FEATURE_NO_TITLE);
  40. //加载布局文件
  41. setContentView(R.layout.incall_screen);
  42. finalViewStubtouchUiStub=(ViewStub)findViewById(
  43. mPhone.getPhoneType()==PhoneConstants.PHONE_TYPE_CDMA
  44. ?R.id.inCallTouchUiCdmaStub:R.id.inCallTouchUiStub);
  45. if(touchUiStub!=null)touchUiStub.inflate();
  46. //加载各种view组建
  47. initInCallScreen();
  48. //对通话的各种状态进行广播。
  49. registerForPhoneStates();
  50. //判断是否使用了OTA技术，通过该判断设置通话界面的样式。
  51. if(icicle==null){
  52. if(DBG)log("onCreate():thisisourveryfirstlaunch,checkingintent...");
  53. internalResolveIntent(getIntent());
  54. }
  55. //记录通话界面创建完成后的时间
  56. Profiler.callScreenCreated();
  57. if(DBG)log("onCreate():exit");
  58. }
UI初始化过程，为了能更好的理解UI初始化过程，请查看 Android电话Phone UI分析一文了解电话呼叫界面的UI布局。 [java] view plain copy
  1. privatevoidinitInCallScreen(){
  2. if(VDBG)log("initInCallScreen()...");
  3. //HavetheWindowManagerfilterouttoucheventsthatare"toofat".
  4. getWindow().addFlags(WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES);
  5. //InitializetheCallCard.
  6. mCallCard=(CallCard)findViewById(R.id.callCard);
  7. if(VDBG)log("-mCallCard="+mCallCard);
  8. mCallCard.setInCallScreenInstance(this);
  9. //InitializetheonscreenUIelements.
  10. initInCallTouchUi();
  11. //Helperclasstokeeptrackofenabledness/stateofUIcontrols
  12. mInCallControlState=newInCallControlState(this,mCM);
  13. //Helperclasstorunthe"Manageconference"UI
  14. mManageConferenceUtils=newManageConferenceUtils(this,mCM);
  15. //TheDTMFDialpad.
  16. ViewStubstub=(ViewStub)findViewById(R.id.dtmf_twelve_key_dialer_stub);
  17. mDialer=newDTMFTwelveKeyDialer(this,stub);
  18. mPowerManager=(PowerManager)getSystemService(Context.POWER_SERVICE);
  19. }

[java] view plain copy
  1. privatevoidinternalResolveIntent(Intentintent){
  2. if(intent==null||intent.getAction()==null){
  3. return;
  4. }
  5. Stringaction=intent.getAction();
  6. if(DBG)log("internalResolveIntent:action="+action);
  7. if(action.equals(intent.ACTION_MAIN)){
  8. if(intent.hasExtra(SHOW_DIALPAD_EXTRA)){
  9. booleanshowDialpad=intent.getBooleanExtra(SHOW_DIALPAD_EXTRA,false);
  10. if(VDBG)log("-internalResolveIntent:SHOW_DIALPAD_EXTRA:"+showDialpad);
  11. mApp.inCallUiState.showDialpad=showDialpad;
  12. finalbooleanhasActiveCall=mCM.hasActiveFgCall();
  13. finalbooleanhasHoldingCall=mCM.hasActiveBgCall();
  14. if(showDialpad&&!hasActiveCall&&hasHoldingCall){
  15. PhoneUtils.switchHoldingAndActive(mCM.getFirstActiveBgCall());
  16. }
  17. }
  18. return;
  19. }
  20. if(action.equals(OtaUtils.ACTION_DISPLAY_ACTIVATION_SCREEN)){
  21. if(!TelephonyCapabilities.supportsOtasp(mPhone)){
  22. thrownewIllegalStateException(
  23. "ReceivedACTION_DISPLAY_ACTIVATION_SCREENintentonnon-OTASP-capabledevice:"
  24. +intent);
  25. }
  26. setInCallScreenMode(InCallScreenMode.OTA_NORMAL);
  27. if((mApp.cdmaOtaProvisionData!=null)
  28. &&(!mApp.cdmaOtaProvisionData.isOtaCallIntentProcessed)){
  29. mApp.cdmaOtaProvisionData.isOtaCallIntentProcessed=true;
  30. mApp.cdmaOtaScreenState.otaScreenState=
  31. CdmaOtaScreenState.OtaScreenState.OTA_STATUS_ACTIVATION;
  32. }
  33. return;
  34. }
  35. if(action.equals(OtaUtils.ACTION_PERFORM_CDMA_PROVISIONING)){
  36. thrownewIllegalStateException(
  37. "UnexpectedACTION_PERFORM_CDMA_PROVISIONINGreceivedbyInCallScreen:"+intent);
  38. }elseif(action.equals(Intent.ACTION_CALL)||action.equals(Intent.ACTION_CALL_EMERGENCY)){
  39. //ACTION_CALL*intentsgototheOutgoingCallBroadcaster,whichnow
  40. //translatesthemintoCallController.placeCall()callsratherthan
  41. //launchingtheInCallScreendirectly.
  42. thrownewIllegalStateException("UnexpectedCALLactionreceivedbyInCallScreen:"+intent);
  43. }elseif(action.equals(ACTION_UNDEFINED)){
  44. //Thisactionisonlyusedforinternalbookkeeping;weshould
  45. //neveractuallygetlaunchedwithit.
  46. Log.wtf(LOG_TAG,"internalResolveIntent:gotlaunchedwithACTION_UNDEFINED");
  47. return;
  48. }else{
  49. Log.wtf(LOG_TAG,"internalResolveIntent:unexpectedintentaction:"+action);
  50. //Butcontinuethebestwecan(basicallytreatingthiscase
  51. //likeACTION_MAIN...)
  52. return;
  53. }
  54. }

更多相关文章

  1. android studio编译android M时无法使用org.apache.http.**的解
  2. Android如何实现模态对话框（Modal Dialog）
  3. 向Android模拟器发短信打电话
  4. android中View.measure方法详解
  5. Android(安卓)build/envsetup.sh 脚本分析(lunch函数)
  6. 刚学会百度地图最新版的sdk，总结一个简单的demo
  7. Android复制手机号码到剪切板并调起打电话功能
  8. android wifi子系统
  9. Android(安卓)实现自动接听和挂断电话功能

随机推荐

  1. Android 无线启动过程分析 无线启动过程
  2. android recycleView局部刷新的选择
  3. Android学习——TextView 设置中划线 下
  4. Best Android Remote Desktop Apps?
  5. Android中的文件存储数据方式 .
  6. android 开机动画（boot animation）的制作
  7. Android基础入门教程——7.1.3 Android(
  8. Android NDK之二：创建NativeActivity
  9. Android指纹解锁边界性问题
  10. android TextView和EditText中显示图片