初始化：
    private static BroadcastReceiver batteryLevelRcvr;
    private static IntentFilter batteryLevelFilter;
    public static int batteryLevel = 0;
    public static int isChargingNum = 0;
    public static int WifiStrength = 0;
    public static int isWifiTraffic = 0;
1
2
3
4
5
6

在 onCreater 中使用：
monitorBatteryState();
1

编写代码：
    /**
     * 检查用户是用的 Wifi 还是 流量
     * */
    public static void isWifiOrTraffic() {
        ConnectivityManager cm;
        cm = (ConnectivityManager) instance
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        boolean isWifitrue = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
                .getState() == NetworkInfo.State.CONNECTED ? true : false;
        boolean isGprstrue = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
                .getState() == NetworkInfo.State.CONNECTED ? true : false;
        if (isWifitrue == true) {
            setWifiOrTraffic(4);
        }
        if (isGprstrue == true) {
            setWifiOrTraffic(5);
        }
    }

    public static void setWifiOrTraffic(int wifi) {
        isWifiTraffic = wifi;
    }

    public static int getWifiOrTraffic() {
        System.out
                .println("=====4-wifi 5-traffic =====JAVA getWifiOrTraffic() : "
                        + isWifiTraffic);
        return isWifiTraffic;
    }

    /**
     * Wifi的连接速度及信号强度
     * */
    public int obtainWifiInfo() {
        int strength = 0;
        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE); // 取得WifiManager对象
        WifiInfo info = wifiManager.getConnectionInfo(); // 取得WifiInfo对象
        if (info.getBSSID() != null) {
            strength = WifiManager.calculateSignalLevel(info.getRssi(), 5); // 链接信号强度，5为获取的信号强度值在5以内
            // int speed = info.getLinkSpeed(); // 链接速度
            // String units = WifiInfo.LINK_SPEED_UNITS; // 链接速度单位
            // String ssid = info.getSSID(); // Wifi源名称
        }
        return strength; // return info.toString();
    }

    public BroadcastReceiver rssiReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d("Rssi", "=====RSSI changed");
            setWifiStrength(obtainWifiInfo());
        }
    };

    public void setWifiStrength(int strength) {
        WifiStrength = strength;
    }

    public static int getWifiStrength() {
        System.out.println("=====JAVA getWifiStrength() : " + WifiStrength);
        return WifiStrength;
    }

    @Override
    public void onPause() {
        super.onPause();
        unregisterReceiver(rssiReceiver);
        Log.d("Rssi", "=====Unregistered");
    }

    /**
     * 1.获取手机电池电量 2.检查手机是否充电
     * */
    public static void monitorBatteryState() {
        isWifiOrTraffic();
        batteryLevelRcvr = new BroadcastReceiver() {
            public void onReceive(Context context, Intent intent) {
                int rawlevel = intent.getIntExtra("level", -1);
                int scale = intent.getIntExtra("scale", -1);
                int status = intent.getIntExtra("status", -1);
                int level = -1;
                if (rawlevel >= 0 && scale > 0) {
                    level = (rawlevel * 100) / scale;
                }
                setBatteryLevel(level);
                switch (status) {
                case BatteryManager.BATTERY_STATUS_CHARGING:
                    setIsCharging(1);
                    break;
                case BatteryManager.BATTERY_STATUS_FULL:
                    setIsCharging(2);
                    break;
                case BatteryManager.BATTERY_STATUS_NOT_CHARGING:
                    setIsCharging(3);
                    break;
                default:
                    break;
                }
            }
        };
        batteryLevelFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
        instance.registerReceiver(batteryLevelRcvr, batteryLevelFilter);
    }

    public static void setBatteryLevel(int level) {
        batteryLevel = level;
    }

    public static int getBatteryLever() {
        System.out.println("=====getBatteryLever() : " + batteryLevel);
        return batteryLevel;
    }

    public static void setIsCharging(int num) {
        isChargingNum = num;
    }

    public static int getIsCharging() {
        System.out
                .println("=====1-ing 2-full 3-no =====JAVA getIsCharging() : "
                        + isChargingNum);
        return isChargingNum;
    }

    protected void onResume() {
        super.onResume();
        if (isWxLogin) {
            Log.d(TAG, "====Login Success");
            loadWXUserInfo();
        }
        registerReceiver(rssiReceiver, new IntentFilter(
                WifiManager.RSSI_CHANGED_ACTION));
        Log.d("Rssi", "=====Registered");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(batteryLevelRcvr);
    }

