Java 如何在后台设置android热点活动？

我正在开发一个应用程序，当点击按钮时，它将打开/关闭热点

如果我用应用程序打开热点，当我打开另一个应用程序或收到任何通知时，热点将自动关闭

我的代码：

public class WifiAP extends Activity {
private static int constant = 0;

private static final int WIFI_AP_STATE_UNKNOWN = -1;
private static int WIFI_AP_STATE_DISABLING = 0;
private static int WIFI_AP_STATE_DISABLED = 1;
public int WIFI_AP_STATE_ENABLING = 2;
public int WIFI_AP_STATE_ENABLED = 3;
private static int WIFI_AP_STATE_FAILED = 4;

private final String[] WIFI_STATE_TEXTSTATE = new String[] {
        "DISABLING","DISABLED","ENABLING","ENABLED","FAILED"
};

private WifiManager wifi;
private String TAG = "WifiAP";

private int stateWifiWasIn = -1;

private boolean alwaysEnableWifi = true; //set to false if you want to try and set wifi state back to what it was before wifi ap enabling, true will result in the wifi always being enabled after wifi ap is disabled

/**
 * Toggle the WiFi AP state
 * @param wifihandler
 */
public void toggleWiFiAP(WifiManager wifihandler, Context context) {
    if (wifi==null){
        wifi = wifihandler;
    }

    boolean wifiApIsOn = getWifiAPState()==WIFI_AP_STATE_ENABLED || getWifiAPState()==WIFI_AP_STATE_ENABLING;
    new SetWifiAPTask(!wifiApIsOn,false,context).execute();
}

private int setWifiApEnabled(boolean enabled) {
    Log.d(TAG, "*** setWifiApEnabled CALLED **** " + enabled);

    WifiConfiguration config = new WifiConfiguration();
    config.SSID = "Aqual soul";
    config.preSharedKey="aquasoul";
    config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
    config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
    config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
    config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);

    //remember wirelesses current state
    if (enabled && stateWifiWasIn==-1){
        stateWifiWasIn=wifi.getWifiState();
    }

/*    //disable wireless
    if (enabled && wifi.getConnectionInfo() !=null) {
        Log.d(TAG, "disable wifi: calling");
        wifi.setWifiEnabled(false);
        int loopMax = 10;
        while(loopMax>0 && wifi.getWifiState()!=WifiManager.WIFI_STATE_DISABLED){
            Log.d(TAG, "disable wifi: waiting, pass: " + (10-loopMax));
            try {
                Thread.sleep(500);
                loopMax--;
            } catch (Exception e) {

            }
        }
        Log.d(TAG, "disable wifi: done, pass: " + (10-loopMax));
    }
*/
    //enable/disable wifi ap
    int state = WIFI_AP_STATE_UNKNOWN;
    try {
        Log.d(TAG, (enabled?"enabling":"disabling") +" wifi ap: calling");
        wifi.setWifiEnabled(false);
        Method method1 = wifi.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
        //method1.invoke(wifi, null, enabled); // true
        method1.invoke(wifi, config, enabled); // true
        Method method2 = wifi.getClass().getMethod("getWifiApState");
        state = (Integer) method2.invoke(wifi);
    } catch (Exception e) {
        Log.e(WIFI_SERVICE, e.getMessage());
        // toastText += "ERROR " + e.getMessage();
    }


    //hold thread up while processing occurs
    if (!enabled) {
        int loopMax = 10;
        while (loopMax>0 && (getWifiAPState()==WIFI_AP_STATE_DISABLING || getWifiAPState()==WIFI_AP_STATE_ENABLED || getWifiAPState()==WIFI_AP_STATE_FAILED)) {
            Log.d(TAG, (enabled?"enabling":"disabling") +" wifi ap: waiting, pass: " + (10-loopMax));
            try {
                Thread.sleep(500);
                loopMax--;
            } catch (Exception e) {

            }
        }
        Log.d(TAG, (enabled?"enabling":"disabling") +" wifi ap: done, pass: " + (10-loopMax));

        //enable wifi if it was enabled beforehand
        //this is somewhat unreliable and app gets confused and doesn't turn it back on sometimes so added toggle to always enable if you desire
        if(stateWifiWasIn==WifiManager.WIFI_STATE_ENABLED || stateWifiWasIn==WifiManager.WIFI_STATE_ENABLING || stateWifiWasIn==WifiManager.WIFI_STATE_UNKNOWN || alwaysEnableWifi){
            Log.d(TAG, "enable wifi: calling");
            wifi.setWifiEnabled(true);
            //don't hold things up and wait for it to get enabled
        }

        stateWifiWasIn = -1;
    } else if (enabled) {
        int loopMax = 10;
        while (loopMax>0 && (getWifiAPState()==WIFI_AP_STATE_ENABLING || getWifiAPState()==WIFI_AP_STATE_DISABLED || getWifiAPState()==WIFI_AP_STATE_FAILED)) {
            Log.d(TAG, (enabled?"enabling":"disabling") +" wifi ap: waiting, pass: " + (10-loopMax));
            try {
                Thread.sleep(500);
                loopMax--;
            } catch (Exception e) {

            }
        }
        Log.d(TAG, (enabled?"enabling":"disabling") +" wifi ap: done, pass: " + (10-loopMax));
    }

