基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：813200300

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

package com.vn.py;

import android.annotation.TargetApi;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Handler;
import android.os.ResultReceiver;
import android.support.annotation.RequiresApi;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.RelativeLayout;
import android.widget.Toast;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "WifiAp8.0_MainActivity";
    private RelativeLayout mLayout;
    private Button mBtnStart,mBtnStop;

    private WifiManager mWifiManager;
    private ConnectivityManager mConnectivityManager;

    public static final int WIFI_AP_STATE_DISABLING = 10;
    public static final int WIFI_AP_STATE_DISABLED = 11;
    public static final int WIFI_AP_STATE_ENABLING = 12;
    public static final int WIFI_AP_STATE_ENABLED = 13;
    public static final String WIFI_AP_STATE_CHANGED_ACTION = "android.net.wifi.WIFI_AP_STATE_CHANGED";
    public static final String EXTRA_WIFI_AP_STATE = "wifi_state";
    private WifiApReceiver mReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mLayout = (RelativeLayout) findViewById(R.id.relative_layout);
        mBtnStart = (Button) findViewById(R.id.btn_start);
        mBtnStart.setOnClickListener(this);
        mBtnStop = (Button) findViewById(R.id.btn_stop);
        mBtnStop.setOnClickListener(this);

        mReceiver = new WifiApReceiver();
        IntentFilter filter = new IntentFilter(WIFI_AP_STATE_CHANGED_ACTION);
        registerReceiver(mReceiver, filter);
        mWifiManager = (WifiManager)getSystemService(Context.WIFI_SERVICE);
        mConnectivityManager = (ConnectivityManager)getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    public void setWifiApEnabledForAndroid(){
        ConnectivityManager connManager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        Field iConnMgrField;
        try{
            iConnMgrField = connManager.getClass().getDeclaredField("mService");
            iConnMgrField.setAccessible(true);
            Object iConnMgr = iConnMgrField.get(connManager);
            Class<?> iConnMgrClass = Class.forName(iConnMgr.getClass().getName());
            Method startTethering = iConnMgrClass.getMethod("startTethering",int.class, ResultReceiver.class,boolean.class);
            startTethering.invoke(iConnMgr,0,null,true);
            Toast.makeText(getApplicationContext(),"热点创建成功",Toast.LENGTH_SHORT).show();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    WifiConfiguration currentConfig;
    WifiManager.LocalOnlyHotspotReservation hotspotReservation;
    @RequiresApi(api = Build.VERSION_CODES.O)
    public void turnOnHotspot() {

        mWifiManager.startLocalOnlyHotspot(new WifiManager.LocalOnlyHotspotCallback() {

            @Override
            public void onStarted(WifiManager.LocalOnlyHotspotReservation reservation) {
                super.onStarted(reservation);
                hotspotReservation = reservation;
                currentConfig = hotspotReservation.getWifiConfiguration();

                Log.v("DANG", "THE PASSWORD IS: "
                          currentConfig.preSharedKey
                          " \n SSID is : "
                          currentConfig.SSID);

                hotspotDetaisDialog();

            }

            @Override
            public void onStopped() {
                super.onStopped();
                Log.v("DANG", "Local Hotspot Stopped");
            }

            @Override
            public void onFailed(int reason) {
                super.onFailed(reason);
                Log.v("DANG", "Local Hotspot failed to start");
            }
        }, new Handler());
    }
    private void hotspotDetaisDialog()
    {

        Log.v(TAG, "TEST"   " "   currentConfig.SSID   "\n"   "123456789"   " "   currentConfig.preSharedKey);

    }

    private void startTethering() {
        mConnectivityManager = (ConnectivityManager) getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (mWifiManager != null) {
            int wifiState = mWifiManager.getWifiState();
            boolean isWifiEnabled = ((wifiState == WifiManager.WIFI_STATE_ENABLED) || (wifiState == WifiManager.WIFI_STATE_ENABLING));
//            if (isWifiEnabled)
//                mWifiManager.setWifiEnabled(false);
//        }
            if (mConnectivityManager != null) {
                try {
                    Field internalConnectivityManagerField = ConnectivityManager.class.getDeclaredField("mService");
                    internalConnectivityManagerField.setAccessible(true);
                    WifiConfiguration apConfig = new WifiConfiguration();
                    apConfig.SSID = "cuieney";
                    apConfig.preSharedKey = "12121212";

                    StringBuffer sb = new StringBuffer();
                    Class internalConnectivityManagerClass = Class.forName("android.net.IConnectivityManager");
                    ResultReceiver dummyResultReceiver = new ResultReceiver(null);
                    try {

                        WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(WIFI_SERVICE);
                        Method mMethod = wifiManager.getClass().getMethod("setWifiApConfiguration", WifiConfiguration.class);
                        mMethod.invoke(wifiManager, apConfig);
                        Method startTetheringMethod = internalConnectivityManagerClass.getDeclaredMethod("startTethering", int.class,
                                ResultReceiver.class, boolean.class);

                        startTetheringMethod.invoke(internalConnectivityManagerClass,
                                0,
                                dummyResultReceiver,
                                true);
                    } catch (NoSuchMethodException e) {
                        Method startTetheringMethod = internalConnectivityManagerClass.getDeclaredMethod("startTethering",
                                int.class,
                                ResultReceiver.class,
                                boolean.class,
                                String.class);

                        startTetheringMethod.invoke(internalConnectivityManagerClass,
                                0,
                                dummyResultReceiver,
                                false,
                                getApplicationContext().getPackageName());
                    } catch (InvocationTargetException e) {
                        sb.append(11   (e.getMessage()));
                        e.printStackTrace();
                    } finally {
//                    log.setText(sb.toString());
                    }


                } catch (Exception e) {
                    Log.e("WifiApManager.startTethering", Log.getStackTraceString(e));
                }
            }
        }
    }

    public void setWifiApEnabledForAndroid_O(){
        ConnectivityManager connManager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        Field iConnMgrField;
        try{
            WifiConfiguration config = new WifiConfiguration();
            config.SSID = "TEST";
            config.preSharedKey= "123456789";
            iConnMgrField = connManager.getClass().getDeclaredField("mService");
            iConnMgrField.setAccessible(true);
            Object iConnMgr = iConnMgrField.get(connManager);
            Class<?> iConnMgrClass = Class.forName(iConnMgr.getClass().getName());
            Method startTethering = iConnMgrClass.getMethod("startTethering",int.class,ResultReceiver.class,boolean.class);
            startTethering.invoke(iConnMgr,0,null,true);
            Toast.makeText(getApplicationContext(),"热点创建成功",Toast.LENGTH_SHORT).show();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void setWifi(){
        WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        wifiManager.startLocalOnlyHotspot(new WifiManager.LocalOnlyHotspotCallback() {
            /*
            *这里是成功开启wifi后回调的方法，此处的reservation中可以通过.getWifiConfiguration().获取
            *到WifiConfiguration，同样的，在WifiConfiguration中可以获取到开启热点的SSID和preSharedKey，
            *此方法开启的热点的名称和密码是系统随机生产的，无法自定义名称和密码，至少我到目前为止
            没有找到可用于设置8.0名称和密码的方法哈哈哈。
            */
            @Override
            public void onStarted(WifiManager.LocalOnlyHotspotReservation reservation) {
                super.onStarted(reservation);
                String SSID = reservation.getWifiConfiguration().SSID;
                String preSharedKey = reservation.getWifiConfiguration().preSharedKey;
                Log.d(TAG, "onStarted: 11--11:"   SSID);
                Log.d(TAG, "onStarted: 22--22:"   preSharedKey);
            }

            @Override
            public void onStopped() {
                super.onStopped();
            }

            @Override
            public void onFailed(int reason) {
                super.onFailed(reason);
            }
        }, null);
    }

    private WifiManager wifiManager;

    public static void setWifiAp(Context context, boolean isEnable){
        ConnectivityManager connManager = (ConnectivityManager) context.getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        Field iConnMgrField = null;
        try {
            iConnMgrField = connManager.getClass().getDeclaredField("mService");
            iConnMgrField.setAccessible(true);
            Object iConnMgr = iConnMgrField.get(connManager);
            Class<?> iConnMgrClass = Class.forName(iConnMgr.getClass().getName());
            if(isEnable){
                Method startTethering = iConnMgrClass.getMethod("startTethering", int.class, ResultReceiver.class, boolean.class);
                startTethering.invoke(iConnMgr, 0, null, true);
            }else{
                Method startTethering = iConnMgrClass.getMethod("stopTethering", int.class);
                startTethering.invoke(iConnMgr, 0);
            }
        }
        catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn_start:
                if(getWifiAPState() != WIFI_AP_STATE_ENABLED){
                    if (Build.VERSION.SDK_INT >= 26) {
                        WifiConfiguration config = new WifiConfiguration();
                        wifiManager = (WifiManager)getApplicationContext().getSystemService(WIFI_SERVICE);
                        config.SSID = "TEST";//热点名称
                        config.preSharedKey = "123456789";//热点密码
//                        mConnectivityManager.startTethering(ConnectivityManager.TETHERING_WIFI,
//                                true, new ONStartTetheringCallback());
                        setWifiAp(this,true);
//                        wifiManager = (WifiManager)getApplicationContext().getSystemService(WIFI_SERVICE);
//                        Method method = wifiManager.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class,Boolean.TYPE);
//                        boolean enable = (Boolean)method.invoke(wifiManager,config,true);
                    }
                }
//                setWifiApEnabledForAndroid();
//                turnOnWifiAp("TEST","123456789",WifiSecurityType.WIFICIPHER_WPA2);
//                startTethering();
//                setWifi();

                break;
            case R.id.btn_stop:
                if(getWifiAPState() != WIFI_AP_STATE_DISABLED){
                    if (Build.VERSION.SDK_INT >= 26) {
                        mConnectivityManager.stopTethering(ConnectivityManager.TETHERING_WIFI);
                    }
                }
                break;
        }
    }

    class ONStartTetheringCallback extends
            ConnectivityManager.OnStartTetheringCallback {
    }


    private class WifiApReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i(TAG, "onReceive: "   intent.getAction());
            if (WIFI_AP_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                int cstate = intent.getIntExtra(EXTRA_WIFI_AP_STATE, -1);
                if (cstate == WIFI_AP_STATE_ENABLED) {
                    Snackbar.make(mLayout, "热点已开启", Snackbar.LENGTH_LONG).show();
                }else if (cstate == WIFI_AP_STATE_ENABLING){
                    Snackbar.make(mLayout, "热点正在开启", Snackbar.LENGTH_SHORT).show();
                }else if (cstate == WIFI_AP_STATE_DISABLED){
                    Snackbar.make(mLayout, "热点已关闭", Snackbar.LENGTH_LONG).show();
                }else if (cstate == WIFI_AP_STATE_DISABLING){
                    Snackbar.make(mLayout, "热点正在关闭", Snackbar.LENGTH_SHORT).show();
                }

            }
        }
    }

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

    public int getWifiAPState() {
        int state = -1;
        try {
            Method method2 = mWifiManager.getClass().getMethod("getWifiApState");
            state = (Integer) method2.invoke(mWifiManager);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Log.i(TAG, "getWifiAPState.state "   state);
        return state;
    }
/////////////////////////////////////
public final static boolean DEBUG = true;

    public static final int MESSAGE_AP_STATE_ENABLED = 1;
    public static final int MESSAGE_AP_STATE_FAILED = 2;
    //默认wifi秘密
    private static final String DEFAULT_AP_PASSWORD = "12345678";
    private static Handler mHandler;
    private static Context mContext;
    //监听wifi热点的状态变化
    public enum WifiSecurityType {
        WIFICIPHER_NOPASS, WIFICIPHER_WPA, WIFICIPHER_WPA2
    }

    public boolean turnOnWifiAp(String str, String password,WifiSecurityType Type) {
        String ssid = str;
        //配置热点信息。
        WifiConfiguration wcfg = new WifiConfiguration();
        wcfg.SSID = new String(ssid);
        wcfg.networkId = 1;
        wcfg.allowedAuthAlgorithms.clear();
        wcfg.allowedGroupCiphers.clear();
        wcfg.allowedKeyManagement.clear();
        wcfg.allowedPairwiseCiphers.clear();
        wcfg.allowedProtocols.clear();

        if(Type == WifiSecurityType.WIFICIPHER_NOPASS) {
            if(DEBUG)Log.d(TAG, "wifi ap----no password");
            wcfg.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN, true);
            wcfg.wepKeys[0] = "";
            wcfg.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            wcfg.wepTxKeyIndex = 0;
        } else if(Type == WifiSecurityType.WIFICIPHER_WPA) {
            if(DEBUG)Log.d(TAG, "wifi ap----wpa");
            //密码至少8位，否则使用默认密码
            if(null != password && password.length() >= 8){
                wcfg.preSharedKey = password;
            } else {
                wcfg.preSharedKey = DEFAULT_AP_PASSWORD;
            }
            wcfg.hiddenSSID = false;
            wcfg.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            wcfg.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            wcfg.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            //wcfg.allowedKeyManagement.set(4);
            wcfg.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            wcfg.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            wcfg.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            wcfg.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
        } else if(Type == WifiSecurityType.WIFICIPHER_WPA2) {
            if(DEBUG)Log.d(TAG, "wifi ap---- wpa2");
            //密码至少8位，否则使用默认密码
            if(null != password && password.length() >= 8){
                wcfg.preSharedKey = password;
            } else {
                wcfg.preSharedKey = DEFAULT_AP_PASSWORD;
            }
            wcfg.hiddenSSID = true;
            wcfg.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            wcfg.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            wcfg.allowedKeyManagement.set(4);
            //wcfg.allowedKeyManagement.set(4);
            wcfg.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            wcfg.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            wcfg.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            wcfg.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
        }
        try {
            Method method = mWifiManager.getClass().getMethod("setWifiApConfiguration",
                    wcfg.getClass());
            Boolean rt = (Boolean)method.invoke(mWifiManager, wcfg);
            if(DEBUG) Log.d(TAG, " rt = "   rt);
        } catch (NoSuchMethodException e) {
            Log.e(TAG, e.getMessage());
        } catch (IllegalArgumentException e) {
            Log.e(TAG, e.getMessage());
        } catch (IllegalAccessException e) {
            Log.e(TAG, e.getMessage());
        } catch (InvocationTargetException e) {
            Log.e(TAG, e.getMessage());
        }
        return setWifiApEnabled();
    }

    private boolean setWifiApEnabled() {
        //开启wifi热点需要关闭wifi
        while(mWifiManager.getWifiState() != WifiManager.WIFI_STATE_DISABLED){
            mWifiManager.setWifiEnabled(false);
            try {
                Thread.sleep(200);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
                return false;
            }
        }
        // 确保wifi 热点关闭。
        while(getWifiAPState() != WIFI_AP_STATE_DISABLED){
            try {
                Method method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",
                        WifiConfiguration.class, boolean.class);
                method1.invoke(mWifiManager, null, false);

                Thread.sleep(200);
            } catch (Exception e) {
                Log.e(TAG, e.getMessage());
                return false;
            }
        }

        //开启wifi热点
        try {
            Method method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",
                    WifiConfiguration.class, boolean.class);
            method1.invoke(mWifiManager, null, true);
            Thread.sleep(200);
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
            return false;
        }
        return true;
    }


}