网络连接评分机制之NetworkFactory

http://blog.csdn.net/u010961631/article/details/48971431

在开机时，各个提供网络连接的对象需要向ConnectivityService注册自己，并把自己所提供的网络的分值告诉ConnectivityService。

        为了ConnectivityService便于统一管理，每一个具备提供网络服务的对象都需要创建一个NetworkFactory的子类对象，并利用该对象注册自己，以及提供自己的分值。

一、NetworkFactory介绍

        我们先来看一下该对象的属性：

[java]  view plain  copy

1. @NetworkFactory.java  
2. /** 
3.  * A NetworkFactory is an entity that creates NetworkAgent objects. 
4.  * The bearers register with ConnectivityService using {@link #register} and 
5.  * their factory will start receiving scored NetworkRequests.  NetworkRequests 
6.  * can be filtered 3 ways: by NetworkCapabilities, by score and more complexly by 
7.  * overridden function.  All of these can be dynamic - changing NetworkCapabilities 
8.  * or score forces re-evaluation of all current requests. 
9.  * @hide 
10.  **/  
11. public class NetworkFactory extends Handler {}  

        这里的注释介绍了该类的基本作用和注册方法，其开头的部分介绍到，该对象可以用来创建NetworkAgent，而结尾的hide标明该类是隐藏类，也就是说 第三方应用无法使用，也就意味着第三方应用是无法承担网络连接的责任 。
        从其继承关系看到，他的本质是一个Handler类。
        然后我们来简单介绍一下该类提供的几个重要方法：

[java]  view plain  copy

1. //将当前网络注册到ConnectivityService   
2. public void register() { }  
3. //处理网络请求，用于打开或者释放当前连接  
4. private void handleAddRequest(NetworkRequest request, int score) {}  
5. //更新当前网络的分值  
6. public void setScoreFilter(int score) {}  

        以上三个是最重要的方法，在接下来的分析中将会多次看到他们的调用。还有几个比较特殊的方法：

[java]  view plain  copy

1. protected void startNetwork() { }  
2. protected void stopNetwork() { }  
3. protected void needNetworkFor(NetworkRequest networkRequest, int score) { }  
4. protected void releaseNetworkFor(NetworkRequest networkRequest) { }  

        这些方法都是protected属性，他们的作用就是在评分后，决定当前网络被激活或者释放，因此 一般都会在子类中被覆盖 。

        属性和方法介绍到这里，下面介绍该对象的使用。

二、NetworkFactory在数据连接中的初始化过程

        我们从数据提供者DcTracker来看NetworkFactory的初始化以及使用方法。
        简单介绍一下DcTracker，他是数据网络的提供者，承担着APN参数选择、数据业务建立与释放等作用。
        在DcTracker初始化时将会初始化数据的NetworkFactory对象：

[java]  view plain  copy

1. @DcTracker.java  
2. public DcTracker(PhoneBase p) {  
3.     ConnectivityManager cm = (ConnectivityManager)p.getContext().getSystemService( Context.CONNECTIVITY_SERVICE);  
4.     mNetworkFilter = new NetworkCapabilities();  
5.     mNetworkFilter.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);  
6.     mNetworkFilter.addCapability(NetworkCapabilities.NET_CAPABILITY_MMS);  
7.     mNetworkFilter.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);  
8.     mNetworkFilter.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);  
9.     //初始化NetworkFactory的子类TelephonyNetworkFactory  
10.     mNetworkFactory = new TelephonyNetworkFactory(this.getLooper(), p.getContext(), "TelephonyNetworkFactory", mNetworkFilter);  
11.     //设置当前网络的分数为50分  
12.     mNetworkFactory.setScoreFilter(50);  
13.     mNetworkFactoryMessenger = new Messenger(mNetworkFactory);  
14.     //把当前的NetworkFactory注册到ConnectivityService中  
15.     cm.registerNetworkFactory(mNetworkFactoryMessenger, "Telephony");  
16. }  

        从DcTracker中我们发现， 该网络环境的NetworkFactory其实是TelephonyNetworkFactory ，他的定义： 

[java]  view plain  copy

1. @DcTracker.java  
2.  private class TelephonyNetworkFactory extends NetworkFactory {  
3.      public TelephonyNetworkFactory(Looper l, Context c, String TAG, NetworkCapabilities nc) {  
4.          super(l, c, TAG, nc);  
5.      }  
6.      @Override  
7.      protected void needNetworkFor(NetworkRequest networkRequest, int score) {  
8.          //进行数据连接的激活  
9.          ApnContext apnContext = apnContextForNetworkRequest(networkRequest);  
10.          if (apnContext != null) apnContext.incRefCount();  
11.      }  
12.      @Override  
13.      protected void releaseNetworkFor(NetworkRequest networkRequest) {  
14.          //数据连接释放  
15.          ApnContext apnContext = apnContextForNetworkRequest(networkRequest);  
16.          if (apnContext != null) apnContext.decRefCount();  
17.      }  
18.  }  

        以上就是数据连接的NetworkFactory初始化过程，正如我们之前所说，要使用NetworkFactory只需要三个步骤：
        1、初始化NetworkFactory子类，并实现其中的protected方法，他们的作用就是在网络评分时决定激活或者释放当前的网络连接。
        2、设置当前网络的分值

        3、将当前NetworkFactory注册到ConnectivityService