    return state;
}

public int getWifiAPState() {
    int state = WIFI_AP_STATE_UNKNOWN;
    try {
        Method method2 = wifi.getClass().getMethod("getWifiApState");
        state = (Integer) method2.invoke(wifi);
    } catch (Exception e) {

    }

    if(state>=10){
        //using Android 4.0+ (or maybe 3+, haven't had a 3 device to test it on) so use states that are +10
        constant=10;
    }

    //reset these in case was newer device
    WIFI_AP_STATE_DISABLING = 0+constant;
    WIFI_AP_STATE_DISABLED = 1+constant;
    WIFI_AP_STATE_ENABLING = 2+constant;
    WIFI_AP_STATE_ENABLED = 3+constant;
    WIFI_AP_STATE_FAILED = 4+constant;

    Log.d(TAG, "getWifiAPState.state " + (state==-1?"UNKNOWN":WIFI_STATE_TEXTSTATE[state-constant]));
    return state;
}

class SetWifiAPTask extends AsyncTask<Void, Void, Void> {
    boolean mMode; //enable or disable wifi AP
    boolean mFinish; //finalize or not (e.g. on exit)
    ProgressDialog d;

    public SetWifiAPTask(boolean mode, boolean finish, Context context) {
        mMode = mode;
        mFinish = finish;
        d = new ProgressDialog(context);
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        d.setTitle("Turning WiFi AP " + (mMode?"on":"off") + "...");
        d.setMessage("...please wait a moment.");
        d.show();
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
        try {
            d.dismiss();
            MainActivity.updateStatusDisplay();
        } catch (IllegalArgumentException e) {

        };
        if (mFinish){
            finish();
        }
    }

    @Override
    protected Void doInBackground(Void... params) {
        setWifiApEnabled(mMode);
        return null;
    }
}

