Android盒子开发，获取网络的信息(热点，WIFI，有线)

Android盒子开发，网络信息的获取，比手机要困难许多。比如我们要获取网卡地址，IP地址，MAC等，有的系统没有直接接口
盒子的Launcher中需要接管便携式WIFI热点的开启，那么就需要获取SSID，为了保证我们Launcher中获取的SSID和系统一致。
说多了，都是泪啊。
热点的信息存放在/data/misc/wifi/hostapd.conf文件下，首先我想到的是使用IO流去读取，但是没有Root权限是无法读取的，于是乎想了一个更新坑爹的方法,自己修改该文件的权限，具体代码如下

**
 * @author xiongchengguang
 * @ClassName ReadConfig
 * @Descripton 读取WIFI热点的名字
 * @date 2016年2月29日下午3:16:23
 */
public class ReadConfig {
    private static final String TAG = "ReadConfig";

    public static String loadFileAsString() {
        getRootPermission();
        StringBuffer sb = new StringBuffer();
        String ssid ="";
        try {
            BufferedReader reader = new BufferedReader(new FileReader("/data/misc/wifi/hostapd.conf"));
            char[] buf = new char[8192];
            int len = 0;
            while ((len = reader.read(buf)) != -1) {
                String str = String.valueOf(buf, 0, len);
                sb.append(str);
            }
            reader.close();
            int index=sb.toString().indexOf("ssid")+5;
            int end=sb.toString().indexOf("channel");
            ssid=sb.toString().substring(index, end);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Log.d(TAG, ssid);
        return ssid;
    }


    /**
     * 修改系统文件权限
     */
    private static void getRootPermission(){
        Process process;
        DataOutputStream dataOutputStream;
        try {
            String cmd1="chmod 777 /data";
            String cmd2="chmod 777 /data/misc/";
            String cmd3="chmod 777 /data/misc/wifi/";
            String cmd4="chmod 777 /data/misc/wifi/hostapd.conf";
            process=Runtime.getRuntime().exec("su");
            dataOutputStream=new DataOutputStream(process.getOutputStream());
            dataOutputStream.writeBytes(cmd1+"\n");
            dataOutputStream.writeBytes(cmd2+"\n");
            dataOutputStream.writeBytes(cmd3+"\n");
            dataOutputStream.writeBytes(cmd4+"\n");
            dataOutputStream.writeBytes("exit\n");
            dataOutputStream.flush();
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

但是这样就会出现一个问题，有的时候能读取到，有的时候不行的。这样程序丢给用户有损我天朝的程序员的脸面啊
脑门一拍，把Setting的源码打开看看不就好了吗

那我们来看下别人具体实现，这不正是系统设置的UI布局吗上面一个TextVie用户，下面一个EditText输入框吗

那我们下面开始使用上面的id来全局搜索 (Ctrl+H ->wifi_ap_dialog)

/**
 * Dialog to configure the SSID and security settings
 * for Access Point operation
 */
public class WifiApDialog extends AlertDialog implements View.OnClickListener,
        TextWatcher, AdapterView.OnItemSelectedListener {

    static final int BUTTON_SUBMIT = DialogInterface.BUTTON_POSITIVE ;

    private final DialogInterface.OnClickListener mListener;

    public static final int OPEN_INDEX = 0;
    public static final int WPA_INDEX = 1;
    public static final int WPA2_INDEX = 2;

    private View mView;
    private TextView mSsid;
    private int mSecurityTypeIndex = OPEN_INDEX;
    private EditText mPassword;

    WifiConfiguration mWifiConfig;

    public WifiApDialog(Context context, DialogInterface.OnClickListener listener ,
            WifiConfiguration wifiConfig) {
        super(context);
        mListener = listener;
        mWifiConfig = wifiConfig;
        if (wifiConfig != null) {
            mSecurityTypeIndex = getSecurityTypeIndex(wifiConfig);
        }
    }



          .......省略


   @Override
    protected void onCreate(Bundle savedInstanceState) {

        mView = getLayoutInflater().inflate(R.layout.wifi_ap_dialog, null);
        Spinner mSecurity = ((Spinner) mView.findViewById(R.id. security));

        setView( mView);
        setInverseBackgroundForced( true);

        Context context = getContext();

        setTitle(R.string. wifi_tether_configure_ap_text);
        mView.findViewById(R.id. type).setVisibility(View. VISIBLE);
        mSsid = (TextView) mView.findViewById(R.id. ssid);
        mPassword = (EditText) mView.findViewById(R.id. password);

        setButton( BUTTON_SUBMIT, context.getString(R.string. wifi_save), mListener);
        setButton(DialogInterface. BUTTON_NEGATIVE,
        context.getString(R.string. wifi_cancel), mListener);

        if (mWifiConfig != null) {
            mSsid.setText( mWifiConfig. SSID);
            mSecurity.setSelection( mSecurityTypeIndex);
            if ( mSecurityTypeIndex == WPA_INDEX ||
                    mSecurityTypeIndex == WPA2_INDEX) {
                  mPassword.setText( mWifiConfig. preSharedKey);
            }
        }
      .......省略

布局中查找控件

mSsid = (TextView) mView.findViewById(R.id. ssid);

给控件赋值

 mSsid.setText( mWifiConfig. SSID);

看到了关键的地方 mWifiConfig 这玩意儿是啊，继续查找，终于在构造函数中找到了他，原来他是从别的地方传递过来的

public WifiApDialog(Context context, DialogInterface.OnClickListener listener ,
            WifiConfiguration wifiConfig) {

那我们继续找在什么地方调用了WifiApDialog这个类 还是Ctrl+H全局查找

    @Override
    public Dialog onCreateDialog( int id) {
        if (id == DIALOG_AP_SETTINGS) {
            final Activity activity = getActivity();
            mDialog = new  WifiApDialog(activity, this, mWifiConfig);
            return mDialog;
        }

        return null;
    }

找到了调用地方，那我们在看看mWifiConfig哪儿来的

 private void initWifiTethering() {
        final Activity activity = getActivity();
        mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE );
        mWifiConfig = mWifiManager.getWifiApConfiguration();

原来是从getWifiApConfiguration这个方法获取的getWifiApConfiguration实在WifiManager这个类中，继续查找

/**
     * Gets the Wi -Fi AP Configuration.
     * @return AP details in WifiConfiguration
     *
     * @hide Dont open yet
     */
    public WifiConfiguration getWifiApConfiguration() {
        try {
            return mService.getWifiApConfiguration();
        } catch (RemoteException e) {
            return null;
        }
    }

这可如何是好，这个方法是hide，上有政策，下有对策，高达上的技术出现了，反射来实现，具体代码如下

private String getNetworkSSID() {
        try {
            Method method = wm.getClass().getMethod("getWifiApConfiguration");
            method.setAccessible(true);
            WifiConfiguration configuration = (WifiConfiguration) method.invoke(wm);
            return configuration.SSID;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "net unknown";
    }

完美解决问题

获取其让信息都比较简单，有线的可能稍微复杂点。我直接贴出整个工具类的代码，骚年们，复制，粘贴吧 不谢

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;

import java.io.BufferedReader;
import java.io.FileReader;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author xiongchengguang
 * @ClassName NetorkUtils
 * @Descripton 网络工具类
 * @date 2016年5月16日上午11:21:08
 */
public class NetworkUtils {

    public static final int TYPE_AP = 0;
    public static final int TYPE_WIFI = 1;
    public static final int TYPE_NULL = -1;
    public static final int TYPE_ETHERNET = 9;

    public static final String NETWORK_TYPE = "network_type";
    public static final String NETWORK_IP = "network_ip";
    public static final String NETWORK_MAC = "network_mac";
    public static final String NETWORK_NAME = "network_name";

    private static WifiManager wm;
    private static ConnectivityManager cm;
    public static final String TAG = "NetorkUtils";
    private static NetworkUtils instance = null;
    private static Context context;

    public static NetworkUtils getInstance(Context context) {
        NetworkUtils.context = context;
        initPlatform();
        if (instance == null) {
            synchronized (NetworkUtils.class) {
                if (instance == null) {
                    instance = new NetworkUtils();
                }
            }
        }
        return instance;
    }

    private static void initPlatform() {
        if (wm == null) {
            wm = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        }

        if (cm == null) {
            cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        }
    }

    public int getNetworkType() {
        if (isWifiApEnabled()) {
            return TYPE_AP;
        } else {
            NetworkInfo info = cm.getActiveNetworkInfo();
            if (info !=null && info.isConnected()) {
                if (info.getType() == ConnectivityManager.TYPE_ETHERNET) {
                    return TYPE_ETHERNET;
                } else if (info.getType() == ConnectivityManager.TYPE_WIFI) {
                    return TYPE_WIFI;
                } else {
                    return TYPE_NULL;
                }
            } else {
                return TYPE_NULL;
            }
        }
    }

    public String getNetworkName() {
        String ssid = "net unknown";
        int type = getNetworkType();
        switch (type) {
        case TYPE_AP:
            ssid = getNetworkSSID();
            break;
        case TYPE_WIFI:
            ssid = wm.getConnectionInfo().getSSID();
            break;
        case TYPE_ETHERNET:
            ssid = "有线网络";
            break;
        case TYPE_NULL:
            ssid = "未知网络";
            break;

        default:
            break;
        }

        return ssid;
    }

    public String getNetworkIP(){
        String address="";
        int type = getNetworkType();
        switch (type) {
        case TYPE_AP:
            address="192.168.43.1";
            break;
        case TYPE_WIFI:
            int ip= wm.getConnectionInfo().getIpAddress();
            address=((ip & 0xff) + "."+ (ip >> 8 & 0xff) + "."+ (ip >> 16 & 0xff) + "." + (ip >> 24 & 0xff));
            break;
        case TYPE_ETHERNET:
            address=localAddress();
            break;
        case TYPE_NULL:
            break;

        default:
            break;
        }
        return address;
    }

    public String getNetworkMac(){
        String mac = "";
        int type = getNetworkType();
        switch (type) {
        case TYPE_AP:
            mac = wm.getConnectionInfo().getMacAddress();
            if (mac == null) {
                mac = UUID.randomUUID().toString();
            }
            break;
        case TYPE_WIFI:
            mac = wm.getConnectionInfo().getMacAddress();
            if (mac == null) {
                mac = UUID.randomUUID().toString();
            }
            break;
        case TYPE_ETHERNET:
            mac=localMac();
            break;
        case TYPE_NULL:
            break;

        default:
            break;
        }
        return mac.toUpperCase();
    }

    private String getNetworkSSID() {
        try {
            Method method = wm.getClass().getMethod("getWifiApConfiguration");
            method.setAccessible(true);
            WifiConfiguration configuration = (WifiConfiguration) method.invoke(wm);
            return configuration.SSID;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "net unknown";
    }

    public boolean isWifiApEnabled() {
        try {
            Method method = wm.getClass().getMethod("isWifiApEnabled");
            method.setAccessible(true);
            return (Boolean) method.invoke(wm);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public String loadReadFile(String path) {
        StringBuffer sb = new StringBuffer();
        try {
            BufferedReader reader = new BufferedReader(new FileReader(path));
            char[] buf = new char[8192];
            int len = 0;
            while ((len = reader.read(buf)) != -1) {
                String str = String.valueOf(buf, 0, len);
                sb.append(str);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    public String localAddress() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {
                NetworkInterface intf = en.nextElement();
                for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {
                    InetAddress inetAddress = enumIpAddr.nextElement();
                    Pattern p = Pattern.compile("^[1-9][0-9]*.[0-9][0-9]*.[0-9][0-9]*.[0-9][0-9]*$");
                    Matcher m = p.matcher(inetAddress.getHostAddress().toString());
                    if (!inetAddress.isLoopbackAddress() && m.matches()) {
                        return inetAddress.getHostAddress().toString();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public  String localMac() {
        try {
            return loadReadFile("/sys/class/net/eth0/address").toUpperCase().substring(0, 17);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public Map getAllNetworkInfo(){
        Map<String,Object> map=new HashMap<String, Object>();
        map.put(NETWORK_TYPE, getNetworkType());
        map.put(NETWORK_IP, getNetworkIP());
        map.put(NETWORK_MAC, getNetworkMac());
        map.put(NETWORK_NAME, getNetworkName());
        return map;
    }

    public void startAP(){
        if(wm.isWifiEnabled()){
            startAP(getNetworkSSID(), "12345678");
        }
    }

    private void startAP(String ssid, String password) {
        Method method1 = null;
        try {
            method1 = wm.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class, boolean.class);
            WifiConfiguration netConfig = new WifiConfiguration();

            netConfig.SSID = ssid;
            netConfig.preSharedKey = password;

            netConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            netConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            netConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            netConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            netConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            netConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            method1.invoke(wm, netConfig, true);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}