三、NetworkFactory在WIFI连接中的初始化过程

        上面介绍了数据连接的NetworkFactory，那么WIFI的NetworkFactory初始化过程是怎样的呢？
        同样的，在WIFI检测到系统初始化完毕的时候，将会创建自己的NetworkFactory并向ConnectivityService注册：

[java]  view plain  copy

1. @WifiStateMachine.java  
2. class DefaultState extends State {  
3.     @Override  
4.     public boolean processMessage(Message message) {  
5.         switch (message.what) {  
6.             case CMD_BOOT_COMPLETED:  
7.                 String countryCode = mPersistedCountryCode;  
8.                 checkAndSetConnectivityInstance();  
9.                 //创建WIFI的NetworkFactory子类  
10.                 mNetworkFactory = new WifiNetworkFactory(getHandler().getLooper(), mContext, NETWORKTYPE, mNetworkCapabilitiesFilter);  
11.                 //设置WIFI网络分数为60  
12.                 mNetworkFactory.setScoreFilter(60);  
13.                 //注册  
14.                 mCm.registerNetworkFactory(new Messenger(mNetworkFactory), NETWORKTYPE);  
15.                 break;  
16.             default:  
17.                 break;  
18.         }  
19.         return HANDLED;  
20.     }  
21. }  

        来看WIFI的NetworkFactory：

[java]  view plain  copy

1. private class WifiNetworkFactory extends NetworkFactory {  
2.     public WifiNetworkFactory(Looper l, Context c, String TAG, NetworkCapabilities f) {  
3.         super(l, c, TAG, f);  
4.     }  
5.     protected void startNetwork() {  
6.     }  
7.     protected void stopNetwork() {  
8.     }  
9. }  

        其过程与数据连接中创建NetworkFactory的过程是一样的，并且WIFI的NetworkFactory的实现更加简单，虽然覆盖了父类中的两个protected方法，但是实际上该方法在WIFI中也是空的。这说明，WIFI无法通过NetworkFactory释放自己的链接（而可以通过NetworkAgent来释放）。

四、NetworkFactory的注册过程

        上面两个连接在初始化NetworkFactory过程中，最后都要将其注册到ConnectivityService中，下面我们就详细介绍一下该注册过程。
        虽然注册的过程是向ConnectivityManager申请的，但是从前一节《 Framework中的连接管理机制 》中我们知道，ConnectivityManager将会把相应请求交给ConnectivityService来处理，对于注册的申请，也是传递到ConnectivityService中的registerNetworkFactory()来处理的：

[java]  view plain  copy

1. @ConnectivityService.java  
2. public void registerNetworkFactory(Messenger messenger, String name) {  
3.     enforceConnectivityInternalPermission();  
4.     //NetworkFactory在ConnectivityService内部是以NetworkFactoryInfo形式存在的  
5.     NetworkFactoryInfo nfi = new NetworkFactoryInfo(name, messenger, new AsyncChannel());  
6.     mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_FACTORY, nfi));  
7. }  

        从这里我们看到，在ConnectivityService中，利用当前的NetworkFactory创建NetworkFactoryInfo对象，该对象保存了当前网络连接的name、Messenger对象，并且为其创建了AsyncChannel。
        接下来继续看注册过程：

[java]  view plain  copy

1. private class InternalHandler extends Handler {  
2.     public void handleMessage(Message msg) {  
3.         NetworkInfo info;  
4.         switch (msg.what) {  
5.             case EVENT_REGISTER_NETWORK_FACTORY: {  
6.                 handleRegisterNetworkFactory((NetworkFactoryInfo)msg.obj);  
7.                 break;  
8.             }  
9.         }  
10.     }  
11. }  

        继续：

[java]  view plain  copy

1. private void handleRegisterNetworkFactory(NetworkFactoryInfo nfi) {  
2.     mNetworkFactoryInfos.put(nfi.messenger, nfi);  
3.     nfi.asyncChannel.connect(mContext, mTrackerHandler, nfi.messenger);  
4. }  

        到这里我们发现， ConnectivityService将当前的NetworkFactoryInfo保存到mNetworkFactoryInfos 中，然后向当前的NetworkFactory发起AsyncChannel 单向通道 申请( AsyncChannel相关介绍见这里 )。
        申请成功时，将会向当前的mTrackerHandler发送CMD_CHANNEL_HALF_CONNECTED消息：

