天天看点
返回

Android 网络管家ConnectivityManager

Android提供了多种网络链接通道，最常见的是WIFI和移动基站通信（Cellular)，另外还可将终端本身作为热点（Wifi Access Point),也可通过WIFI进行将两个终端直接进行连接（Wifi P2P），从而交互数据;同时还支持蓝牙将WIFI作为数据热点(Access Point),为其他设备提供网络接入。

对于移动通信，不同的运营商提供了不同的服务，网络提供的服务能力也各不相同。那么，Android是如何区分网络的承载能力的？为了区分不同网络的承载能力，Android提供了多达20种网络能力用以区分网络数据的接入方式（以下只列举常见的类型)：

  • NET_CAPABILITY_MMS： Multimedia Messaging Service,表示网络可以通过MMSC发送MMS（彩信）；
  • NET_CAPABILITY_SUPL： Secure User Plane Location,网络可以使用基站进行辅助GPS定位；
  • NET_CAPABILITY_DUN ： Dial-Up Network,网络支持拨号的方式接入
  • NET_CAPABILITY_FOTA ： Firmware Over The Air,网络可以使用FOTA服务器进行软件升级；
  • NET_CAPABILITY_IMS ： IP Multimedia Subsystem, 网络可以使用多媒体系统服务
  • NET_CAPABILITY_CBS : Cell BroadCast Messaging, 网络可以接收基站广播消息
  • NET_CAPABILITY_WIFI_P2P:Wifi Peer to Peer(Wifi Direct)，网络支持WIFI直连
  • NET_CAPABILITY_INTERNET：网络支持互联网访问

Android中有一个系统服务

ConnectivityService

用于管理网络连接的状态与信息，通过该系统服务，我们可以查询当前可用的网络信息，发起网络链接请求，设置网络属性与参数等。在这篇文章里，将从以下几个方面来讲解下

ConnectivityService

具体是如何工作的？

  • ConnectivityManager

     如何使用；

  • ConnectivityService

     的初始化；

  • ConnectivityService

     是如何与Telephony数据模块进行交互的
以下分析均基于Android MM6.0

ConnectivityManager常用接口

ConnectivityManager提供了很多接口用于获取系统当前的网络连接信息：

  • getAllNetworkInfo()

     : 返回所有网络信息

  • getActiveNetworkInfo()

     :获取当前激活的网络连接信息

  • getNetworkForType

     : 获取指定类型的网络

  • requestNetwork(...)

     : 请求建立某种类型的网络

  • setAirplaneMode()

     : 开启飞行模式

  • addDefaultNetworkActiveListener()

     : 监听默认网络连接是否激活

  • registerNetworkCallback()

     : 监听某个网络请求的状态，可用时进行回调

比如，现在监听移动数据的状态，首先需要在

AndroidManifest.xml

中声明网络相关的权限：

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
  • 获取当前激活网络的信息 
ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);

    NetworkInfo network = cm.getActiveNetworkInfo();
    int type = ConnectivityManager.TYPE_DUMMY;
    if(network != null) {
        type = network.getType();
    }

    if (type == ConnectivityManager.TYPE_MOBILE) {
        Log.v(TAG, " mobile data is connected: " + network.isConnected());
    } else if (type == ConnectivityManager.TYPE_WIFI){
        Log.v(TAG, "wifi is connected: " + network.isConnected());
    }
  • 监听网络可用（WIFI或者移动数据）的变化 
ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    NetworkRequest.Builder builder = new NetworkRequest.Builder();
    NetworkRequest request = builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                        .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                        .build();

    cm.requestNetwork(request, new ConnectivityManager.NetworkCallback() {

        @Override
        public void onAvailable(Network network) {
            Log.v(TAG, "onAvailable(): network " + network);
           // do something
        }

    });

ConnectivityService

 初始化

在系统进程

SystemServer

启动过程中，会新建一个

ConnectivityService

一个实例：

try {
        connectivity = new ConnectivityService(
                context, networkManagement, networkStats, networkPolicy);
        // 将ConnectivityService添加注册到系统
        ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
        networkStats.bindConnectivityManager(connectivity);
        networkPolicy.bindConnectivityManager(connectivity);
    } catch (Throwable e) {
        reportWtf("starting Connectivity Service", e);
    }

