devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android源码笔记--网络(二)_filternetworkstateforuid

作者：不正经 | 2024-04-13 19:41:56

赞

踩

filternetworkstateforuid

           这一节主要了解ConnectivityService,这个api在Android网络里使用较常见，它是Android网络管理的中心，它是在SystemServer中创建的，代码如下：

  1.  /frameworks/base/services/java/com/android/server/SystemServer.java
  2.  
  3. /**
  4.      * Starts a miscellaneous grab bag of stuff that has yet to be refactored and organized.
  5.      */
  6.    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
  7.      try {
  8.                 connectivity = new ConnectivityService(
  9.                         context, networkManagement, networkStats, networkPolicy);
  10.                 ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity,
  11.                         /* allowIsolated= */ false,
  12.                         DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
  13.                 networkPolicy.bindConnectivityManager(connectivity);
  14.             } catch (Throwable e) {
  15.                 reportWtf("starting Connectivity Service", e);
  16.             }
  17.    
  18.    }

分析:初始化过程ConnectivityService的构造方法非常长，如下:

  1. @VisibleForTesting
  2.     protected ConnectivityService(Context context, INetworkManagementService netManager,
  3.             INetworkStatsService statsService, INetworkPolicyManager policyManager,
  4.             IDnsResolver dnsresolver, IpConnectivityLog logger, INetd netd, Dependencies deps) {
  5.         if (DBG) log("ConnectivityService starting up");
  6. ...
  7.         mDefaultRequest = createDefaultInternetRequestForTransport(-1, NetworkRequest.Type.REQUEST);
  8.         mNetworkRanker = new NetworkRanker();
  9.         NetworkRequestInfo defaultNRI = new NetworkRequestInfo(null, mDefaultRequest, new Binder());
  10.         mNetworkRequests.put(mDefaultRequest, defaultNRI);
  11.         mNetworkRequestInfoLogs.log("REGISTER " + defaultNRI);
  12.  
  13.         mDefaultMobileDataRequest = createDefaultInternetRequestForTransport(
  14.                 NetworkCapabilities.TRANSPORT_CELLULAR, NetworkRequest.Type.BACKGROUND_REQUEST);
  15. ...
  16.         mDefaultWifiRequest = createDefaultInternetRequestForTransport(
  17.                 NetworkCapabilities.TRANSPORT_WIFI, NetworkRequest.Type.BACKGROUND_REQUEST);
  18.  
  19.         mHandlerThread = mDeps.makeHandlerThread();
  20.         mHandlerThread.start();
  21.         mHandler = new InternalHandler(mHandlerThread.getLooper());
  22.         mTrackerHandler = new NetworkStateTrackerHandler(mHandlerThread.getLooper());
  23.         mConnectivityDiagnosticsHandler =
  24.                 new ConnectivityDiagnosticsHandler(mHandlerThread.getLooper());
  25.  
  26.         mReleasePendingIntentDelayMs = Settings.Secure.getInt(context.getContentResolver(),
  27.                 Settings.Secure.CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS, 5_000);
  28.  
  29.         mLingerDelayMs = mSystemProperties.getInt(LINGER_DELAY_PROPERTY, DEFAULT_LINGER_DELAY_MS);
  30.  
  31.         mNMS = Objects.requireNonNull(netManager, "missing INetworkManagementService");
  32.         mStatsService = Objects.requireNonNull(statsService, "missing INetworkStatsService");
  33.         mPolicyManager = Objects.requireNonNull(policyManager, "missing INetworkPolicyManager");
  34.         mPolicyManagerInternal = Objects.requireNonNull(
  35.                 LocalServices.getService(NetworkPolicyManagerInternal.class),
  36.                 "missing NetworkPolicyManagerInternal");
  37.         mDnsResolver = Objects.requireNonNull(dnsresolver, "missing IDnsResolver");
  38.         mProxyTracker = mDeps.makeProxyTracker(mContext, mHandler);
  39.  
  40.         mNetd = netd;
  41.         mKeyStore = KeyStore.getInstance();
  42.         mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
  43.         mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
  44.         mLocationPermissionChecker = new LocationPermissionChecker(mContext);
  45. ...
  46.         try {
  47.             mPolicyManager.registerListener(mPolicyListener);
  48.         } catch (RemoteException e) {
  49.             // ouch, no rules updates means some processes may never get network
  50.             loge("unable to register INetworkPolicyListener" + e);
  51.         }
  52.  
  53.         final PowerManager powerManager = (PowerManager) context.getSystemService(
  54.                 Context.POWER_SERVICE);
  55.         mNetTransitionWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
  56.         mNetTransitionWakeLockTimeout = mContext.getResources().getInteger(
  57.                 com.android.internal.R.integer.config_networkTransitionTimeout);
  58.         mPendingIntentWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
  59.  
  60.         mNetConfigs = new NetworkConfig[ConnectivityManager.MAX_NETWORK_TYPE+1];
  61. ...
  62.         boolean wifiOnly = mSystemProperties.getBoolean("ro.radio.noril", false);
  63.         log("wifiOnly=" + wifiOnly);
  64.         String[] naStrings = context.getResources().getStringArray(
  65.                 com.android.internal.R.array.networkAttributes);
  66.         for (String naString : naStrings) {
  67.             try {
  68.                 NetworkConfig n = new NetworkConfig(naString);
  69.                 if (VDBG) log("naString=" + naString + " config=" + n);
  70.                 if (n.type > ConnectivityManager.MAX_NETWORK_TYPE) {
  71.                    
  72.                     continue;
  73.                 }
  74.                 if (wifiOnly && ConnectivityManager.isNetworkTypeMobile(n.type)) {
  75.                  
  76.                     continue;
  77.                 }
  78.                 if (mNetConfigs[n.type] != null) {
  79.                    
  80.                     continue;
  81.                 }
  82.                 mLegacyTypeTracker.addSupportedType(n.type);
  83.  
  84.                 mNetConfigs[n.type] = n;
  85.                 mNetworksDefined++;
  86.             } catch(Exception e) {
  87.                 // ignore it - leave the entry null
  88.             }
  89.         }
  90.  
  91.         if (mNetConfigs[TYPE_VPN] == null) {
  92.            
  93.             mLegacyTypeTracker.addSupportedType(TYPE_VPN);
  94.             mNetworksDefined++;  // used only in the log() statement below.
  95.         }
  96. ...
  97.         if (mNetConfigs[TYPE_ETHERNET] == null && mDeps.hasService(Context.ETHERNET_SERVICE)) {
  98.             mLegacyTypeTracker.addSupportedType(TYPE_ETHERNET);
  99.             mNetworksDefined++;
  100.         }
  101.  
  102.         if (VDBG) log("mNetworksDefined=" + mNetworksDefined);
  103.  
  104.         mProtectedNetworks = new ArrayList<Integer>();
  105.         int[] protectedNetworks = context.getResources().getIntArray(
  106.                 com.android.internal.R.array.config_protectedNetworks);
  107.         for (int p : protectedNetworks) {
  108.             if ((mNetConfigs[p] != null) && (mProtectedNetworks.contains(p) == false)) {
  109.                 mProtectedNetworks.add(p);
  110.             } else {
  111.                 if (DBG) loge("Ignoring protectedNetwork " + p);
  112.             }
  113.         }
  114.  
  115.         mWolSupportedInterfaces = new ArraySet(
  116.                 mContext.getResources().getStringArray(
  117.                         com.android.internal.R.array.config_wakeonlan_supported_interfaces));
  118.  
  119.         mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
  120.  
  121.         mPermissionMonitor = new PermissionMonitor(mContext, mNetd);
  122. ...
  123.         IntentFilter intentFilter = new IntentFilter();
  124.         intentFilter.addAction(Intent.ACTION_USER_STARTED);
  125.         intentFilter.addAction(Intent.ACTION_USER_STOPPED);
  126.         intentFilter.addAction(Intent.ACTION_USER_ADDED);
  127.         intentFilter.addAction(Intent.ACTION_USER_REMOVED);
  128.         intentFilter.addAction(Intent.ACTION_USER_UNLOCKED);
  129.         mContext.registerReceiverAsUser(
  130.                 mIntentReceiver,
  131.                 UserHandle.ALL,
  132.                 intentFilter,
  133.                 null /* broadcastPermission */,
  134.                 mHandler);
  135.         mContext.registerReceiverAsUser(mUserPresentReceiver, UserHandle.SYSTEM,
  136.                 new IntentFilter(Intent.ACTION_USER_PRESENT), null, null);
  137.  
  138.         // Listen to package add and removal events for all users.
  139.         intentFilter = new IntentFilter();
  140.         intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
  141.         intentFilter.addAction(Intent.ACTION_PACKAGE_REPLACED);
  142.         intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
  143.         intentFilter.addDataScheme("package");
  144.         mContext.registerReceiverAsUser(
  145.                 mIntentReceiver,
  146.                 UserHandle.ALL,
  147.                 intentFilter,
  148.                 null /* broadcastPermission */,
  149.                 mHandler);
  150.  
  151.         try {
  152.             mNMS.registerObserver(mDataActivityObserver);
  153.         } catch (RemoteException e) {
  154.             loge("Error registering observer :" + e);
  155.         }
  156.  
  157.         mSettingsObserver = new SettingsObserver(mContext, mHandler);
  158.         registerSettingsCallbacks();
  159.  
  160.         final DataConnectionStats dataConnectionStats = new DataConnectionStats(mContext, mHandler);
  161.         dataConnectionStats.startMonitoring();
  162.  
  163.         mKeepaliveTracker = new KeepaliveTracker(mContext, mHandler);
  164.         mNotifier = new NetworkNotificationManager(mContext, mTelephonyManager,
  165.                 mContext.getSystemService(NotificationManager.class));
  166.  
  167.         final int dailyLimit = Settings.Global.getInt(mContext.getContentResolver(),
  168.                 Settings.Global.NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT,
  169.                 LingerMonitor.DEFAULT_NOTIFICATION_DAILY_LIMIT);
  170.         final long rateLimit = Settings.Global.getLong(mContext.getContentResolver(),
  171.                 Settings.Global.NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS,
  172.                 LingerMonitor.DEFAULT_NOTIFICATION_RATE_LIMIT_MILLIS);
  173.         mLingerMonitor = new LingerMonitor(mContext, mNotifier, dailyLimit, rateLimit);
  174.  
  175.         mMultinetworkPolicyTracker = mDeps.makeMultinetworkPolicyTracker(
  176.                 mContext, mHandler, () -> rematchForAvoidBadWifiUpdate());
  177.         mMultinetworkPolicyTracker.start();
  178.  
  179.         mMultipathPolicyTracker = new MultipathPolicyTracker(mContext, mHandler);
  180.  
  181.         mDnsManager = new DnsManager(mContext, mDnsResolver, mSystemProperties);
  182.         registerPrivateDnsSettingsCallbacks();
  183.     }