因为业务需要，获取到手机主板的信号强度，包括WiFi，4G，2G。来验证当前主板模块是否是因为信号不好而导致问题，我去网上查询了几遍，将一些文章结合起来。最后获取到相关数据。以下是相关的操作步骤

 

1.加权限

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

2.实例化TelephonyManager，建立起PhoneStatListener监听（主要是带SIM卡的状态监听），再注册一个NetWorkBroadCastReceiver监听。

//获取telephonyManager
mTelephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
//开始监听
mListener = new PhoneStatListener();
mNetWorkBroadCastReciver = new NetWorkBroadCastReciver();
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
intentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
registerReceiver(mNetWorkBroadCastReciver, intentFilter);

 

mTelephonyManager.listen(mListener, PhoneStatListener.LISTEN_SIGNAL_STRENGTHS);

/**
 * 观察手机带SIM卡时的信号强度
 */
private class PhoneStatListener extends PhoneStateListener {
    //获取信号强度

    @Override
    public void onSignalStrengthsChanged(SignalStrength signalStrength) {
        super.onSignalStrengthsChanged(signalStrength);

        signal=signalStrength;
        //网络信号改变时，获取网络信息
        getNetWorkInfo();
    }
}

//接收网络状态改变的广播
class NetWorkBroadCastReciver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        getNetWorkInfo();
    }
}

  /**
     * 获取网络的信息
     */
    private void getNetWorkInfo() {
        ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = connectivityManager.getActiveNetworkInfo();
        if (info != null && info.isAvailable()) {
            switch (info.getType()) {
                case ConnectivityManager.TYPE_WIFI:
                    //wifi
                    WifiManager manager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
                    WifiInfo connectionInfo = manager.getConnectionInfo();
                    int rssi = connectionInfo.getRssi();
                    mTextView.setText("当前为wifi网络，信号强度=" + rssi);
                    break;
                case ConnectivityManager.TYPE_MOBILE:
                    //移动网络,可以通过TelephonyManager来获取具体细化的网络类型
                    String netWorkStatus = isFastMobileNetwork() ? "4G网络" : "2G网络";
                    if (isFastMobileNetwork()){
                        try {
                            if (signal==null){
                                Log.e("tiwolf", "getNetWorkInfo: signal为空" );
                                return;
                            }
                         
                            Method method=signal.getClass().getMethod("getDbm");
                            mGsmSignalStrength= (int) method.invoke(signal);
                            if(mGsmSignalStrength>-90){
                                Log.e("tiwolf", "getNetWorkInfo: 信号强度强" );
                            }else {
                                Log.e("tiwolf", "getNetWorkInfo: 信号强度弱" );
                            }
                        } catch (NoSuchMethodException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }

                    }else {
                        //获取网络信号强度
                        //获取0-4的5种信号级别，越大信号越好,但是api23开始才能用
//            int level = signalStrength.getLevel();
                        if (signal==null){
                            Log.e("tiwolf", "getNetWorkInfo: signal为空" );
                            return;
                        }
                        mGsmSignalStrength = signal.getGsmSignalStrength();
                    }
                    mTextView.setText("当前为" + netWorkStatus + "，信号强度=" + mGsmSignalStrength);
                    Log.e("tiwolf", "当前为" + netWorkStatus + "，信号强度=" + mGsmSignalStrength );
                    break;
            }
        } else {
            mTextView.setText("没有可用网络");
        }
    }

最后结束取消监听，取消注册

mTelephonyManager.listen(mListener, PhoneStatListener.LISTEN_NONE);