ConnectivityService初始化时主要做了以下几个事情：

  • 创建默认的移动数据请求；
  • 初始化消息队列；
  • 网络热点状态监听 
protected ConnectivityService(Context context, INetworkManagementService netManager,
            INetworkStatsService statsService, INetworkPolicyManager policyManager,
            IpConnectivityLog logger) {
        // 创建默认的网络请求
        mDefaultRequest = createInternetRequestForTransport(-, NetworkRequest.Type.REQUEST);
        NetworkRequestInfo defaultNRI = new NetworkRequestInfo(null, mDefaultRequest, new Binder());
        mNetworkRequests.put(mDefaultRequest, defaultNRI);
        // 创建默认的移动数据网络请求
        mDefaultMobileDataRequest = createInternetRequestForTransport(
                NetworkCapabilities.TRANSPORT_CELLULAR, NetworkRequest.Type.BACKGROUND_REQUEST);
        // 创建消息处理线程
        mHandlerThread = createHandlerThread();
        mHandlerThread.start();
        mHandler = new InternalHandler(mHandlerThread.getLooper());
        mTrackerHandler = new NetworkStateTrackerHandler(mHandlerThread.getLooper());
        ....
        //读取网络属性
        String[] naStrings = context.getResources().getStringArray(
                com.android.internal.R.array.networkAttribute);
        for (String naString : naStrings) {
            try {
                NetworkConfig n = new NetworkConfig(naString);
                ....
                mNetConfigs[n.type] = n;
                mNetworksDefined++;
            } catch(Exception e) {
                // ignore it - leave the entry null
            }
        }
        // 网络数据热点控制
        mTethering = new Tethering(mContext, mNetd, statsService, mPolicyManager);
        ....

        try {
            //通过NETD监控数据流量上下行方向
            mNetd.registerObserver(mTethering);
            mNetd.registerObserver(mDataActivityObserver);
        } catch (RemoteException e) {
            loge("Error registering observer :" + e);
        }

        mSettingsObserver = new SettingsObserver(mContext, mHandler);
        registerSettingsCallbacks();

        mDataConnectionStats = new DataConnectionStats(mContext);
        mDataConnectionStats.startMonitoring();

        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);

        mNotifier = new NetworkNotificationManager(mContext, mTelephonyManager,
                mContext.getSystemService(NotificationManager.class));
        // 网络数据使用控制
        final int dailyLimit = Settings.Global.getInt(mContext.getContentResolver(),
                Settings.Global.NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT,
                LingerMonitor.DEFAULT_NOTIFICATION_DAILY_LIMIT);
        final long rateLimit = Settings.Global.getLong(mContext.getContentResolver(),
                Settings.Global.NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS,
                LingerMonitor.DEFAULT_NOTIFICATION_RATE_LIMIT_MILLIS);
        mLingerMonitor = new LingerMonitor(mContext, mNotifier, dailyLimit, rateLimit);
    }

AMS(ActiviyManagerService)初始化完成后，系统启动完成，

SystemServer

会调用各个Service的SystemReady函数，

ConnectivityService

开始执行：

void systemReady() {    
        // 配置全局代理
        loadGlobalProxy();
        // load the global proxy at startup
        mHandler.sendMessage(mHandler.obtainMessage(EVENT_APPLY_GLOBAL_HTTP_PROXY));

        // Configure whether mobile data is always on.
        mHandler.sendMessage(mHandler.obtainMessage(EVENT_CONFIGURE_MOBILE_DATA_ALWAYS_ON));

        mHandler.sendMessage(mHandler.obtainMessage(EVENT_SYSTEM_READY));
        // 网络权限监控
        mPermissionMonitor.startMonitoring();
    }

ConnectivityService如何与Telephony进行交互

ConnectivityService如何与Telephony交互了？当手机通过基站连接上数据网络时，Telephony是如何告知

ConnectivityService

网络信息的？同时，用户在发送彩信时需要进行数据的配置；在进行视频通话时需要请求IMS服务;FOTA升级时需要访问FOTA服务器，这几种情况下ConnectivityService会向Telephony发送配置网络的请求，以特定的方式访问网络。在分析Telephony与ConnetivityService具体的交互过程之前，首先来看一看Telephony是如何管理数据连接的？

Telephony数据链接管理