执行过程大体如下:

     (1）创建处理消息的线程并启动。
  （2）创建处理消息的Handle对象mHandler、mTrackerHandler。
  （3)创建DefaultNetworkFactory 对象，用来创建各种NetworkStateTracker对象。
  （4）使用Android的ID设置net.hostname属性。这个属性将作为网络传输中的主机名。
  （5)从Setting 中或者系统资源Config.xml 的config_default_dns_server 项中得到DNS 服务器的IP地址，保存到变量mDefaultDns 中。
  （6）保存对其他系统服务的引用，包括NetworkManagementService、NetworkPolicyManagerService、PowerManagerService 和 PhoneInterfaceManager。
  （7)创建 wakelock对象mNetTransitionWakeLock，在网络有数据传输时用来防止休眠。
  （8）创建NetworkStateTracker对象的数组。
   (9)从系统资源Config.xml读取RadioAttributes、networkAttributes、config_protectedNetworks数组的值，分别用来初始化数组变量mRadioAttributes、mNetConfigs和mProtectedNetworks。
  （10）根据mNetConfigs数组，计算各种网络类型的优先级，保存在mPriorityList列表中。
  （11）变量mNetworkPreference表示系统中优先使用的网络，如果用户在Setting程序中设置了优先网络，则使用用户设置的值；用户没有设置，则从mPriorityList列表按照从先到后的顺序
  挑选当前有效的网络类型。
  （12）创建各种网络连接的NetworkState Tracker对象，填充mNetTrackers数组。
  （13）创建Tethering对象mTethering，用来共享网络。
  （14）创建监听用户状态变化 Intent的Receiver对象。
  （15）创建Nat464Xlat对象mClat，用于IPV4和IPV6地址的转换。

