Android WIFI模块解析

2022-05-24 06:33:27

Android中的AP扫描结果，通过WifiNative的JNI调用，实际调用wpa_supplicant的相应命令，并返回字符串给JNI方法，下面是对该字符串的解析函数： 

Java代码  Android WIFI模块解析
  1. private static final Pattern scanResultPattern = Pattern.compile("\t+");  
  2. /** 
  3.      * Parse the scan result line passed to us by wpa_supplicant (helper). 
  4.      * @param line the line to parse 
  5.      * @return the {@link ScanResult} object 
  6.      */  
  7.     private ScanResult parseScanResult(String line) {  
  8.         ScanResult scanResult = null;  
  9.         if (line != null) {  
  10.             /* 
  11.              * Cache implementation (LinkedHashMap) is not synchronized, thus, 
  12.              * must synchronized here! 
  13.              */  
  14.             synchronized (mScanResultCache) {  
  15.                 String[] result = scanResultPattern.split(line);  
  16.                 if (3 <= result.length && result.length <= 5) {  
  17.                     String bssid = result[0];  
  18.                     // bssid | frequency | level | flags | ssid  
  19.                     int frequency;  
  20.                     int level;  
  21.                     try {  
  22.                         frequency = Integer.parseInt(result[1]);  
  23.                         level = Integer.parseInt(result[2]);  
  24.                         /* some implementations avoid negative values by adding 256 
  25.                          * so we need to adjust for that here. 
  26.                          */  
  27.                         if (level > 0) level -= 256;  
  28.                     } catch (NumberFormatException e) {  
  29.                         frequency = 0;  
  30.                         level = 0;  
  31.                     }  
  32.   
  33.                     /* 
  34.                      * The formatting of the results returned by 
  35.                      * wpa_supplicant is intended to make the fields 
  36.                      * line up nicely when printed, 
  37.                      * not to make them easy to parse. So we have to 
  38.                      * apply some heuristics to figure out which field 
  39.                      * is the SSID and which field is the flags. 
  40.                      */  
  41.                     String ssid;  
  42.                     String flags;  
  43.                     if (result.length == 4) {  
  44.                         if (result[3].charAt(0) == '[') {  
  45.                             flags = result[3];  
  46.                             ssid = "";  
  47.                         } else {  
  48.                             flags = "";  
  49.                             ssid = result[3];  
  50.                         }  
  51.                     } else if (result.length == 5) {  
  52.                         flags = result[3];  
  53.                         ssid = result[4];  
  54.                     } else {  
  55.                         // Here, we must have 3 fields: no flags and ssid  
  56.                         // set  
  57.                         flags = "";  
  58.                         ssid = "";  
  59.                     }  
  60.   
  61.                     // bssid + ssid is the hash key  
  62.                     String key = bssid + ssid;  
  63.                     scanResult = mScanResultCache.get(key);  
  64.                     if (scanResult != null) {  
  65.                         scanResult.level = level;  
  66.                         scanResult.SSID = ssid;  
  67.                         scanResult.capabilities = flags;  
  68.                         scanResult.frequency = frequency;  
  69.                     } else {  
  70.                         // Do not add scan results that have no SSID set  
  71.                         if (0 < ssid.trim().length()) {  
  72.                             scanResult =  
  73.                                 new ScanResult(  
  74.                                     ssid, bssid, flags, level, frequency);  
  75.                             mScanResultCache.put(key, scanResult);  
  76.                         }  
  77.                     }  
  78.                 } else {  
  79.                     Slog.w(TAG, "Misformatted scan result text with " +  
  80.                           result.length + " fields: " + line);  
  81.                 }  
  82.             }  
  83.         }  
  84.   
  85.         return scanResult;  
  86.     }  