unregisterReceiver(mNetWorkBroadCastReciver);

 

大体的就是这样子，后面有文档上传到csdn，有需要的可以去下载

 

 

 

 

 

 

      前段时间在开发蓝牙功能，蓝牙功能开发结束之后最近又在开发WiFi功能。WiFi功能也算简单，主需要导入使用苹果系统自带的框架即可，仅仅单纯的获取手机当前连接的WiFi名称，或者获取手机系统显示的WiFi列表，那就so easy了。这里我介绍一下WiFi开发主要的步骤和流程，一些其他的使用细节不再一一阐述。
	苹果在iOS9.0以后提供了获取WiFi列表的API，但是需要开发人员主动发邮件给苹果，等待审核通过之后打开获取WiFi列表权限才能使用；但是在iOS9.0之前，只能获取到手机当前连接的WiFi名称等信息。

一、iOS9.0之前获取WiFi权限
1、导入头文件
        #import<SystemConfiguration/CaptiveNetwork.h>
2、获取手机当前连接的WiFi信息的方法
//获取手机当前连接WiFi信息
- (NSString *)getWifiName {
    NSString *wifiName = nil;
    CFArrayRef wifiInterfaces = CNCopySupportedInterfaces();
    if (!wifiInterfaces) {
        return @"未知";
    }
    NSArray *interfaces = (__bridge NSArray *)wifiInterfaces;
    for (NSString *interfaceName in interfaces) {
        CFDictionaryRef dictRef = CNCopyCurrentNetworkInfo((__bridge CFStringRef)(interfaceName));
        if (dictRef) {
            NSDictionary *networkInfo = (__bridge NSDictionary *)dictRef;
            wifiName = [networkInfo objectForKey:(__bridge NSString *)kCNNetworkInfoKeySSID];
            CFRelease(dictRef);
        }
    }
    CFRelease(wifiInterfaces);
    return wifiName;
}
3、直接使用第2步的方法，进一步操作

        比如，这里我直接获取使用WiFi的名字，然后赋值给UItextfield：self.networkTF.text = [self getWifiName];

二、iOS9.0之后获取WiFi权限
       iOS9.0之后获取WiFi权限需要以下几个主要步骤：
1、向 Apple 申请开发 Network Extension 权限；
       写封邮件给 networkextension@apple.com ，向苹果要开发 Network Extension 的权限。申请邮件内容如下所示，仅供参考：
	Hi, I am a personal developer on ios9, I am using xcode8.0 to develop app, AppleID:XXXXXXXXXX, I want to get SSID and BSSID and RSSI by scanning near WiFi, I hope to get the NetworkExtension permission, please approve!

	苹果收到邮件后会自动回复邮件，然后根据苹果回复的邮件提供的链接，打开连接根据选项逐一填写，然后提交之后14天左右就可以收到苹果的确认回复邮件。
2、申请包含 Network Extension 的描述文件；

     申请获取WiFi权限通过之后，需要进入开发者账号里面配置创建Network Extension的描述文件，配置成功之后点击下载，下载完成双击打开描述文件。
3、配置 Info.plist；

     打开项目，在Xcode的Info.plist中Required background modes 添加一个 network-authentication(item)
4、配置 entitlements；

     在Xcode的Info.plist中Entitlements File下添加一个键值对: com.apple.developer.networking.HotspotHelper -> YES
5、iOS 获取 Wifi 列表代码实现；
     导入头文件：
     #import <NetworkExtension/NetworkExtension.h>  

      //实现部分
