Android 5.1 open data flow 数据开启流程

最新推荐文章于 2021-06-13 17:32:30 发布
最新推荐文章于 2021-06-13 17:32:30 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： Telephony
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa111/article/details/50059269
版权
先上一张流程图

data open.jpg
Settings.apk
在Settings ->  Data Usage Summary中的某个SIM tab下开启数据开关
android/ packages/apps/Settings/src/com/android/settings/DataUsageSummary.java
setMobileDataEnabled (true); 
   
   

    
    

     
     private View.OnClickListener mDataEnabledListener = new View.OnClickListener() {
    
    

    
    

     
             @Override
    
    

    
    

     
             public void onClick(View v) {
    
    

    
    

     
                 if (mBinding) return;
    
    

    
    

     
      
    
    

    
    

     
                 final boolean dataEnabled = !mDataEnabled.isChecked();
    
    

    
    

     
                 final String currentTab = mCurrentTab;
    
    

    
    

     
                 if (TAB_MOBILE.equals(currentTab) || currentTab.startsWith(TAB_SIM)) {
    
    

    
    

     
                     if (dataEnabled) {
    
    

    
    

     
                         setMobileDataEnabled(true);
    
    

    
    

     
                         if (mPolicyEditor.getPolicyWarningBytes(mTemplate) == WARNING_DISABLED) {
    
    

    
    

     
                             mPolicyEditor.setPolicyWarningBytes(mTemplate, 2 * GB_IN_BYTES);
    
    

    
    

     
                         }
    
    

    
    

     
                     } else {
    
    

    
    

     
                         // disabling data; show confirmation dialog which eventually
    
    

    
    

     
                         // calls setMobileDataEnabled() once user confirms.
    
    

    
    

     
                         ConfirmDataDisableFragment.show(DataUsageSummary.this);
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 updatePolicy(false);
    
    

    
    

     
             }
    
    

    
    

     
         };

下面这部根据phoneId获得了当前获得了SubId
mTelephonyManager . setDataEnabled ( subId [ 0 ], enabled ); 
   
   

    
    

     
      
    
    

    
    

     
         private void setMobileDataEnabled(boolean enabled) {
    
    

    
    

     
             if (LOGD) Log.d(TAG, "setMobileDataEnabled()");
    
    

    
    

     
             // How about exposing sub based API like TelephonyManager.setDataEnabled(int subId);
    
    

    
    

     
             if (mCurrentTab.startsWith(TAB_SIM)) {
    
    

    
    

     
                 int phoneId = multiSimGetCurrentSub();
    
    

    
    

     
      
    
    

    
    

     
                 // as per phone, set the individual flag
    
    

    
    

     
                 android.provider.Settings.Global.putInt(getActivity().getContentResolver(),
    
    

    
    

     
                         android.provider.Settings.Global.MOBILE_DATA + phoneId, enabled ? 1 : 0);
    
    

    
    

     
      
    
    

    
    

     
                 int[] subId = SubscriptionManager.getSubId(phoneId);
    
    

    
    

     
                 mTelephonyManager.setDataEnabled(subId[0], enabled);
    
    

    
    

     
             } else {
    
    

    
    

     
                 mTelephonyManager.setDataEnabled(enabled);
    
    

    
    

     
                 mMobileDataEnabled = enabled;
    
    

    
    

     
             }
    
    

    
    

     
             updatePolicy(false);
    
    

    
    

     
         }


frameworks/base
数据开关都会调用到TelephonyManager.setDataEnabled()，不管是从流量使用情况还是从下拉的“快速设置”（Quick Setting）里打开（这里会在后面补充说明）
android/frameworks/base/telephony/java/android/telephony/TelephonyManager.java
getITelephony (). setDataEnabled ( subId , enable ); 
   
   

    
    

     
         /** @hide */
    
    

    
    

     
         @SystemApi
    
    

    
    

     
         public void setDataEnabled(int subId, boolean enable) {
    
    

    
    

     
             try {
    
    

    
    

     
                 AppOpsManager appOps = (AppOpsManager)mContext.getSystemService(Context.APP_OPS_SERVICE);
    
    

    
    

     
                 if (enable) {
    
    

    
    

     
                     if (appOps.noteOp(AppOpsManager.OP_DATA_CONNECT_CHANGE) != AppOpsManager.MODE_ALLOWED) {
    
    

    
    

     
                         Log.w(TAG, "Permission denied by user.");
    
    

    
    

     
                         return;
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
                 Log.d(TAG, "setDataEnabled: enabled=" + enable);
    
    

    
    

     
                 getITelephony().setDataEnabled(subId, enable);
    
    

    
    

     
             } catch (RemoteException e) {
    
    

    
    

     
                 Log.e(TAG, "Error calling setDataEnabled", e);
    
    

    
    

     
             }
    
    

    
    

     
         }

android/ packages/services/Telephony/src/com/android/phone/PhoneInterfaceManager.java
到这里才是设置phone的数据开启
phone . setDataEnabled ( enable ); 
   
   

    
    

     
      
    
    

    
    

     
         /**
    
    

    
    

     
          * Set mobile data enabled
    
    

    
    

     
          * Used by the user through settings etc to turn on/off mobile data
    
    

    
    

     
          *
    
    

    
    

     
          * @param enable {@code true} turn turn data on, else {@code false}
    
    

    
    

     
          */
    
    

    
    

     
         @Override
    
    

    
    

     
         public void setDataEnabled(int subId, boolean enable) {
    
    

    
    

     
             enforceModifyPermission();
    
    

    
    

     
             int phoneId = mSubscriptionController.getPhoneId(subId);
    
    

    
    

     
             log("getDataEnabled: subId=" + subId + " phoneId=" + phoneId);
    
    

    
    

     
             Phone phone = PhoneFactory.getPhone(phoneId);
    
    

    
    

     
             if (phone != null) {
    
    

    
    

     
                 log("setDataEnabled: subId=" + subId + " enable=" + enable);
    
    

    
    

     
                 phone.setDataEnabled(enable);
    
    

    
    

     
             } else {
    
    

    
    

     
                 loge("setDataEnabled: no phone for subId=" + subId);
    
    

    
    

     
             }
    
    

    
    

     
         }

android/ frameworks/opt/telephony/src/java/com/android/internal/telephony/gsm/GSMPhone.java
mDcTracker . setDataEnabled ( enable ); 
   
   

    
    

     
         @Override
    
    

    
    

     
         public void setDataEnabled(boolean enable) {
    
    

    
    

     
             mDcTracker.setDataEnabled(enable);
    
    

    
    

     
         }
  android/rameworks/opt/telephony/src/java/com/android/internal/telephony/dataconnection/DcTrackerBase.java   
发送打开数据开关的消息CMD_SET_USER_DATA_ENABLE
Message msg = obtainMessage ( DctConstants . CMD_SET_USER_DATA_ENABLE ); 
   
   

    
    

     
         /**
    
    

    
    

     
          * Modify {@link android.provider.Settings.Global#MOBILE_DATA} value.
    
    

    
    

     
          */
    
    

    
    

     
         public void setDataEnabled(boolean enable) {
    
    

    
    

     
             Message msg = obtainMessage(DctConstants.CMD_SET_USER_DATA_ENABLE);
    
    

    
    

     
             msg.arg1 = enable ? 1 : 0;
    
    

    
    

     
             sendMessage(msg);
    
    

    
    

     
         }
处理消息
onSetUserDataEnabled ( enabled ); 
   
   

    
    

     
         @Override
    
    

    
    

     
         public void handleMessage(Message msg) {
    
    

    
    

     
             switch (msg.what) {
    
    

    
    

     
                 case AsyncChannel.CMD_CHANNEL_DISCONNECTED: {
    
    

    
    

     
                     log("DISCONNECTED_CONNECTED: msg=" + msg);
    
    

    
    

     
                     DcAsyncChannel dcac = (DcAsyncChannel) msg.obj;
    
    

    
    

     
                     mDataConnectionAcHashMap.remove(dcac.getDataConnectionIdSync());
    
    

    
    

     
                     dcac.disconnected();
    
    

    
    

     
                     break;
    
    

    
    

     
                 }
    
    

    
    

     
                 ...
    
    

    
    

     
                 case DctConstants.CMD_SET_USER_DATA_ENABLE: {
    
    

    
    

     
                     final boolean enabled = (msg.arg1 == DctConstants.ENABLED) ? true : false;
    
    

    
    

     
                     if (DBG) log("CMD_SET_USER_DATA_ENABLE enabled=" + enabled);
    
    

    
    

     
                     onSetUserDataEnabled(enabled);
    
    

    
    

     
                     break;
    
    

    
    

     
                 }
    
    

    
    

     
     ...
onTrySetupData ( Phone . REASON_DATA_ENABLED ); 
   
   

    
    

     
         protected void onSetUserDataEnabled(boolean enabled) {
    
    

    
    

     
             synchronized (mDataEnabledLock) {
    
    

    
    

     
                 if (mUserDataEnabled != enabled) {
    
    

    
    

     
                     mUserDataEnabled = enabled;
    
    

    
    

     
                     Settings.Global.putInt(mPhone.getContext().getContentResolver(),
    
    

    
    

     
                             Settings.Global.MOBILE_DATA + mPhone.getPhoneId(), enabled ? 1 : 0);
    
    

    
    

     
                     if (getDataOnRoamingEnabled() == false &&
    
    

    
    

     
                             mPhone.getServiceState().getRoaming() == true) {
    
    

    
    

     
                         if (enabled) {
    
    

    
    

     
                             notifyOffApnsOfAvailability(Phone.REASON_ROAMING_ON);
    
    

    
    

     
                         } else {
    
    

    
    

     
                             notifyOffApnsOfAvailability(Phone.REASON_DATA_DISABLED);
    
    

    
    

     
                         }
    
    

    
    

     
                     }
    
    

    
    

     
      
    
    

    
    

     
                     if (enabled) {
    
    

    
    

     
                         onTrySetupData(Phone.REASON_DATA_ENABLED);
    
    

    
    

     
                     } else {
    
    

    
    

     
                         onCleanUpAllConnections(Phone.REASON_DATA_SPECIFIC_DISABLED);
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
         }

android/frameworks/opt/telephony/src/java/com/android/internal/telephony/dataconnection/DcTracker.java
setupDataOnConnectableApns ( reason ); 
   
   

    
    

     
         @Override
    
    

    
    

     
         // TODO: We shouldnt need this.
    
    

    
    

     
         protected boolean onTrySetupData(String reason) {
    
    

    
    

     
             if (DBG) log("onTrySetupData: reason=" + reason);
    
    

    
    

     
             setupDataOnConnectableApns(reason);
    
    

    
    

     
             return true;
    
    

    
    

     
         }
trySetupData ( apnContext ); 
   
   

    
    

     
         private void setupDataOnConnectableApns(String reason) {
    
    

    
    

     
             if (DBG) log("setupDataOnConnectableApns: " + reason);
    
    

    
    

     
      
    
    

    
    

     
             for (ApnContext apnContext : mPrioritySortedApnContexts) {
    
    

    
    

     
                 if (DBG) log("setupDataOnConnectableApns: apnContext " + apnContext);
    
    

    
    

     
                 if (apnContext.getState() == DctConstants.State.FAILED) {
    
    

    
    

     
                     apnContext.setState(DctConstants.State.IDLE);
    
    

    
    

     
                 }
    
    

    
    

     
                 if (apnContext.isConnectable()) {
    
    

    
    

     
                     log("setupDataOnConnectableApns: isConnectable() call trySetupData");
    
    

    
    

     
                     apnContext.setReason(reason);
    
    

    
    

     
                     trySetupData(apnContext);
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
         }
下面这个方法比较长，有很多条件的检查
boolean retValue = setupData ( apnContext , radioTech ); 
   
   

    
    

     
      
    
    

    
    

     
         private boolean trySetupData(ApnContext apnContext) {
    
    

    
    

     
             ...        
    
    

    
    

     
             
     
     if
     
      
     
     (
     
     apnContext
     
     .
     
     isConnectable
     
     ()
     
      
     
     &&
     
      
     
     (
     
     isEmergencyApn 
     
     ||

     
      
    
    

    
    

     
                     (isDataAllowed(apnContext) &&
    
    

    
    

     
                     getAnyDataEnabled(checkUserDataEnabled) && !isEmergency()))) {
    
    

    
    

     
                 if (apnContext.getState() == DctConstants.State.FAILED) {
    
    

    
    

     
                     if (DBG) log("trySetupData: make a FAILED ApnContext IDLE so its reusable");
    
    

    
    

     
                     apnContext.setState(DctConstants.State.IDLE);
    
    

    
    

     
                 }
    
    

    
    

     
                 int radioTech = mPhone.getServiceState().getRilDataRadioTechnology();
    
    

    
    

     
                 if (apnContext.getState() == DctConstants.State.IDLE) {
    
    

    
    

     
      
    
    

    
    

     
                     ArrayList<ApnSetting> waitingApns = buildWaitingApns(apnContext.getApnType(),
    
    

    
    

     
                             radioTech);
    
    

    
    

     
                     if (waitingApns.isEmpty()) {
    
    

    
    

     
                         notifyNoData(DcFailCause.MISSING_UNKNOWN_APN, apnContext);
    
    

    
    

     
                         notifyOffApnsOfAvailability(apnContext.getReason());
    
    

    
    

     
                         if (DBG) log("trySetupData: X No APN found retValue=false");
    
    

    
    

     
                         return false;
    
    

    
    

     
                     } else {
    
    

    
    

     
                         apnContext.setWaitingApns(waitingApns);
    
    

    
    

     
                         if (DBG) {
    
    

    
    

     
                             log ("trySetupData: Create from mAllApnSettings : "
    
    

    
    

     
                                         + apnListToString(mAllApnSettings));
    
    

    
    

     
                         }
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 if (DBG) {
    
    

    
    

     
                     log("trySetupData: call setupData, waitingApns : "
    
    

    
    

     
                             + apnListToString(apnContext.getWaitingApns()));
    
    

    
    

     
                 }
    
    

    
    

     
                 boolean retValue = setupData(apnContext, radioTech);//7
    
    

    
    

     
                 notifyOffApnsOfAvailability(apnContext.getReason());
    
    

    
    

     
      
    
    

    
    

     
                 if (DBG) log("trySetupData: X retValue=" + retValue);
    
    

    
    

     
                 return retValue;
    
    

    
    

     
             } else {
    
    

    
    

     
                 if (!apnContext.getApnType().equals(PhoneConstants.APN_TYPE_DEFAULT)
    
    

    
    

     
                         && apnContext.isConnectable()) {
    
    

    
    

     
                     mPhone.notifyDataConnectionFailed(apnContext.getReason(), apnContext.getApnType());
    
    

    
    

     
                 }
    
    

    
    

     
                 notifyOffApnsOfAvailability(apnContext.getReason());
    
    

    
    

     
                 if (DBG) log ("trySetupData: X apnContext not 'ready' retValue=false");
    
    

    
    

     
                 return false;
    
    

    
    

     
             }
    
    

    
    

     
         }
dcac.bringUp(apnContext, getInitialMaxRetry(), profileId, radioTech, mAutoAttachOnCreation, msg ); 
   
   

    
    

     
      private boolean setupData(ApnContext apnContext, int radioTech) {
    
    

    
    

     
             if (DBG) log("setupData: apnContext=" + apnContext);
    
    

    
    

     
             ApnSetting apnSetting;
    
    

    
    

     
             DcAsyncChannel dcac = null;
    
    

    
    

     
      
    
    

    
    

     
             apnSetting = apnContext.getNextWaitingApn();
    
    

    
    

     
             if (apnSetting == null) {
    
    

    
    

     
                 if (DBG) log("setupData: return for no apn found!");
    
    

    
    

     
                 return false;
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             int profileId = apnSetting.profileId;
    
    

    
    

     
             if (profileId == 0) {
    
    

    
    

     
                 profileId = getApnProfileID(apnContext.getApnType());
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             // On CDMA, if we're explicitly asking for DUN, we need have
    
    

    
    

     
             // a dun-profiled connection so we can't share an existing one
    
    

    
    

     
             // On GSM/LTE we can share existing apn connections provided they support
    
    

    
    

     
             // this type.
    
    

    
    

     
             if (apnContext.getApnType() != PhoneConstants.APN_TYPE_DUN ||
    
    

    
    

     
                     teardownForDun() == false) {
    
    

    
    

     
                 dcac = checkForCompatibleConnectedApnContext(apnContext);
    
    

    
    

     
                 if (dcac != null) {
    
    

    
    

     
                     // Get the dcacApnSetting for the connection we want to share.
    
    

    
    

     
                     ApnSetting dcacApnSetting = dcac.getApnSettingSync();
    
    

    
    

     
                     if (dcacApnSetting != null) {
    
    

    
    

     
                         // Setting is good, so use it.
    
    

    
    

     
                         apnSetting = dcacApnSetting;
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
             if (dcac == null) {
    
    

    
    

     
                 if (isOnlySingleDcAllowed(radioTech)) {
    
    

    
    

     
                     if (isHigherPriorityApnContextActive(apnContext)) {
    
    

    
    

     
                         if (DBG) {
    
    

    
    

     
                             log("setupData: Higher priority ApnContext active.  Ignoring call");
    
    

    
    

     
                         }
    
    

    
    

     
                         return false;
    
    

    
    

     
                     }
    
    

    
    

     
      
    
    

    
    

     
                     // Only lower priority calls left.  Disconnect them all in this single PDP case
    
    

    
    

     
                     // so that we can bring up the requested higher priority call (once we receive
    
    

    
    

     
                     // repsonse for deactivate request for the calls we are about to disconnect
    
    

    
    

     
                     if (cleanUpAllConnections(true, Phone.REASON_SINGLE_PDN_ARBITRATION)) {
    
    

    
    

     
                         // If any call actually requested to be disconnected, means we can't
    
    

    
    

     
                         // bring up this connection yet as we need to wait for those data calls
    
    

    
    

     
                         // to be disconnected.
    
    

    
    

     
                         if (DBG) log("setupData: Some calls are disconnecting first.  Wait and retry");
    
    

    
    

     
                         return false;
    
    

    
    

     
                     }
    
    

    
    

     
      
    
    

    
    

     
                     // No other calls are active, so proceed
    
    

    
    

     
                     if (DBG) log("setupData: Single pdp. Continue setting up data call.");
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 dcac = findFreeDataConnection();
    
    

    
    

     
      
    
    

    
    

     
                 if (dcac == null) {
    
    

    
    

     
                     dcac = createDataConnection();
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 if (dcac == null) {
    
    

    
    

     
                     if (DBG) log("setupData: No free DataConnection and couldn't create one, WEIRD");
    
    

    
    

     
                     return false;
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
             if (DBG) log("setupData: dcac=" + dcac + " apnSetting=" + apnSetting);
    
    

    
    

     
      
    
    

    
    

     
             apnContext.setDataConnectionAc(dcac);
    
    

    
    

     
             apnContext.setApnSetting(apnSetting);
    
    

    
    

     
             apnContext.setState(DctConstants.State.CONNECTING);
    
    

    
    

     
             mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
    
    

    
    

     
      
    
    

    
    

     
             Message msg = obtainMessage();
    
    

    
    

     
             msg.what = DctConstants.EVENT_DATA_SETUP_COMPLETE;
    
    

    
    

     
             msg.obj = apnContext;
    
    

    
    

     
             dcac.bringUp(apnContext, getInitialMaxRetry(), profileId, radioTech, mAutoAttachOnCreation,
    
    

    
    

     
                     msg);//8
    
    

    
    

     
      
    
    

    
    

     
             if (DBG) log("setupData: initing!");
    
    

    
    

     
             return true;
    
    

    
    

     
         }

android/frameworks/opt/telephony/src/java/com/android/internal/telephony/dataconnection/DcAsyncChannel.java
sendMessage 
   
   

    
    

     
         /**
    
    

    
    

     
          * Bring up a connection to the apn and return an AsyncResult in onCompletedMsg.
    
    

    
    

     
          * Used for cellular networks that use Acesss Point Names (APN) such
    
    

    
    

     
          * as GSM networks.
    
    

    
    

     
          *
    
    

    
    

     
          * @param apnContext is the Access Point Name to bring up a connection to
    
    

    
    

     
          * @param initialMaxRetry the number of retires for initial bringup.
    
    

    
    

     
          * @param profileId for the conneciton
    
    

    
    

     
          * @param onCompletedMsg is sent with its msg.obj as an AsyncResult object.
    
    

    
    

     
          *        With AsyncResult.userObj set to the original msg.obj,
    
    

    
    

     
          *        AsyncResult.result = FailCause and AsyncResult.exception = Exception().
    
    

    
    

     
          */
    
    

    
    

     
         public void bringUp(ApnContext apnContext, int initialMaxRetry, int profileId,
    
    

    
    

     
                 int rilRadioTechnology, boolean retryWhenSSChange, Message onCompletedMsg) {
    
    

    
    

     
             if (DBG) {
    
    

    
    

     
                 log("bringUp: apnContext=" + apnContext + " initialMaxRetry=" + initialMaxRetry
    
    

    
    

     
                     + " onCompletedMsg=" + onCompletedMsg);
    
    

    
    

     
             }
    
    

    
    

     
             sendMessage(DataConnection.EVENT_CONNECT,//9
    
    

    
    

     
                         new ConnectionParams(apnContext, initialMaxRetry, profileId,
    
    

    
    

     
                                 rilRadioTechnology, retryWhenSSChange, onCompletedMsg));
    
    

    
    

     
         }


android/frameworks/opt/telephony/src/java/com/android/internal/telephony/dataconnection/DataConnection.java
这其实是个状态即机 StateMachine，这个类或者或机制，本身也比较复杂，以后看明白了以后会单独在写一篇文章
现在是进入其中一个状态 DcInactiveState。
DcInactiveState processmesssage
onConnect ( mConnectionParams ); 
   
   

    
    

     
          /**
     
     

      
      

       
        * The state machine is inactive and expects a EVENT_CONNECT.
      
      

      
      

       
        */
      
      

      
      

       
        private class DcInactiveState extends State {
      
      

      
      

       
        ...
      
      

      
      

       
        
      
      

      
      

       
        @Override
      
      

      
      

       
        public boolean processMessage(Message msg) {
      
      

     
     

     
            ...                    
     
         
     
         
    
    

    
    

     
     

    
    

    
    

     
                 case EVENT_CONNECT:
    
    

    
    

     
                         if (DBG) log("DcInactiveState: mag.what=EVENT_CONNECT");
    
    

    
    

     
                         ConnectionParams cp = (ConnectionParams) msg.obj;
    
    

    
    

     
                         if (initConnection(cp)) {
    
    

    
    

     
                             onConnect(mConnectionParams);//10
    
    

    
    

     
                             transitionTo(mActivatingState);
    
    

    
    

     
                         } else {
    
    

    
    

     
                             if (DBG) {
    
    

    
    

     
                                 log("DcInactiveState: msg.what=EVENT_CONNECT initConnection failed");
    
    

    
    

     
                             }
    
    

    
    

     
                             notifyConnectCompleted(cp, DcFailCause.UNACCEPTABLE_NETWORK_PARAMETER,
    
    

    
    

     
                                     false);
    
    

    
    

     
                         }
    
    

    
    

     
                         retVal = HANDLED;
    
    

    
    

     
                         break;
mPhone . mCi . setupDataCall 
   
   

    
    

     
      
    
    

    
    

     
         /**
    
    

    
    

     
          * Begin setting up a data connection, calls setupDataCall
    
    

    
    

     
          * and the ConnectionParams will be returned with the
    
    

    
    

     
          * EVENT_SETUP_DATA_CONNECTION_DONE AsyncResul.userObj.
    
    

    
    

     
          *
    
    

    
    

     
          * @param cp is the connection parameters
    
    

    
    

     
          */
    
    

    
    

     
         private void onConnect(ConnectionParams cp) {
    
    

    
    

     
             if (DBG) log("onConnect: carrier='" + mApnSetting.carrier
    
    

    
    

     
                     + "' APN='" + mApnSetting.apn
    
    

    
    

     
                     + "' proxy='" + mApnSetting.proxy + "' port='" + mApnSetting.port + "'");
    
    

    
    

     
      
    
    

    
    

     
             // Check if we should fake an error.
    
    

    
    

     
             if (mDcTesterFailBringUpAll.getDcFailBringUp().mCounter  > 0) {
    
    

    
    

     
                ...
    
    

    
    

     
     
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             mCreateTime = -1;
    
    

    
    

     
             mLastFailTime = -1;
    
    

    
    

     
             mLastFailCause = DcFailCause.NONE;
    
    

    
    

     
      
    
    

    
    

     
             // The data profile's profile ID must be set when it is created.
    
    

    
    

     
             int dataProfileId;
    
    

    
    

     
             if (mApnSetting.getApnProfileType() == ApnProfileType.PROFILE_TYPE_OMH) {
    
    

    
    

     
                 dataProfileId = mApnSetting.getProfileId() + RILConstants.DATA_PROFILE_OEM_BASE;
    
    

    
    

     
                 log("OMH profile, dataProfile id = " + dataProfileId);
    
    

    
    

     
             } else {
    
    

    
    

     
                 dataProfileId = cp.mProfileId;
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             // msg.obj will be returned in AsyncResult.userObj;
    
    

    
    

     
             Message msg = obtainMessage(EVENT_SETUP_DATA_CONNECTION_DONE, cp);
    
    

    
    

     
             msg.obj = cp;
    
    

    
    

     
      
    
    

    
    

     
             int authType = mApnSetting.authType;
    
    

    
    

     
             if (authType == -1) {
    
    

    
    

     
                 authType = TextUtils.isEmpty(mApnSetting.user) ? RILConstants.SETUP_DATA_AUTH_NONE
    
    

    
    

     
                         : RILConstants.SETUP_DATA_AUTH_PAP_CHAP;
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             String protocol;
    
    

    
    

     
             if (mPhone.getServiceState().getRoaming()) {
    
    

    
    

     
                 protocol = mApnSetting.roamingProtocol;
    
    

    
    

     
             } else {
    
    

    
    

     
                 protocol = mApnSetting.protocol;
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             mPhone.mCi.setupDataCall(//11
    
    

    
    

     
                     Integer.toString(cp.mRilRat + 2),
    
    

    
    

     
                     Integer.toString(dataProfileId),
    
    

    
    

     
                     mApnSetting.apn, mApnSetting.user, mApnSetting.password,
    
    

    
    

     
                     Integer.toString(authType),
    
    

    
    

     
                     protocol, msg);
    
    

    
    

     
         }

android/frameworks/opt/telephony/src/java/com/android/internal/telephony/RIL.java


--------------
十橙
关注
专栏目录
PCM data flow - 7 - Frame & Period
AZURE
04-02 8664
后面章节将分析 dma buffer 的管理，其中细节需要对音频数据相关概念有一定的了解。因此本章说明下音频数据中的几个重要概念： Sample：样本长度，音频数据最基本的单位，常见的有 8 位和 16 位； Channel：声道数，分为单声道 mono 和立体声 stereo； Frame：帧，构成一个完整的声音单元，Frame = Sample * channel； Rate：又称 sample
【Android系统源码修改】如何修改单卡和双卡工程的默认数据连接开关
Bright的博客
07-07 1113
[SOLUTION] 单卡项目: 数据连接都是由\alps\mediatek\config\工程名\ProjectConfig.mk下的MTK_DEFAULT_DATA_OFF这个属性来控制。 若MTK_DEFAULT_DATA_OFF=yes，则默认关闭. 同理，若设置成no就是默认打开。 KK版本： 请修改DefaultDataSimSetting.java中的setDataDefaultSi...
Android 屏蔽移动数据功能,Android9.0 开启关闭移动数据流程
weixin_34838910的博客
05-25 506
@DcTracker.javapublic void setUserDataEnabled(boolean enable) {Message msg = obtainMessage(DctConstants.CMD_SET_USER_DATA_ENABLE);msg.arg1 = enable ? 1 : 0;if (DBG) log("setDataEnabled: sendMessage: e...
Android 屏蔽移动数据功能,Android9.0开启关闭移动数据流程
weixin_42315706的博客
05-25 761
@DcTracker.javapublic void setUserDataEnabled(boolean enable) {Message msg = obtainMessage(DctConstants.CMD_SET_USER_DATA_ENABLE);msg.arg1 = enable ? 1 : 0;if (DBG) log("setDataEnabled: sendMessage: e...
Android 7.1开机之后APN的加载及拨号上网流程分析
秦逸轩的博客
06-13 6022
1、前言 在前段时间的项目中遇到客户的设备出现APN断开的情况没有自动连接，后来折腾了一段时间解决了这个问题。现在用这篇博客记录一下APN的选择和连接流程。 2、名词解析 APN：APN指一种网络接入技术，是通过手机上网时必须配置的一个参数，它决定了手机通过哪种接入方式来访问网络。 对于手机用户来说，可以访问的外部网络类型有很多，例如：Internet、WAP网站、集团企业内部网络、行业内部专用网络。而不同的接入点所能访问的范围以及接入的方式是不同的，网络侧如何知道手机激活以后要访问哪个网络从而分配哪
PreferenceFragment & DialogFragment & Spinner & NumberPicker
颂一家之言
03-27 794
PreferencFragment解析：http://blog.csdn.net/lmj623565791/article/details/37970961/ billing_cycle.xml <PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" android:title="@stri
2023国际信息管理数据洞见期刊 - 基于区块链的数据驱动审批流程系统
International Journal of Information Management Data Insights 3（2023）100162基于区块链的数据驱动可信审批流程系统SanilGandhi，Arvind Kiwelekar，Laxman Netak，Shashank Shahare计算机工程系，博士...
datastore java_Android 使用DataStore存储数据
weixin_42298100的博客
02-23 1132
1 添加依赖2 在 main 文件夹下创建 .proto 文件3 编写 Serializer4 编写基础存储工具类5 举例使用** 5.1 创建 DataStore 存储工具子类** 5.2 基本使用6 混淆1 添加依赖implementation "androidx.datastore:datastore:1.0.0-alpha06"implementation "androidx.da...
5.1 SAP BW on HANA 数据建模特性
人丑多读书
08-14 8411
本章节主要介绍优化理念（optimized concepts）、新特性（new features）、对ABAP开发的影响（impact on ABAP development） 5.1.1 Optimized Concepts for SAP BW on SAP HANA 以前使用infoCube是出于性能的考虑（星型模型和减少数据量）。在SAP BW on HANA中，由于HANA的高性能，
（N）Telephony分析（六）之DcTracker的requestNetwork分析
每个片段都值得深深纪念
09-14 1843
在PhoneApp的初始化中，我们分析到，TelephonyNetworkFactory的初始化，最终会调用到DcTracker的requestNetwork方法 private void onNeedNetworkFor(Message msg) { NetworkRequest networkRequest = (NetworkRequest)msg.obj; boolean
5.0上禁用手机移动数据上网调研
XXOOYC的专栏
03-22 7091
背景：     在4.4以及之前的手机，可以通过反射调用ConnectivityManager#setMobileDataEnabled()设置手机是否允许使用手机流量上网。    而到了5.0+，这个API已经被移除了。主要就是为了调研在5.0上如何实现，算是一个小调研吧。 调研结果： 在5.0上，取而代之的是TelephonyManager#setDataEnabled()
移动数据流程
05-20 684
移动数据流程 该文摘自网友，留作以便查阅 切入点，setting 中 ”启用移动数据“ 1： Settings.java (packages\apps\phone\src\com\android\phone)     开始点击启用移动数据的按钮        protected void onCreate(Bundle icicle) {         super.onCreate(i
Android 7.0 插卡后APN信息的加载流程、UI界面编辑APN的流程及Android中APN配置相关的漏洞
ZhangJian的博客
11-19 1万+
本篇博客主要分析了APN相关的常用流程，以及实际存在的APN相关的漏洞。
安卓的多PDN连接
what_a_fuck的博客
09-12 5205
PDN:公用数据网 Public Data Network  PDN连接过程是手机接入分组数据网的一个重要过程，其目的是在UE和分组数据网络间建立一个默认承载 PDP:分组数据协议 Packet Data Protocol  PDP上下文：PDP上下文是在MS和GSN节 点中存储的与SM有关的信息。这些信息也可以分为预订信息和位置信息两类。  静态和动态PDP地址：PDP地址是GPRS
content:// scheme 和 file:// scheme
路一直在
01-05 1万+
path 转 Uri (content://) /** * 根据file path 获取content:// * @param context * @param filePath * @return content:// */ public static Uri getImageContentUri(Context context, S
Android——4.2 - 3G移植之路之 APN (五)
jscese
11-19 5326
APN(Access Point Name),也就是 接入点 ，移动设备使用数据流量上网必须配置的一个参数，代表以何种方式来连接服务台开启数据流量功能. 一般有访问WAP或者connect 因特网，国内的运营商2G，3G标识如下： 移动公司：2G:GSM、3G:TD-SCDMA 联通公司：2G:GSM、3G:WCDMA 电信公司：2G:CDMA、3G:CDMA2000 关于具体某个运营商的几G网络 的APN 是什么具体可参考/device/sample/etc/apns-full-conf.xml
Android7.0 数据业务长连接去拨号过程
ZhangJian的博客
09-02 4428
在之前的博客中，我们分析了数据业务长连接的拨号过程，现在我们来看看Android如何实现去拨号过程。
文件File path与content:// Uri的相互转换
热门推荐
thini's Blog
08-15 1万+
content Uri to path /** * Gets the corresponding path to a file from the given content:// URI * @param selectedVideoUri The content:// URI to find the file path from * @param contentResolver T
android5.1 healthd详解：启动流程与功能剖析
总结来说，本文提供了关于Android 5.1 healthd服务的入门理解，着重讲解了服务的启动流程、操作模式选择以及与BatteryService的交互。对于想要深入研究Android底层电池管理和系统服务的开发者来说，这是一个很好的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值