WIFI添加一个网络配置，返回生成的网络ID 
Java代码  Android WIFI模块解析
  1. /** 
  2.      * see {@link android.net.wifi.WifiManager#addOrUpdateNetwork(WifiConfiguration)} 
  3.      * @return the supplicant-assigned identifier for the new or updated 
  4.      * network if the operation succeeds, or {@code -1} if it fails 
  5.      */  
  6.     public int addOrUpdateNetwork(WifiConfiguration config) {  
  7.         enforceChangePermission();  
  8.   
  9.         /* 
  10.          * If the supplied networkId is -1, we create a new empty 
  11.          * network configuration. Otherwise, the networkId should 
  12.          * refer to an existing configuration. 
  13.          */  
  14.         int netId = config.networkId;  
  15.         boolean newNetwork = netId == -1;  
  16.         boolean doReconfig = false;  
  17.         // networkId of -1 means we want to create a new network  
  18.         synchronized (mWifiStateTracker) {  
  19.             if (newNetwork) {  
  20.                 netId = mWifiStateTracker.addNetwork();  
  21.                 if (netId < 0) {  
  22.                     if (DBG) {  
  23.                         Slog.d(TAG, "Failed to add a network!");  
  24.                     }  
  25.                     return -1;  
  26.                 }  
  27.                 doReconfig = true;  
  28.             }  
  29.             mNeedReconfig = mNeedReconfig || doReconfig;  
  30.         }  
  31.   
  32.         setVariables: {  
  33.             /* 
  34.              * Note that if a networkId for a non-existent network 
  35.              * was supplied, then the first setNetworkVariable() 
  36.              * will fail, so we don't bother to make a separate check 
  37.              * for the validity of the ID up front. 
  38.              */  
  39.             if (config.SSID != null &&  
  40.                     !mWifiStateTracker.setNetworkVariable(  
  41.                         netId,  
  42.                         WifiConfiguration.ssidVarName,  
  43.                         config.SSID)) {  
  44.                 if (DBG) {  
  45.                     Slog.d(TAG, "failed to set SSID: "+config.SSID);  
  46.                 }  
  47.                 break setVariables;  
  48.             }  
  49.   
  50.             if (config.BSSID != null &&  
  51.                     !mWifiStateTracker.setNetworkVariable(  
  52.                         netId,  
  53.                         WifiConfiguration.bssidVarName,  
  54.                         config.BSSID)) {  
  55.                 if (DBG) {  
  56.                     Slog.d(TAG, "failed to set BSSID: "+config.BSSID);  
  57.                 }  
  58.                 break setVariables;  
  59.             }  
  60.   
  61.             String allowedKeyManagementString =  
  62.                 makeString(config.allowedKeyManagement, WifiConfiguration.KeyMgmt.strings);  
  63.             if (config.allowedKeyManagement.cardinality() != 0 &&  
  64.                     !mWifiStateTracker.setNetworkVariable(  
  65.                         netId,  
  66.                         WifiConfiguration.KeyMgmt.varName,  
  67.                         allowedKeyManagementString)) {  
  68.                 if (DBG) {  
  69.                     Slog.d(TAG, "failed to set key_mgmt: "+  
  70.                             allowedKeyManagementString);  
  71.                 }  
  72.                 break setVariables;  
  73.             }  
  74.   
  75.             String allowedProtocolsString =  
  76.                 makeString(config.allowedProtocols, WifiConfiguration.Protocol.strings);  
  77.             if (config.allowedProtocols.cardinality() != 0 &&  
  78.                     !mWifiStateTracker.setNetworkVariable(  
  79.                         netId,  
  80.                         WifiConfiguration.Protocol.varName,  
  81.                         allowedProtocolsString)) {  
  82.                 if (DBG) {  
  83.                     Slog.d(TAG, "failed to set proto: "+  
  84.                             allowedProtocolsString);  
  85.                 }  
  86.                 break setVariables;  
  87.             }  
  88.   
  89.             String allowedAuthAlgorithmsString =  
  90.                 makeString(config.allowedAuthAlgorithms, WifiConfiguration.AuthAlgorithm.strings);  
  91.             if (config.allowedAuthAlgorithms.cardinality() != 0 &&  
  92.                     !mWifiStateTracker.setNetworkVariable(  
  93.                         netId,  
  94.                         WifiConfiguration.AuthAlgorithm.varName,  
  95.                         allowedAuthAlgorithmsString)) {  
  96.                 if (DBG) {  
  97.                     Slog.d(TAG, "failed to set auth_alg: "+  
  98.                             allowedAuthAlgorithmsString);  
  99.                 }  
  100.                 break setVariables;  
  101.             }  
  102.   
  103.             String allowedPairwiseCiphersString =  
  104.                 makeString(config.allowedPairwiseCiphers, WifiConfiguration.PairwiseCipher.strings);  
  105.             if (config.allowedPairwiseCiphers.cardinality() != 0 &&  
  106.                     !mWifiStateTracker.setNetworkVariable(  
  107.                         netId,  
  108.                         WifiConfiguration.PairwiseCipher.varName,  
  109.                         allowedPairwiseCiphersString)) {  
  110.                 if (DBG) {  
  111.                     Slog.d(TAG, "failed to set pairwise: "+  
  112.                             allowedPairwiseCiphersString);  
  113.                 }  
  114.                 break setVariables;  
  115.             }  
  116.   
  117.             String allowedGroupCiphersString =  
  118.                 makeString(config.allowedGroupCiphers, WifiConfiguration.GroupCipher.strings);  
  119.             if (config.allowedGroupCiphers.cardinality() != 0 &&  
  120.                     !mWifiStateTracker.setNetworkVariable(  
  121.                         netId,  
  122.                         WifiConfiguration.GroupCipher.varName,  
  123.                         allowedGroupCiphersString)) {  
  124.                 if (DBG) {  
  125.                     Slog.d(TAG, "failed to set group: "+  
  126.                             allowedGroupCiphersString);  
  127.                 }  
  128.                 break setVariables;  
  129.             }  
  130.   
  131.             // Prevent client screw-up by passing in a WifiConfiguration we gave it  
  132.             // by preventing "*" as a key.  
  133.             if (config.preSharedKey != null && !config.preSharedKey.equals("*") &&  
  134.                     !mWifiStateTracker.setNetworkVariable(  
  135.                         netId,  
  136.                         WifiConfiguration.pskVarName,  
  137.                         config.preSharedKey)) {  
  138.                 if (DBG) {  
  139.                     Slog.d(TAG, "failed to set psk: "+config.preSharedKey);  
  140.                 }  
  141.                 break setVariables;  
  142.             }  
  143.   
  144.             boolean hasSetKey = false;  
  145.             if (config.wepKeys != null) {  
  146.                 for (int i = 0; i < config.wepKeys.length; i++) {  
  147.                     // Prevent client screw-up by passing in a WifiConfiguration we gave it  
  148.                     // by preventing "*" as a key.  
  149.                     if (config.wepKeys[i] != null && !config.wepKeys[i].equals("*")) {  
  150.                         if (!mWifiStateTracker.setNetworkVariable(  
  151.                                     netId,  
  152.                                     WifiConfiguration.wepKeyVarNames[i],  
  153.                                     config.wepKeys[i])) {  
  154.                             if (DBG) {  
  155.                                 Slog.d(TAG,  
  156.                                         "failed to set wep_key"+i+": " +  
  157.                                         config.wepKeys[i]);  
  158.                             }  
  159.                             break setVariables;  
  160.                         }  
  161.                         hasSetKey = true;  
  162.                     }  
  163.                 }  
  164.             }  
  165.   
  166.             if (hasSetKey) {  
  167.                 if (!mWifiStateTracker.setNetworkVariable(  
  168.                             netId,  
  169.                             WifiConfiguration.wepTxKeyIdxVarName,  
  170.                             Integer.toString(config.wepTxKeyIndex))) {  
  171.                     if (DBG) {  
  172.                         Slog.d(TAG,  
  173.                                 "failed to set wep_tx_keyidx: "+  
  174.                                 config.wepTxKeyIndex);  
  175.                     }  
  176.                     break setVariables;  
  177.                 }  
  178.             }  
  179.   
  180.             if (!mWifiStateTracker.setNetworkVariable(  
  181.                         netId,  
  182.                         WifiConfiguration.priorityVarName,  
  183.                         Integer.toString(config.priority))) {  
  184.                 if (DBG) {  
  185.                     Slog.d(TAG, config.SSID + ": failed to set priority: "  
  186.                             +config.priority);  
  187.                 }  
  188.                 break setVariables;  
  189.             }  
  190.   
  191.             if (config.hiddenSSID && !mWifiStateTracker.setNetworkVariable(  
  192.                         netId,  
  193.                         WifiConfiguration.hiddenSSIDVarName,  
  194.                         Integer.toString(config.hiddenSSID ? 1 : 0))) {  
  195.                 if (DBG) {  
  196.                     Slog.d(TAG, config.SSID + ": failed to set hiddenSSID: "+  
  197.                             config.hiddenSSID);  
  198.                 }  
  199.                 break setVariables;  
  200.             }  
  201.   
  202.             for (WifiConfiguration.EnterpriseField field  
  203.                     : config.enterpriseFields) {  
  204.                 String varName = field.varName();  
  205.                 String value = field.value();  
  206.                 if (value != null) {  
  207.                     if (field != config.eap) {  
  208.                         value = (value.length() == 0) ? "NULL" : convertToQuotedString(value);  
  209.                     }  
  210.                     if (!mWifiStateTracker.setNetworkVariable(  
  211.                                 netId,  
  212.                                 varName,  
  213.                                 value)) {  
  214.                         if (DBG) {  
  215.                             Slog.d(TAG, config.SSID + ": failed to set " + varName +  
  216.                                     ": " + value);  
  217.                         }  
  218.                         break setVariables;  
  219.                     }  
  220.                 }  
  221.             }  
  222.             return netId;  
  223.         }  


认证类型管理类： 

Java代码  Android WIFI模块解析
  1. /** 
  2.      * Recognized key management schemes. 
  3.      */  
  4.     public static class KeyMgmt {  
  5.         private KeyMgmt() { }  
  6.   
  7.         /** WPA is not used; plaintext or static WEP could be used. */  
  8.         public static final int NONE = 0;  
  9.         /** WPA pre-shared key (requires {@code preSharedKey} to be specified). */  
  10.         public static final int WPA_PSK = 1;  
  11.         /** WPA using EAP authentication. Generally used with an external authentication server. */  
  12.         public static final int WPA_EAP = 2;  
  13.         /** IEEE 802.1X using EAP authentication and (optionally) dynamically 
  14.          * generated WEP keys. */  
  15.         public static final int IEEE8021X = 3;  
  16.   
  17.         public static final String varName = "key_mgmt";  
  18.   
  19.         public static final String[] strings = { "NONE", "WPA_PSK", "WPA_EAP", "IEEE8021X" };  
  20.     }  
上一篇：C++ 为什么不加入垃圾回收机制


下一篇：Pandas之八Reshaping（二）