- (void)getWifiList {
	if (![[[UIDevice currentDevice] systemVersion] floatValue] >= 9.0) {return;}
	dispatch_queue_t queue = dispatch_queue_create("com.leopardpan.HotspotHelper", 0);
	[NEHotspotHelper registerWithOptions:nil queue:queue handler: ^(NEHotspotHelperCommand * cmd) {
		//kNEHotspotHelperCommandTypeFilterScanList：表示扫描到 Wifi 列表信息。
		if(cmd.commandType == kNEHotspotHelperCommandTypeFilterScanList) {
			//NEHotspotNetwork 里有如下信息：SSID：Wifi 名称；BSSID：站点的 MAC 地址；signalStrength： Wifi信号强度，该值在0.0-1.0之间；secure：网络是否安全 (不需要密码的 Wifi，该值为 false)；autoJoined： 设备是否自动连接该 Wifi，目前测试自动连接以前连过的 Wifi 的也为 false ；justJoined：网络是否刚刚加入；chosenHelper：HotspotHelper是否为网络的所选助手
			for (NEHotspotNetwork* network  in cmd.networkList) {
				NSLog(@“+++++%@“,network.SSID);
			}
		}
	}];
}

6、获取Wifi列表回调

	以上的五个步骤操作之后，运行项目，会发现没有WiFi列表的回调，那是因为没有刷新WiFi列表，这时候就需要你手动打开手机系统设置—>WLAN—>系统WiFi列表加载出来的时候，上面的代码才会执行回调，才获取到WiFi列表。

三、代理方法
#pragma mark —Register a Hotspot Helper—

+ (BOOL)registerWithOptions:(NSDictionary*)options queue:(dispatch_queue_t)queue handler:(NEHotspotHelperHandler)handler

@param options

kNEHotspotHelperOptionDisplayName ：WIFI注释tag字符串// 这里设置的内容将会在WiFi列表中每个WiFi下边展示

@param queue dispatch_queue_t 		用来调用handle的block
@param handler NEHotspotHelperHandler block 		用于执行处理helper commands.

@return 		注册成功为YES, 否则NO.
@discussion 	这个API一旦调用成功，应用程序有资格在后台启动，并参与各种热点相关的功能。 当应用程序启动此方法，应该调用一次，再次调用它，就不会产生影响，并且返回NO。

#pragma mark —Manage Hotspot Networks—

+ (BOOL)logoff:(NEHotspotNetwork *)network

@param network 		对应当前关联的WiFi网络NEHotspotNetwork

@return 		注销命令已成功进入队列为YES, 否则NO.
@discussion 		调用这个方法使kNEHotspotHelperCommandTypeLogoff型的NEHotspotHelperCommand向应用程序发出的“handler”模块，网络参数须符合当前关联的WiFi网络，必须来自对NEHotspotHelperCommand网络属性或者方法supportedInterfaces

+ (NSArray *)supportedNetworkInterfaces

@return 		如果没有网络接口被管理就返回nil，否则就返回NEHotspotNetwork对象数组。
@discussion 		每个网络接口由NEHotspotNetwork对象表示，当前返回的数组包含一个NEHotspotNetwork对象，代表Wi-Fi接口。

四、具体实现调用的方法，获取wifi列表，并给指定ssid做标记
- (void)getWifiList {
    NSMutableDictionary* options = [[NSMutableDictionary alloc] init];
    [options setObject:@“上网” forKey:kNEHotspotHelperOptionDisplayName];
    dispatch_queue_t queue = dispatch_queue_create("com.myapp.ex", NULL);
    BOOL returnType = [NEHotspotHelper registerWithOptions:options queue:queue handler: ^(NEHotspotHelperCommand * cmd) {
        NEHotspotNetwork* network;
        NSLog(@"COMMAND TYPE:   %ld", (long)cmd.commandType);
        [cmd createResponse:kNEHotspotHelperResultAuthenticationRequired];
        if (cmd.commandType == kNEHotspotHelperCommandTypeEvaluate || cmd.commandType ==kNEHotspotHelperCommandTypeFilterScanList) {
            NSLog(@"WIFILIST:   %@", cmd.networkList);
            for (network  in cmd.networkList) {
                //NSLog(@"COMMAND TYPE After:   %ld", (long)cmd.commandType);
                if ([network.SSID isEqualToString:@"ssid"]|| [network.SSID isEqualToString:@"test"]) {
                    double signalStrength = network.signalStrength;
                    NSLog(@"Signal Strength: %f", signalStrength);
                    [network setConfidence:kNEHotspotHelperConfidenceHigh];
                    [network setPassword:@"password"];
                    NEHotspotHelperResponse *response = [cmd createResponse:kNEHotspotHelperResultSuccess];
                    NSLog(@"Response CMD %@", response);
                    [response setNetworkList:@[network]];
                    [response setNetwork:network];
                    [response deliver];
                }
            }
        }
    }];
    NSLog(@"result :%d", returnType);
    NSArray *array = [NEHotspotHelper supportedNetworkInterfaces];
    NSLog(@"wifiArray:%@", array);
    NEHotspotNetwork *connectedNetwork = [array lastObject];
    NSLog(@"supported Network Interface: %@", connectedNetwork);
}


        以上就是本节的全部内容，欢迎关注山掌柜的微信公众号，更多精彩等你来！