[java]  view plain  copy

1. @ConnectivityService.java  
2. private class NetworkStateTrackerHandler extends Handler {  
3.     public void handleMessage(Message msg) {  
4.         NetworkInfo info;  
5.         switch (msg.what) {  
6.             case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {  
7.                 handleAsyncChannelHalfConnect(msg);  
8.                 break;  
9.             }  
10.         }  
11.     }  
12. }  

        处理单向连接：

[java]  view plain  copy

1. private void handleAsyncChannelHalfConnect(Message msg) {  
2.     AsyncChannel ac = (AsyncChannel) msg.obj;  
3.     if (mNetworkFactoryInfos.containsKey(msg.replyTo)) {  
4.         if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {  
5.             for (NetworkRequestInfo nri : mNetworkRequests.values()) {  
6.                 if (nri.isRequest == false) continue;  
7.                 NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId);  
8.                 ac.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, (nai != null ? nai.getCurrentScore() : 0), 0, nri.request);  
9.             }  
10.         } else {  
11.         }  
12.     } else if (mNetworkAgentInfos.containsKey(msg.replyTo)) {  
13.     }  
14. }  

        在这里，ConnectivityService通过AsyncChannel通道向当前的NetworkFactory发起CMD_REQUEST_NETWORK的请求，需要注意的是，该请求所附带的第二个参数选择，由于当前处于初始化阶段，因此当前的mNetworkForRequestId中为空，也就是说此时传递的第二个参数必然为0。
        我们接下来看NetworkFactory收到该请求时的处理：

[java]  view plain  copy

1. @NetworkFactory.java  
2. public void handleMessage(Message msg) {  
3.     switch (msg.what) {  
4.         case CMD_REQUEST_NETWORK: {  
5.             handleAddRequest((NetworkRequest)msg.obj, msg.arg1);  
6.             break;  
7.         }  
8.     }  
9. }  

        继续：

[java]  view plain  copy

1. private void handleAddRequest(NetworkRequest request, int score) {  
2.     NetworkRequestInfo n = mNetworkRequests.get(request.requestId);  
3.     if (n == null) {  
4.         n = new NetworkRequestInfo(request, score);  
5.         mNetworkRequests.put(n.request.requestId, n);  
6.     } else {  
7.         n.score = score;  
8.     }  
9.     evalRequest(n);  
10. }  

        在这里由于是第一次接收到CMD_REQUEST_NETWORK的请求，因此将会在NetworkFactory中创建NetworkRequestInfo的对象，然后进入网络评价过程：

[java]  view plain  copy

1. private void evalRequest(NetworkRequestInfo n) {  
2.     if (n.requested == false && n.score < mScore && n.request.networkCapabilities.satisfiedByNetworkCapabilities( mCapabilityFilter) && acceptRequest(n.request, n.score)) {  
3.         needNetworkFor(n.request, n.score);  
4.         n.requested = true;  
5.     } else if (n.requested == true && (n.score > mScore || n.request.networkCapabilities.satisfiedByNetworkCapabilities( mCapabilityFilter) == false || acceptRequest(n.request, n.score) == false)) {  
6.         releaseNetworkFor(n.request);  
7.         n.requested = false;  
8.     }  
9. }  

        该逻辑就是整个网络评价系统最关键的地方，如果NetworkRequestInfo没有被requested过，并且其分值(n.score)小于当前NetworkFactory自己的分值(mScore)，那么就说明，当前NetworkFactory所处的网络优先级高于其他网络的优先级，就会触发当前NetworkFactory所在网络的needNetworkFor()流程，也就是连接建立流程，并将标记NetworkRequestInfo.requested=true。
        当NetworkRequestInfo被requested过(也就是当前网络被needNetworkFor过)，此时如果再次收到请求，并且携带的新score大于当前NetworkFactory所处网络的mScore，那么就说明当前NetworkFactory所在网络优先级已经不是最高，需要将其releaseNetworkFor掉，并标记NetworkRequestInfo.requested=false。
        对于初始化流程来说，由于NetworkRequestInfo是刚才在handleAddRequest新创建的，所以其requested状态必然为false，而且我们前面提到，ConnectivityService发送CMD_REQUEST_NETWORK时携带的分值参数为0，并且对于数据网络来说，其mScore=50，因此此时的判定状态将会是：n.requested=false AND n.score < mScore。
        也就是说，对于数据网络环境初始化过程来说，将会满足第一个if判断，进入needNetworkFor流程，也就是触发数据网络的建立。
        至此，NetworkFactory注册流程结束。