网络经常会用到的场景是获取当前网络类型，一般使用如下:

  1.  public static int getNetworkState(Context context) {
  2.         ConnectivityManager connManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); // 获取网络服务
  3.         if (null == connManager) { // 为空则认为无网络
  4.             return NETWORK_NONE;
  5.         }
  6.         // 获取网络类型，如果为空，返回无网络
  7.         NetworkInfo activeNetInfo = connManager.getActiveNetworkInfo();
  8.         if (activeNetInfo == null || !activeNetInfo.isAvailable()) {
  9.             return NETWORK_NONE;
  10.         }
  11.        return activeNetInfo.getType();
  12. }

看看源码:

  1. /frameworks/base/core/java/android/net/ConnectivityManager.java
  2.  
  3.   private final IConnectivityManager mService;
  4.  
  5.    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
  6.     @Nullable
  7.     public Network getActiveNetwork() {
  8.         try {
  9.             return mService.getActiveNetwork();
  10.         } catch (RemoteException e) {
  11.             throw e.rethrowFromSystemServer();
  12.         }
  13.     }
  1. /frameworks/base/core/java/android/net/IConnectivityManager.aidl
  2.  
  3. interface IConnectivityManager
  4. {
  5.     Network getActiveNetwork();
  6.     Network getActiveNetworkForUid(int uid, boolean ignoreBlocked);
  7.     @UnsupportedAppUsage
  8.     NetworkInfo getActiveNetworkInfo();
  9.     NetworkInfo getActiveNetworkInfoForUid(int uid, boolean ignoreBlocked);
  10.     @UnsupportedAppUsage(maxTargetSdk = 28)
  11.     NetworkInfo getNetworkInfo(int networkType);
  12. }
  1. /frameworks/base/services/core/java/com/android/server/ConnectivityService.java
  2.  
  3.    @Override
  4.     public NetworkInfo getNetworkInfo(int networkType) {
  5.         enforceAccessPermission();
  6.         final int uid = Binder.getCallingUid();
  7.         if (getVpnUnderlyingNetworks(uid) != null) {
  8.             // A VPN is active, so we may need to return one of its underlying networks. This
  9.             // information is not available in LegacyTypeTracker, so we have to get it from
  10.             // getUnfilteredActiveNetworkState.
  11.             final NetworkState state = getUnfilteredActiveNetworkState(uid);
  12.             if (state.networkInfo != null && state.networkInfo.getType() == networkType) {
  13.                 filterNetworkStateForUid(state, uid, false);
  14.                 return state.networkInfo;
  15.             }
  16.         }
  17.         final NetworkState state = getFilteredNetworkState(networkType, uid);
  18.         return state.networkInfo;
  19.     }
  20. 	
  21. 	
  22.  
  23.     private NetworkState getFilteredNetworkState(int networkType, int uid) {
  24.         if (mLegacyTypeTracker.isTypeSupported(networkType)) {
  25.             final NetworkAgentInfo nai = mLegacyTypeTracker.getNetworkForType(networkType);
  26.             final NetworkState state;
  27.             if (nai != null) {
  28.                 state = nai.getNetworkState();
  29.                 state.networkInfo.setType(networkType);
  30.             } else {
  31.                 final NetworkInfo info = new NetworkInfo(networkType, 0,
  32.                         getNetworkTypeName(networkType), "");
  33.                 info.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, null, null);
  34.                 info.setIsAvailable(true);
  35.                 final NetworkCapabilities capabilities = new NetworkCapabilities();
  36.                 capabilities.setCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING,
  37.                         !info.isRoaming());
  38.                 state = new NetworkState(info, new LinkProperties(), capabilities,
  39.                         null, null, null);
  40.             }
  41.             filterNetworkStateForUid(state, uid, false);
  42.             return state;
  43.         } else {
  44.             return NetworkState.EMPTY;
  45.         }
  46.     }	
  1. 	/frameworks/base/core/java/android/net/LinkProperties.java
  2. 	//网络连接相关属性在此设置
  3. 	
  4. 	public final class LinkProperties implements Parcelable {
  5. 	   @TestApi
  6.     public LinkProperties(@Nullable LinkProperties source, boolean parcelSensitiveFields) {
  7.         mParcelSensitiveFields = parcelSensitiveFields;
  8.         if (source == null) return;
  9.         mIfaceName = source.mIfaceName;
  10.         mLinkAddresses.addAll(source.mLinkAddresses);
  11.         mDnses.addAll(source.mDnses);
  12.         mValidatedPrivateDnses.addAll(source.mValidatedPrivateDnses);
  13.         mUsePrivateDns = source.mUsePrivateDns;
  14.         mPrivateDnsServerName = source.mPrivateDnsServerName;
  15.         mPcscfs.addAll(source.mPcscfs);
  16.         mDomains = source.mDomains;
  17.         mRoutes.addAll(source.mRoutes);
  18.         mHttpProxy = (source.mHttpProxy == null) ? null : new ProxyInfo(source.mHttpProxy);
  19.         for (LinkProperties l: source.mStackedLinks.values()) {
  20.             addStackedLink(l);
  21.         }
  22.         setMtu(source.mMtu);
  23.         setDhcpServerAddress(source.getDhcpServerAddress());
  24.         mTcpBufferSizes = source.mTcpBufferSizes;
  25.         mNat64Prefix = source.mNat64Prefix;
  26.         mWakeOnLanSupported = source.mWakeOnLanSupported;
  27.         mCaptivePortalApiUrl = source.mCaptivePortalApiUrl;
  28.         mCaptivePortalData = source.mCaptivePortalData;
  29.     }
  30. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/418184?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号