Telephony与数据连接相关的主要代码有如下几个类:

  • ApnContext/ApnSetting

     : APN（Access Point Name,控制数据以何种方式接入网络)设置相关，Telephony初始化时，会加载资源文件

    config.xml

     中的

    networkAttributes

     配置文件，这里每个网络类型都对应一个

    ApnContenxt

     实例； 
<string-array translatable="false" name="networkAttributes">
            <item>"wifi,1,1,1,-1,true"</item>
            <item>"mobile,0,0,0,-1,true"</item>
            <item>"mobile_mms,2,0,2,60000,true"</item>
            <item>"mobile_supl,3,0,2,60000,true"</item>
            <item>"mobile_hipri,5,0,3,60000,true"</item>
            <item>"mobile_fota,10,0,2,60000,true"</item>
            <item>"mobile_ims,11,0,2,60000,true"</item>
            <item>"mobile_cbs,12,0,2,60000,true"</item>
            <item>"wifi_p2p,13,1,0,-1,true"</item>
            <item>"mobile_ia,14,0,2,-1,true"</item>
            <item>"mobile_emergency,15,0,2,-1,true"</item>
        </string-array>

  • DataConnection

     : 表示单个数据连接，是一个状态向量机，有Activating,Active,Disconnecting,Inactive以及Retring等几种状态。

    DataConnection

     中有一个私有类

    DcNetworkAgent

     （继承自

    NetworkAgent

     ),用于向

    ConnectivityService

     发送当前网络连接的状态信息,

    ConnectivityService

     接受到网络状态之后，就会更新网络。 
private class DcNetworkAgent extends NetworkAgent {
        public DcNetworkAgent(Looper l, Context c, String TAG, NetworkInfo ni,
                NetworkCapabilities nc, LinkProperties lp, int score, NetworkMisc misc) {
            super(l, c, TAG, ni, nc, lp, score, misc);
        }

        @Override
        protected void unwanted() {
            if (mNetworkAgent != this) {
                log("DcNetworkAgent: unwanted found mNetworkAgent=" + mNetworkAgent +
                        ", which isn't me.  Aborting unwanted");
                return;
            }
            // this can only happen if our exit has been called - we're already disconnected
            if (mApnContexts == null) return;

            for (ConnectionParams cp : mApnContexts.values()) {
                final ApnContext apnContext = cp.mApnContext;
                final Pair<ApnContext, Integer> pair =
                        new Pair<ApnContext, Integer>(apnContext, cp.mConnectionGeneration);
                log("DcNetworkAgent: [unwanted]: disconnect apnContext=" + apnContext);
                Message msg = mDct.obtainMessage(DctConstants.EVENT_DISCONNECT_DONE, pair);
                DisconnectParams dp = new DisconnectParams(apnContext, apnContext.getReason(), msg);
                DataConnection.this.sendMessage(DataConnection.this.
                        obtainMessage(EVENT_DISCONNECT, dp));
            }
        }
        ....
    }

NetworkAgent

 是一个代理者的角色，负责网络承载对象（如WIFI/WIFI直连,移动数据，蓝牙热点）与

ConnectivityService

 之间的交互

  • DcController

     : 数据连接控制，用以管理当前所有的数据连接；

  • DcAsyncChannel

     : 数据连接的异步通道，每个数据连接都对应这样一个异步通道，客户端想要新建或取消一个数据连接都应该通过对应的异步通道来发送请求命令；

  • DcTracker/DcTrackerBase

     : 维护系统的APN，管理网络连接状态；

  • DctController

     : 数据连接的核心类，控制网络状态的切换，负责与ConnectivityService交互，处理其发送过来的网络请求。
代码路径：
  • /android/frameworks/opt/telephony/src/java/com/android/internal/telephony/dataconnection/ApnContext.java
  • /android/frameworks/base/core/java/android/net/NetworkAgent.java

Telephony与ConnectivityService交互过程

刚才提到，当移动终端连接上移动网络之后，Telephony会通过

NetworkAgent

将网络信息发送给

ConnectivityService

，让其更新当前的网络信息；另一方面，当用户在发送彩信或者拨打视频通话时，

ConnectivityService

会主动向Telephony发送网络配置的请求。那么，这两个过程是如何进行的了？

Telephony告知ConnectivityService网络信息