1、获得WifiManager对象
WifiManager wm = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);

2、通过WifiManager对象获得wifi信息
WifiInfo info = wm.getConnectionInfo();

3、通过WifiInfo获得wifi信息
//通过wifi管理对象获得wifi信息
                        WifiInfo info = wm.getConnectionInfo();
                        //获取wifi名称
                        String ssid = info.getSSID().replace("\"", "");
                        //获取mac地址
                        String MacAddr = info.getMacAddress();
                        //获取当前连接速度
                        int linkSpeed = info.getLinkSpeed();
                        //获取ip地址
                        int ipAddr = info.getIpAddress();
                        ......

xml代码
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="20dp"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="SSID:"
        android:textColor="@android:color/black"
        android:textSize="30sp" />

    <TextView
        android:id="@+id/wifiSSID"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/textView1"
        android:text="-"
        android:textColor="@android:color/black"
        android:textSize="30sp" />

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="信号强度"
        android:layout_below="@id/textView1"
        android:textColor="@android:color/black"
        android:textSize="30sp" />

    <ImageView
        android:id="@+id/ivWifi"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/textView2"
        android:background="@drawable/wifi1"/>

</RelativeLayout>

主函数代码
import android.app.Activity;
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity {

    private WifiManager wm;
    private TextView wifiSSID;
    private ImageView ivWifi;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        initWifi();
    }

    private void initView() {
        wifiSSID = findViewById(R.id.wifiSSID);
        ivWifi = findViewById(R.id.ivWifi);
    }

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    wifiSSID.setText(msg.obj.toString());
                    if (msg.arg1 <= 50) {
                        ivWifi.setBackgroundResource(R.drawable.wifi4);
                    } else if (msg.arg1 <= 70) {
                        ivWifi.setBackgroundResource(R.drawable.wifi3);
                    } else if (msg.arg1 <= 100) {
                        ivWifi.setBackgroundResource(R.drawable.wifi2);
                    }
                    break;
                case 2:
                    wifiSSID.setText("-");
                    ivWifi.setBackgroundResource(R.drawable.wifi1);
                    break;
            }
        }
    };

    private void initWifi() {
        Thread thread = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //拿到wifi管理对象
                    wm = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
                    if (wm.isWifiEnabled()) {
                        //通过wifi管理对象获得wifi信息
                        WifiInfo info = wm.getConnectionInfo();
                        //获取wifi名称
                        String ssid = info.getSSID().replace("\"", "");
                        //获取mac地址
                        String MacAddr = info.getMacAddress();
                        //获取当前连接速度
                        int linkSpeed = info.getLinkSpeed();
                        //获取ip地址
                        int ipAddr = info.getIpAddress();

                        Message msg = Message.obtain();
                        msg.what = 1;
                        msg.obj = ssid;
                        /**
                        *	getRssi()返回的是一个-100到0的数，直接取绝对值
                        *	-50到0表示信号好
                        *	-50到-70表示信号一般
                        *	-70到-100表示信号差
                        */
                        msg.arg1 = Math.abs(info.getRssi());
                        handler.sendMessage(msg);
                    } else {
                        Message msg = Message.obtain();
                        msg.what = 2;
                        handler.sendMessage(msg);
                    }
                }
            }
        };
        thread.start();
    }


}


最后给权限
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>