Android 关于应用程序无法获取连接客户端的原因的建议（提供的代码）

嘿，伙计们，我一直在做一个项目，创建一种wifi热点管理器，这样它就可以用mac地址、ip地址和其他信息记录连接的设备。然而，我似乎不明白为什么当我在屏幕上按“获取客户端”时，它不会收集任何连接的用户的数据。我已经将该文件编译成APK，以便在我的手机上进行测试，因为wifi功能在android studio的模拟器上不起作用

该代码归功于：

(一)

(二)

package com.example.gavin.wifiattendence；
导入android.app.Activity；
导入android.app.ProgressDialog；
导入android.content.Context；
导入android.net.wifi.WifiConfiguration；
导入android.net.wifi.WifiManager；
导入android.nfc.Tag；
导入android.os.AsyncTask；
导入android.util.Log；
导入java.io.BufferedReader；
导入java.io.FileReader；
导入java.io.IOException；
导入java.lang.reflect.Method；
导入java.net.InetAddress；
导入java.util.ArrayList；
导入java.util.concurrent.ExecutionException；
导入java.util.logging.LogRecord；
导入android.os.Handler；
/**
*由Gavins于2015年3月5日创建。
*/
公共类访问点扩展活动{
私有静态int常量=0；
私人语境；
私有静态int WIFI_STATE_UNKNOWN=-1；
私有静态int WIFI\u状态\u禁用=0；
私有静态int WIFI_STATE_DISABLED=1；
公共静态int WIFI_状态_启用=2；
公共静态int WIFI_STATE_ENABLED=3；
私有静态int WIFI_状态_失败=4；
最终静态字符串[]WIFI\u STATE\u TEXTSTATE=新字符串[]{
“禁用”、“禁用”、“启用”、“启用”、“失败”
};
私人WifiManager-wifi；
私有字符串TAG=“WifiAP”；
私有int stateWifi=-1；
私有布尔值alwaysEnabledWifi=true；
//启用或禁用wifi
public void toggleWifiAP（WifiManager wifiHandler，上下文）{
如果（wifi==null）{
wifi=wifiHandler；
}
布尔wifiApIsOn=getWifiApState（）==WIFI_状态_启用| | getWifiApState（）==WIFI_状态_启用；
新建SetWifiApTask（！wifiApIsOn，false，context）.execute（）；
}
private int setWifiApEnabled（启用布尔值）{
Log.d（标签“设置wifi已启用”称为“+已启用”）；
WifiConfiguration config=新的WifiConfiguration（）；
config.SSID=“参加讲座”；
config.allowedAuthAlgorithms.set（WifiConfiguration.AuthAlgorithm.OPEN）；
//还记得无线状态吗
如果（已启用和状态WiFi==-1）{
stateWifi=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）{
e、 printStackTrace（）；
}
}
Log.d（标签“禁用wifi已完成，通过：”+（10圈最大值））；
}
//启用和禁用wifi AP
int state=WIFI_状态_未知；
试一试{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:呼叫”）；
wifi.setWifiEnabled（假）；
方法method1=wifi.getClass（）.getMethod（“setWifiApEnabled”，WifiConfiguration.class，boolean.class）；
方法1.调用（wifi、配置、启用）；
方法method2=wifi.getClass（）.getMethod（“getWifiState”）；
state=（整数）method2.invoke（wifi）；
}捕获（例外e）{
//Log.e（WIFI_服务，e.getMessage（））；
}
//在处理过程中使用线程
如果（！已启用）{
int loopMax=10；
而（loopMax>0&（getWifiApState（）==WIFI_状态|禁用| | getWifiApState（）==WIFI_状态|启用| | getWifiApState（）==WIFI_状态|失败））{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi AP:等待，通过：”+（10圈最大值））；
试一试{
睡眠（500）；
loopMax--；
}捕获（例外e）{
}
}
Log.d（标签，（启用？“启用”）：“禁用”）+“Wifi ap:完成，通过：”+（10圈最大值））；
//启用wifi
如果（stateWifi==WifiManager.WIFI_STATE_ENABLED | | stateWifi==WifiManager.WIFI_STATE_ENABLED | | stateWifi==WifiManager.WIFI_STATE_UNKNOWN | | alwaysEnabledWifi）{
Log.d（标签“启用wifi:呼叫”）；
wifi.setWifiEnabled（true）；
//通过这种方式，它不会延迟，而是等待它被启用
}
stateWifi=-1；
}如果已启用，则为else{
int loopMax=10；
而（loopMax>0&（getWifiApState（）==WIFI_状态|启用| | getWifiApState（）==WIFI_状态|禁用| | getWifiApState（）==WIFI_状态|失败））{
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:等待，通过：”+（10圈最大值））；
试一试{
睡眠（500）；
loopMax--；
}捕获（例外e）{
}
}
Log.d（标签，（启用？“启用”）：“禁用”）+“wifi ap:完成，通过：”+（10圈最大值））；
}
返回状态；
}
//获取wifi AP状态
public int getWifiApState（）{
int state=WIFI_状态_未知；
试一试{
方法method2=wifi.getClass（）.getMethod（“getWifiApState”）；
state=（整数）method2.invoke（wifi）；
}捕获（例外e）{
}
如果（状态>=10）{
常数=10；
}
WIFI_状态_禁用=0+常数；
WIFI\u状态\u禁用=1+常数
package com.example.gavin.wifiattendance;

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.nfc.Tag;
import android.os.AsyncTask;
import android.util.Log;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.logging.LogRecord;
import android.os.Handler;

/**
 * Created by Gavins on 05/03/2015.
 */
public class AccessPoint extends Activity {
    private static int constant = 0;
    private Context context;

    private static int WIFI_STATE_UNKNOWN = -1;
    private static int WIFI_STATE_DISABLING = 0;
    private static int WIFI_STATE_DISABLED = 1;
    public static int WIFI_STATE_ENABLING = 2;
    public static int WIFI_STATE_ENABLED = 3;
    private static int WIFI_STATE_FAILED = 4;

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

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

    private int stateWifi = -1;
    private boolean alwaysEnabledWifi = true;


    //enable or disable the wifi
    public void toggleWifiAP(WifiManager wifiHandler, Context context){
        if (wifi == null){
            wifi = wifiHandler;
        }
        boolean wifiApIsOn = getWifiApState() == WIFI_STATE_ENABLED || getWifiApState()==WIFI_STATE_ENABLING;
        new SetWifiApTask(!wifiApIsOn, false, context).execute();
    }

    private int setWifiApEnabled(boolean enabled){
        Log.d(TAG, "Set wifi enabled called" + enabled);

        WifiConfiguration config = new WifiConfiguration();
        config.SSID = "Attend Lecture";
        config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);

        //remember wireless state
        if (enabled && stateWifi == -1){
            stateWifi = wifi.getWifiState();
        }

        //disable the 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){
                    e.printStackTrace();
                }
            }
            Log.d(TAG, "Disabling wifi is done, pass: " + (10-loopMax));
        }

        //enable and disable wifi AP
        int state = WIFI_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, config, enabled);
            Method method2 = wifi.getClass().getMethod("getWifiState");
            state = (Integer)method2.invoke(wifi);
        }catch (Exception e){
            //Log.e(WIFI_SERVICE, e.getMessage());
        }

        //Use thread while processing occurs
        if (!enabled){
            int loopMax = 10;
            while (loopMax>0 && (getWifiApState()==WIFI_STATE_DISABLING || getWifiApState()==WIFI_STATE_ENABLED || getWifiApState()==WIFI_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 the wifi
            if (stateWifi==WifiManager.WIFI_STATE_ENABLED || stateWifi==WifiManager.WIFI_STATE_ENABLING || stateWifi==WifiManager.WIFI_STATE_UNKNOWN || alwaysEnabledWifi){
                Log.d(TAG, "enable wifi: Calling");
                wifi.setWifiEnabled(true);
                //this way it doesnt hold things up and waits for it to get enabled
            }

            stateWifi = -1;
        }else if (enabled){
            int loopMax = 10;
            while (loopMax>0 && (getWifiApState()==WIFI_STATE_ENABLING || getWifiApState()==WIFI_STATE_DISABLED || getWifiApState()==WIFI_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;
    }

    //Get the wifi AP state
    public int getWifiApState(){
        int state = WIFI_STATE_UNKNOWN;
        try {
            Method method2 = wifi.getClass().getMethod("getWifiApState");
            state = (Integer) method2.invoke(wifi);
        }catch (Exception e){

        }

        if (state>=10){
            constant=10;
        }

        WIFI_STATE_DISABLING = 0+constant;
        WIFI_STATE_DISABLED = 1+constant;
        WIFI_STATE_ENABLING = 2+constant;
        WIFI_STATE_ENABLED = 3+constant;
        WIFI_STATE_FAILED = 4+constant;

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

    class SetWifiApTask extends AsyncTask<Void, Void, Void>{
        boolean mMode;
        boolean mFinish;
        ProgressDialog pDialog;

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

        @Override
        protected void onPreExecute(){
            super.onPreExecute();
            pDialog.setTitle("Turning on Access Point " + (mMode?"On":"Off" + "..."));
            pDialog.setMessage("Please wait a moment...");
            pDialog.show();
        }

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

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

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

    //get the list connected to the wifi hotspot
    public void getClientList(boolean onlyReachable, FinishScanListener finishListener){
        getClientList(onlyReachable, 300, finishListener);
    }

    public void getClientList(final boolean onlyReachable, final int reachableTimeout, final FinishScanListener finishListener){

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                BufferedReader br = null;
                final ArrayList<ClientScanResult> result = new ArrayList<>();

                try {
                    br = new BufferedReader(new FileReader("/proc/net/arp"));
                    String line;
                    while ((line = br.readLine()) != null){
                        String[] splitted = line.split(" +");

                        if ((splitted !=null) && (splitted.length >=4)){
                            String mac = splitted[3];

                            if (mac.matches("..:..:..:..:..:..")){
                                boolean isReachable = InetAddress.getByName(splitted[0]).isReachable(reachableTimeout);

                                if (!onlyReachable || isReachable){
                                    result.add(new ClientScanResult(splitted[0], splitted[3], splitted[5], isReachable));
                                }
                            }
                        }
                    }
                }catch (Exception e){
                    Log.e(this.getClass().toString(), e.toString());
                }finally {
                    try {
                        br.close();
                    }catch (IOException e){
                        Log.e(this.getClass().toString(), e.getMessage());
                    }
                }
                //Get handler that will be used to post to main thread
                Handler mainHandler = new Handler(context.getMainLooper());
                Runnable myRunnable = new Runnable() {
                    @Override
                    public void run() {
                        finishListener.onFinishScan(result);
                    }
                };
                mainHandler.post(myRunnable);
            }
        };

        Thread myThread = new Thread(runnable);
        myThread.start();

    }


}

    package com.example.gavin.wifiattendance;

import android.app.Activity;
import android.content.Context;
import android.net.wifi.WifiManager;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.TextView;

import com.example.gavin.wifiattendance.AccessPoint;

import java.util.ArrayList;

public class MainActivity extends ActionBarActivity{

    boolean wasApEnabled = false;
    static AccessPoint wifiAP;
    private WifiManager wifi;
    static Button apButton;
    static TextView textView;

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

        apButton = (Button) findViewById(R.id.toggleBtn);
        textView = (TextView) findViewById(R.id.wifiClients);

        wifiAP = new AccessPoint();
        wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);

        scan();

        apButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                wifiAP.toggleWifiAP(wifi, MainActivity.this);
            }
        });

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD|WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON|WindowManager.LayoutParams.FLAG_DIM_BEHIND);

    }

    public void scan(){
        wifiAP.getClientList(false, new FinishScanListener() {
            @Override
            public void onFinishScan(final ArrayList<ClientScanResult> clients) {
                textView.setText("WifiApState:" + wifiAP.getWifiApState()+ "\n\n");
                textView.append("Clients: \n");
                for (ClientScanResult clientScanResult : clients){
                    textView.append("====================\n");
                    textView.append("ipAddress: " + clientScanResult.getIpAddress() + "\n");
                    textView.append("Device: " + clientScanResult.getDevice() + "\n");
                    textView.append("macAddress: " + clientScanResult.getMacAddress() + "\n");
                    textView.append("isReachable: " + clientScanResult.isReachable() + "\n");

                }
            }
        });
    }

    @Override
    public void onResume() {
        super.onResume();
        if (wasApEnabled) {
            if (wifiAP.getWifiApState() != wifiAP.WIFI_STATE_ENABLED && wifiAP.getWifiApState() != wifiAP.WIFI_STATE_ENABLING) {
                wifiAP.toggleWifiAP(wifi, MainActivity.this);
            }
        }
        updateStatusDisplay();
    }

    @Override
    public void onPause() {
        super.onPause();
        boolean wifiApIsOn = wifiAP.getWifiApState()==wifiAP.WIFI_STATE_ENABLED || wifiAP.getWifiApState()==wifiAP.WIFI_STATE_ENABLING;
        if (wifiApIsOn){
            wasApEnabled = true;
            wifiAP.toggleWifiAP(wifi, MainActivity.this);
        }else {
            wasApEnabled = false;
        }
        updateStatusDisplay();
    }

    public static void updateStatusDisplay(){
        if (wifiAP.getWifiApState()==wifiAP.WIFI_STATE_ENABLED || wifiAP.getWifiApState()==wifiAP.WIFI_STATE_ENABLING){
            apButton.setText("Turn Off");
        }else {
            apButton.setText("Turn on");
        }
    }



    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        menu.add(0,0,0, "Get Clients");
        return super.onCreateOptionsMenu(menu);
    }

    public boolean onOptionsItemSelected(int featureId, MenuItem item) {
        switch (item.getItemId()){
            case 0:
                scan();
                break;
        }
        return super.onMenuItemSelected(featureId, item);
    }
}