在数据连接建立完成之后，Telephony通过

DcNetworkAgent

向

ConnectivityService

发送消息，告知其网络信息。初始化时，

DataConnection

的默认状态是Inactive:

private DataConnection(PhoneBase phone, String name, int id,
                    DcTrackerBase dct, DcTesterFailBringUpAll failBringUpAll,
                    DcController dcc) {
            super(name, dcc.getHandler());
            ....
            mDataRegState = mPhone.getServiceState().getDataRegState();
            int networkType = ss.getDataNetworkType();
            mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_MOBILE,
                    networkType, NETWORK_TYPE, TelephonyManager.getNetworkTypeName(networkType));
            mNetworkInfo.setRoaming(ss.getDataRoaming());
            mNetworkInfo.setIsAvailable(true);

            addState(mDefaultState);
            ....
            // 初始化状态
            setInitialState(mInactiveState);
    }

状态机接收到建立数据连接的请求后，连接初始化成功后，接着向Modem发起建立数据连接的请求，并把状态机的状态切换至DcActivating,表示当前正在建立数据：

private class DcInactiveState extends State {
            ....

            @Override
            public boolean processMessage(Message msg) {
                boolean retVal;

                switch (msg.what) {
                    ....
                    // 网络连接请求
                    case EVENT_CONNECT:
                        ConnectionParams cp = (ConnectionParams) msg.obj;
                        // 初始化连接
                        if (initConnection(cp)) {
                            //向Modem发送数据连接请求
                            onConnect(mConnectionParams);
                            //状态切换至Activating
                            transitionTo(mActivatingState);
                        } else {
                            notifyConnectCompleted(cp, DcFailCause.UNACCEPTABLE_NETWORK_PARAMETER,
                                    false);
                        }
                        retVal = HANDLED;
                        break;
                    ....
                    default:
                        retVal = NOT_HANDLED;
                        break;
                }
                return retVal;
    }

等Modem建立数据连接后，Telephony收到建立成功的消息，发送给

DataConnection

,当前状态

DcActivatingState

负责处理该消息，若没有错误，则直接切换至Active状态：

// state machine is activating a connection
    private class DcActivatingState extends State {
        @Override
        public boolean processMessage(Message msg) {
            boolean retVal;
            AsyncResult ar;
            ConnectionParams cp;

            switch (msg.what) {
                ....
                case EVENT_SETUP_DATA_CONNECTION_DONE:
                    ar = (AsyncResult) msg.obj;
                    cp = (ConnectionParams) ar.userObj;

                    DataCallResponse.SetupResult result = onSetupConnectionCompleted(ar);

                    switch (result) {
                        case SUCCESS:
                            // All is well,切换至Active状态
                            ...
                            mDcFailCause = DcFailCause.NONE;
                            transitionTo(mActiveState);
                            break;
                        // 各种错误处理
                        case ERR_xxxx
                            ...
                            break;
                }
                default:
                    retVal = NOT_HANDLED;
                    break;
            }
            return retVal;
        }
    }
有关Android的StateMachine可参考: /android/frameworks/base/core/java/com/android/internal/util/StateMachine.java

状态机进入到active状态，此时表示数据连接建立成功，最后建立一个

NetworkAgent

对象，并将该对象注册到

ConnectivitySerice

:

private class DcActiveState extends State {
        @Override public void enter() {
            if (mConnectionParams != null) {
                ApnContext apnContext = mConnectionParams.mApnContext;
                int network = ConnectivityManager.TYPE_NONE;
                // 根据APN设置网络类型
                switch(apnContext.getApnType()) {
                    case PhoneConstants.APN_TYPE_IMS:
                        network = ConnectivityManager.TYPE_MOBILE_IMS;
                        break;
                    case PhoneConstants.APN_TYPE_EMERGENCY:
                        network = ConnectivityManager.TYPE_MOBILE_EMERGENCY;
                        break;
                    default:
                        network = ConnectivityManager.TYPE_MOBILE;
                        break;
                }
                if ((network != ConnectivityManager.TYPE_NONE) && (network != mNetworkInfo.getType())) {
                    mNetworkInfo.setType(network);
                }
            }

            boolean createNetworkAgent = true;
            ....

            mDcController.addActiveDcByCid(DataConnection.this);

            mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED,
                    mNetworkInfo.getReason(), null);
            ....
            final NetworkMisc misc = new NetworkMisc();
            misc.subscriberId = mPhone.getSubscriberId();
            // 创建NetworkAgent，并向ConnectivityService注册该代理对象
            if (createNetworkAgent) {
                mNetworkAgent = new DcNetworkAgent(getHandler().getLooper(), mPhone.getContext(),
                        "DcNetworkAgent", mNetworkInfo, makeNetworkCapabilities(), mLinkProperties,
                        , misc);
            }
        }
    }