公共类WifiAP扩展活动{
私有静态int常量=0；
私有静态最终整数WIFI\u AP\u STATE\u UNKNOWN=-1；
私有静态int WIFI\u AP\u状态\u禁用=0；
私有静态int WIFI\u AP\u STATE\u DISABLED=1；
公共int WIFI\u AP\u状态\u启用=2；
公共int WIFI\u AP\u STATE\u ENABLED=3；
私有静态int WIFI\u AP\u状态\u失败=4；
私有最终字符串[]WIFI\u STATE\u TEXTSTATE=新字符串[]{
“禁用”、“禁用”、“启用”、“启用”、“失败”
};
私人WifiManager-wifi；
私有字符串TAG=“WifiAP”；
私有int statewiwasin=-1；
私有布尔值alwaysEnableWifi=true；//设置为false如果要尝试将wifi状态设置回启用wifi ap之前的状态，则true将导致在禁用wifi ap后始终启用wifi
/**
*切换WiFi AP状态
*@param wifihandler
*/
public void toggleWiFiAP（WifiManager wifihandler，上下文）{
如果（wifi==null）{
wifi=wifihandler；
}
布尔wifiApIsOn=getWifiAPState（）==WIFI_AP_STATE_ENABLED | | getWifiAPState（）==WIFI_AP_STATE_ENABLING；
新建SetWifiAPTask（！wifiApIsOn，false，context）.execute（）；
}
private int setWifiApEnabled（启用布尔值）{
Log.d（标记“***setWifiApEnabled称为****”+已启用）；
WifiConfiguration config=新的WifiConfiguration（）；
config.SSID=“水族灵魂”；
config.preSharedKey=“aquasoul”；
config.allowedAuthAlgorithms.set（WifiConfiguration.AuthAlgorithm.OPEN）；
config.allowedProtocols.set（WifiConfiguration.Protocol.RSN）；
config.allowedProtocols.set（WifiConfiguration.Protocol.WPA）；
config.allowedKeyManagement.set（WifiConfiguration.KeyMgmt.WPA\u PSK）；
config.allowedPairwiseCiphers.set（WifiConfiguration.PairwiseCipher.CCMP）；
config.allowedPairwiseCiphers.set（WifiConfiguration.PairwiseCipher.TKIP）；
config.alloweGroupCiphers.set（WifiConfiguration.GroupCipher.CCMP）；
config.alloweGroupCiphers.set（WifiConfiguration.GroupCipher.TKIP）；
//记住wirelesses的当前状态
如果（已启用&&statewiwasin==-1）{
stateWifiWasIn=wifi.getWifiState（）；
}
/*//禁用无线
如果（已启用&&wifi.getConnectionInfo（）！=null）{
Log.d（标签“禁用wifi:呼叫”）；
wifi.setWifiEnabled（假）；
int loopMax=10；
while（loopMax>0&&wifi.getWifiState（）！=WifiManager.wifi\u STATE\u禁用）{
Log.d（标签“禁用wifi:等待，通过：”+（10圈最大值））；
试一试{
睡眠（500）；
loopMax--；
}捕获（例外e）{
}
}
Log.d（标签“禁用wifi:完成，通过：”+（最大10圈））；
}
*/
//启用/禁用wifi ap
int state=WIFI\u AP\u state\u未知；
试一试{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:呼叫”）；
wifi.setWifiEnabled（假）；
方法method1=wifi.getClass（）.getMethod（“setWifiApEnabled”，WifiConfiguration.class，boolean.class）；
//method1.invoke（wifi，null，enabled）；//true
method1.invoke（wifi，config，enabled）；//true
方法method2=wifi.getClass（）.getMethod（“getWifiApState”）；
state=（整数）method2.invoke（wifi）；
}捕获（例外e）{
Log.e（WIFI_服务，e.getMessage（））；
//toastText+=“错误”+e.getMessage（）；
}
//在处理过程中暂停线程
如果（！已启用）{
int loopMax=10；
而（loopMax>0&（getWifiAPState（）==WIFI\u AP\u状态|禁用| getWifiAPState（）==WIFI\u状态|启用| getWifiAPState（）==WIFI\u状态|失败））{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:等待，通过：”+（10圈最大值））；
试一试{
睡眠（500）；
loopMax--；
}捕获（例外e）{
}
}
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:完成，通过：”+（10圈最大值））；
//如果事先已启用wifi，则启用wifi
//这是有点不可靠，应用程序会变得混乱，有时无法将其打开，所以添加了切换，以便在需要时始终启用
如果（stateWifiWasIn==WifiManager.WIFI\u STATE\u ENABLED | | stateWifiWasIn==WifiManager.WIFI\u STATE\u ENABLED | | stateWifiWasIn==WifiManager.WIFI\u STATE\u UNKNOWN | | alwaysEnableWifi）{
Log.d（标签“启用wifi:呼叫”）；
wifi.setWifiEnabled（true）；
//不要拖延时间，等待它被启用
}
stateWifiWasIn=-1；
}如果已启用，则为else{
int loopMax=10；
而（loopMax>0&（getWifiAPState（）==WIFI\u AP\u状态|启用| getWifiAPState（）==WIFI\u状态|禁用| getWifiAPState（）==WIFI\u状态|失败））{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:等待，通过：”+（10圈最大值））；
试一试{
睡眠（500）；
loopMax--；
}捕获（例外e）{
}
}
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:完成，通过：”+（10圈最大值））；
}
返回状态；
}
public int getWifiAPState（）{
int state=WIFI\u AP\u state\u未知；
试一试{
方法method2=wifi.getClass（）.getMethod（“getWifiApState”）；
state=（整数）method2.invoke（wifi）；
}捕获（例外e）{
}
如果（状态>=10）{
//使用安卓4.0+（或者可能是3+，还没有3台设备来测试它），所以使用+10的状态
常数=10；
}
//如果是较新的设备，请重置这些
WIFI\u AP\u状态\u禁用=0+常数；
WIFI\u AP\u STATE\u DISABLED=1+恒定值；
无线接入状态启用=2+恒定值；
WIFI\u AP\u状态启用=3+恒定值；
WIFI\u AP\u状态\u失败=4+常数；
Log.d（标记“getWifiAPState.state”+（state==-1？“未知”）：WIFI\u state