向

ConnectivityService

注册

DcNetworkAgent

,并将当前网络连接信息发送给

ConnectivityService

，同时发送一个包含了该代理对象的

Messager

用于与

ConnectivityService

之间的数据交换：

public NetworkAgent(Looper looper, Context context, String logTag, NetworkInfo ni,
            NetworkCapabilities nc, LinkProperties lp, int score, NetworkMisc misc) {
        super(looper);
        mContext = context;
        if (ni == null || nc == null || lp == null) {
            throw new IllegalArgumentException();
        }
        ConnectivityManager cm = (ConnectivityManager)mContext.getSystemService(
                Context.CONNECTIVITY_SERVICE);
        //注册NetworkAgent
        netId = cm.registerNetworkAgent(new Messenger(this), new NetworkInfo(ni),
                new LinkProperties(lp), new NetworkCapabilities(nc), score, misc);
    }

ConnectivityService

注册NetworkAgent，生成一个可用的网络ID；

mHandler

接收到消息后，在

mTrackerHandler

(跟踪网络状态）与

DcNetworkAgent

之间建立一个异步通信通道，并更新网络状态：

public int registerNetworkAgent(Messenger messenger, NetworkInfo networkInfo,
                LinkProperties linkProperties, NetworkCapabilities networkCapabilities,
                int currentScore, NetworkMisc networkMisc) {
            enforceConnectivityInternalPermission();
            // TODO: Instead of passing mDefaultRequest, provide an API to determine whether a Network
            // satisfies mDefaultRequest.

            // if exist, just return netid value
            synchronized (mNetworkForNetId) {
                if (mNetworkForNetId.get(netid) != null) {
                    return netid;
                }
            }

            final NetworkAgentInfo nai = new NetworkAgentInfo(messenger, new AsyncChannel(),
                    new Network(reserveNetId()), new NetworkInfo(networkInfo), new LinkProperties(
                    linkProperties), new NetworkCapabilities(networkCapabilities), currentScore,
                    mContext, mTrackerHandler, new NetworkMisc(networkMisc), mDefaultRequest, this);
            synchronized (this) {
                nai.networkMonitor.systemReady = mSystemReady;
            }

            mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_AGENT, nai));
            return nai.network.netId;
        }

        // mHandler接收到消息后，调用该函数进行处理
        private void handleRegisterNetworkAgent(NetworkAgentInfo na) {
            mNetworkAgentInfos.put(na.messenger, na);

            synchronized (mNetworkForNetId) {
                mNetworkForNetId.put(na.network.netId, na);
            }
            // 建立mTrackHandler与DcNetworkAgent之间的通信通道
            na.asyncChannel.connect(mContext, mTrackerHandler, na.messenger);
            NetworkInfo networkInfo = na.networkInfo;
            na.networkInfo = null;
            // 更新网络状态
            updateNetworkInfo(na, networkInfo);
        }

更新网络状态：

  • 如果Netd尚未创建对应的物理链接，则创建NetworkInfo对应的物理网络连接；
  • 更新网络连接属性，信号强度，重新匹配当前网络与网络请求；
  • 通知注册了回调的监听者网络状态信息； 
private void updateNetworkInfo(NetworkAgentInfo networkAgent, NetworkInfo newInfo) {
            if(DBG) Log.e(TAG, "updateNetworkInfo()");
            NetworkInfo.State state = newInfo.getState();
            NetworkInfo oldInfo = null;
            final int oldScore = networkAgent.getCurrentScore();
            boolean isSuspendedToConnected = false;
            ....
            // Netd尚未创建NetworkInfo对应的物理网络链接
            if (state == NetworkInfo.State.CONNECTED && (!networkAgent.created || isSuspendedToConnected)) {
                if ((networkAgent.networkInfo.getType() != ConnectivityManager.TYPE_WIFI)
                        && !networkAgent.created) {
                    try {
                        // This should never fail.  Specifying an already in use NetID will cause failure.
                        if (networkAgent.isVPN()) {
                            mNetd.createVirtualNetwork(networkAgent.network.netId,
                                    !networkAgent.linkProperties.getDnsServers().isEmpty(),
                                    (networkAgent.networkMisc == null ||
                                        !networkAgent.networkMisc.allowBypass));
                        } else {
                            mNetd.createPhysicalNetwork(networkAgent.network.netId,
                                networkAgent.networkCapabilities.hasCapability(
                                        NET_CAPABILITY_NOT_RESTRICTED) ?
                                        null : NetworkManagementService.PERMISSION_SYSTEM);
                        }
                    } catch (Exception e) {
                        loge("Error creating network " + networkAgent.network.netId + ": "
                                + e.getMessage());
                        return;
                    }
                }

                networkAgent.created = true;
                updateLinkProperties(networkAgent, null);
                notifyIfacesChanged();
                networkAgent.networkMonitor.sendMessage(NetworkMonitor.CMD_NETWORK_CONNECTED);

                updateSignalStrengthThresholds(networkAgent, "CONNECT", null);

                // Consider network even though it is not yet validated.
                rematchNetworkAndRequests(networkAgent, ReapUnvalidatedNetworks.REAP);

                // This has to happen after matching the requests, because callbacks are just requests.
                notifyNetworkCallbacks(networkAgent, ConnectivityManager.CALLBACK_PRECHECK);
            }else if{....}
    }

ConnectivityService

 向Telephony发送网络请求

上层需要使用特定的网络时，比如发送彩信（MMS)需要用到MMS网络；使用视频通话（Volte）需要使用IMS网络，都会向

ConnectivityService

发送网络请求，建立相应的网络连接，而

ConnectivityService

则会将这些网络请求发给Telephony，由其负责网络连接的建立。这里，就来看一看网络请求的处理过程。

在Telephony创建

DctController

的时候，创建一个

TelephonyNetworkFactory

用于接收来自

ConnectivityService

的网络请求，并将其注册到

ConnectivityService

中：

private void updatePhoneBaseForIndex(int index, PhoneBase phoneBase) {
        ....
        mNetworkFactory[index] = new TelephonyNetworkFactory(this.getLooper(),
                mPhones[index].getContext(), "TelephonyNetworkFactory", phoneBase,
                mNetworkFilter[index]);
        mNetworkFactory[index].setScoreFilter();
        mNetworkFactoryMessenger[index] = new Messenger(mNetworkFactory[index]);
        cm.registerNetworkFactory(mNetworkFactoryMessenger[index], "Telephony");
    }

ConnectivityService将包含了

TelephonyNetworkFactory

的消息传递类Messager打包成一个

NetworkFactoryInfo

，将其注册到系统中：

@Override
    public void registerNetworkFactory(Messenger messenger, String name) {
        enforceConnectivityInternalPermission();
        NetworkFactoryInfo nfi = new NetworkFactoryInfo(name, messenger, new AsyncChannel());
        mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_FACTORY, nfi));
    }

在

ConnectivityService

的内部类

NetworkStateTracker

与

TelephonyNetworkFactory

之间建立一个异步通信的通道，这样两者就可以相互发送消息了。

private void handleRegisterNetworkFactory(NetworkFactoryInfo nfi) {
        if (DBG) log("Got NetworkFactory Messenger for " + nfi.name);
        mNetworkFactoryInfos.put(nfi.messenger, nfi);
        nfi.asyncChannel.connect(mContext, mTrackerHandler, nfi.messenger);
    }

此后，APP向

ConnectivityService

发送网络请求，则

ConnectivityService

将请求打包成一个

NetworkRequestInfo

准备发送给NetworkFactory：

@Override
    public NetworkRequest requestNetwork(NetworkCapabilities networkCapabilities,
            Messenger messenger, int timeoutMs, IBinder binder, int legacyType) {
        networkCapabilities = new NetworkCapabilities(networkCapabilities);
        enforceNetworkRequestPermissions(networkCapabilities);
        enforceMeteredApnPolicy(networkCapabilities);
        ensureRequestableCapabilities(networkCapabilities);

        if (timeoutMs <  || timeoutMs > ConnectivityManager.MAX_NETWORK_REQUEST_TIMEOUT_MS) {
            throw new IllegalArgumentException("Bad timeout specified");
        }

        NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, legacyType,
                nextNetworkRequestId());
        NetworkRequestInfo nri = new NetworkRequestInfo(messenger, networkRequest, binder,NetworkRequestInfo.REQUEST);

        mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_REQUEST, nri));
        if (timeoutMs > ) {
            mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_TIMEOUT_NETWORK_REQUEST,
                    nri), timeoutMs);
        }
        return networkRequest;
    }

处理网络请求，首先匹配当前网络请求与网络，然后将该网络请求发送到NetworkFactory:

private void handleRegisterNetworkRequest(NetworkRequestInfo nri) {
            mNetworkRequests.put(nri.request, nri);
            // 匹配所有网络与网络请求
            rematchAllNetworksAndRequests(null, );
            if (nri.isRequest && mNetworkForRequestId.get(nri.request.requestId) == null) {
                // 发送更新后的网络评分（网络的优先级）到NetworkFactory
                sendUpdatedScoreToFactories(nri.request, );
            }
        }

将网络请求发送给所有已注册的NetworkFactory:

private void sendUpdatedScoreToFactories(NetworkRequest networkRequest, int score) {
        //通过异步通信通道向所有NetworkFactory发送网络请求
        for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) {
            nfi.asyncChannel.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, score, ,
                    networkRequest);
        }
    }

NetworkFactory接收到网络请求

CMD_REQUEST_NETWORK

:

protected void handleAddRequest(NetworkRequest request, int score) {
        NetworkRequestInfo n = mNetworkRequests.get(request.requestId);
        if (n == null) {
            if (DBG) log("got request " + request + " with score " + score);
            n = new NetworkRequestInfo(request, score);
            mNetworkRequests.put(n.request.requestId, n);
        } else {
            n.score = score;
        }
        // 评估该网络请求
        evalRequest(n);
    }

评估网络请求是否满足处理的条件：

private void evalRequest(NetworkRequestInfo n) {
            if (n.requested == false && n.score < mScore && (n.request.networkCapabilities.satisfiedByNetworkCapabilities(mCapabilityFilter) && acceptRequest(n.request, n.score))) {
                // 处理网络请求
                needNetworkFor(n.request, n.score);
                n.requested = true;
            } else if (n.requested == true &&
                (n.score > mScore || n.request.networkCapabilities.satisfiedByNetworkCapabilities(mCapabilityFilter) == false ||
                acceptRequest(n.request, n.score) == false)) {
                ....
                } else {
                    releaseNetworkFor(n.request);
                    n.requested = false;
                }
            }
        }


     @Override
        protected void needNetworkFor(NetworkRequest networkRequest, int score) {
            // figure out the apn type and enable it
            log("Cellular needs Network for " + networkRequest);

            if (getRequestPhoneId(networkRequest) == mPhone.getPhoneId()) {
                DcTrackerBase dcTracker =((PhoneBase)mPhone).mDcTracker;
                // 获取APN
                String apn = apnForNetworkRequest(networkRequest);
                // 是否支持对应的APN
                if (dcTracker.isApnSupported(apn)) {
                    requestNetwork(networkRequest, dcTracker.getApnPriority(apn), l);
                } 
            } else {
                // 将NetworkRequest放入缓冲队列
                mPendingReq.put(networkRequest.requestId, networkRequest);
            }
        }

调用

DctController

的

requestNetwork

函数，请求建立相应的网络连接：

private int requestNetwork(NetworkRequest request, int priority, LocalLog l) {
        logd("requestNetwork request=" + request + ", priority=" + priority);
        // 保存网络请求信息
        RequestInfo requestInfo = new RequestInfo(request, priority, l);
        mRequestInfos.put(request.requestId, requestInfo);
        // 处理网络请求
        processRequests();

        return PhoneConstants.APN_REQUEST_STARTED;
    }
android 网络 通信 WiFi
上一篇: Android ConnectivityManager学习
下一篇: Android网络状态之----ConnectivityManager下面咱们直接看代码：

继续阅读