android盒子与手机相互通讯

最新推荐文章于 2022-04-20 22:50:49 发布

wujiang_android

最新推荐文章于 2022-04-20 22:50:49 发布

阅读量591

点赞数 1

分类专栏： android

本文链接：https://blog.csdn.net/wujiang_android/article/details/81431373

版权

android 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

android的盒子大多数是有USB接口的，USB接口可以连接手机的。如果我们需要盒子和手机相互通讯，怎么实现呢？下面给出我的工程代码，测试盒子wifi信号用的，通讯的关键代码需自己去体会啦。

盒子端：

OpenDevicesReceiver.java:

public class OpenDevicesReceiver extends BroadcastReceiver {
private OpenDevicesListener mOpenDevicesListener;

   public OpenDevicesReceiver(OpenDevicesListener openDevicesListener) {
       mOpenDevicesListener = openDevicesListener;
   }

   @Override
   public void onReceive(Context context, Intent intent) {
       UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
       if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
           if (usbDevice != null) {
               mOpenDevicesListener.openAccessoryModel(usbDevice);
           } else {
               mOpenDevicesListener.openDevicesError();
           }
       } else {
           mOpenDevicesListener.openDevicesError();
       }
   }

   public interface OpenDevicesListener {
       /**
       * 打开Accessory模式
       *
       * @param usbDevice
       */
       void openAccessoryModel(UsbDevice usbDevice);

       /**
       * 打开设备(手机)失败
       */
       void openDevicesError();
   }
}

UsbDetachedReceiver.java:

package com.sen5.factorytest.ui.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.hardware.usb.UsbManager;

public class UsbDetachedReceiver extends BroadcastReceiver {
private UsbDetachedListener mUsbDetachedListener;

   public UsbDetachedReceiver(UsbDetachedListener usbDetachedListener) {
       mUsbDetachedListener = usbDetachedListener;
   }

   @Override
   public void onReceive(Context context, Intent intent) {
       // TODO Auto-generated method stub
       if (intent.getAction() == UsbManager.ACTION_USB_DEVICE_DETACHED) {
           mUsbDetachedListener.usbDetached();
       } else if (intent.getAction() == UsbManager.ACTION_USB_DEVICE_ATTACHED) {
           mUsbDetachedListener.usbAttached();
       }
   }

   public interface UsbDetachedListener {
       /**
       * usb断开连接
       */
       void usbDetached();

       /**
       * usb insert
       */
       void usbAttached();
   }
}

Wifi4GRouterChangeReceiver.java:

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class Wifi4GRouterChangeReceiver extends BroadcastReceiver {
   private Wifi4GRouterChangeListener mWifi4GRouterChangeListener;

   public Wifi4GRouterChangeReceiver(Wifi4GRouterChangeListener listener) {
       mWifi4GRouterChangeListener = listener;
   }

   @Override
   public void onReceive(Context context, Intent intent) {
       // TODO Auto-generated method stub
       Log.d("wujiang", "Wifi4GRouterChangeReceiver: onReceive");
       mWifi4GRouterChangeListener.Wifi4GRouterChanged(intent);
   }

   public interface Wifi4GRouterChangeListener {
       void Wifi4GRouterChanged(Intent intent);
   }
}

主activity：

package com.sen5.factorytest.testing.modules;

import java.util.Collection;
import java.util.HashMap;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.alibaba.fastjson.JSON;
import com.nes.services.NesIntent;
import com.sen5.factorytest.testing.BaseCase;
import com.sen5.factorytest.testing.CaseEnum;
import com.sen5.factorytest.testing.bean.CaseResult;
import com.sen5.factorytest.ui.activity.Main2Activity;
import com.sen5.factorytest.ui.receiver.OpenDevicesReceiver;
import com.sen5.factorytest.ui.receiver.UsbDetachedReceiver;
import com.sen5.factorytest.ui.receiver.Wifi4GRouterChangeReceiver;
import com.utsmta.app.R;

import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbConstants;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;

public class Case4GWifi extends BaseCase implements UsbDetachedReceiver.UsbDetachedListener,
OpenDevicesReceiver.OpenDevicesListener, Wifi4GRouterChangeReceiver.Wifi4GRouterChangeListener {
private static final String USB_ACTION = "com.tcl.navigator.hostchart";

private static final int CONNECTED_SUCCESS = 0;
private static final int RECEIVER_MESSAGE_SUCCESS = 1;
private static final int SEND_MESSAGE_SUCCESS = 2;
private static final int REQUEST_ROUTER_MAIN_SSID = 3;
private static final int GETTED_ROUTER_MAIN_SSID = 4;
private static final int CHANGE_TO_MAIN_ANTENNA = 5;
private static final int CHANGE_TO_MAIN_ANTENNA_SUCCESS = 6;
private static final int REQUEST_ROUTER_SUB_SSID = 7;
private static final int GETTED_ROUTER_SUB_SSID = 8;
private static final int CHANGE_TO_SUB_ANTENNA = 9;
private static final int CHANGE_TO_SUB_ANTENNA_SUCCESS = 10;
private static final int FINISH_ANTENNA_TEST = 11;
private static final int SHOW_WRITE_ROUTER_RESULT = 12;

private static final int MAIN_STEP = 1;
private static final int SUB_STEP = 2;
private int mTestSetup = 0;

private final String TAG = "wujiang";
   private UsbDetachedReceiver mUsbDetachedReceiver;
   private OpenDevicesReceiver mOpenDevicesReceiver;
   private Wifi4GRouterChangeReceiver mWifi4GRouterChangeReceiver;

private PendingIntent pendingIntent;
private ExecutorService mThreadPool;
private UsbManager mUsbManager;

private UsbDeviceConnection mUsbDeviceConnection;
private UsbEndpoint mUsbEndpointOut;
private UsbEndpoint mUsbEndpointIn;
private UsbInterface mUsbInterface;

private CaseResult mCaseResult;

private boolean isTestting = false;
   private boolean isDetached = false;
   public static boolean mToggle = true;
   public static boolean isReceiverMessage = false;

   private byte[] mBytes = new byte[1024];
   private StringBuffer mStringBuffer = new StringBuffer();

   private String m4GRounterSSID = null;
   private StringBuffer mTestingInfor = new StringBuffer();
   private boolean mMainAntennaTestResult;
   private boolean mSubAntennaTestResult;
   private String mMainAntennaLevel;
   private String mSubAntennaLevel;

   private Timer mTimer1;
   private Timer mTimer2;
   private Timer mTimer3;
   private Timer mTimer4;
   private Timer mTimer5;
   private Timer mTimer6;
   private Timer mTimer7;

   private boolean mGotSSID = false;
   private boolean mChangedToMainAntenna = false;
   private boolean mChangedToSubAntenna = false;
   private boolean mGotWriteRouterResult = false;
   private boolean mGotDataFromPhone = false;
   private int mGetReceiverWaitCount = 0;
   private final int mGetRecevierWaitMaxCount = 18;
   private final int mGetDataFromPhoneWaitMaxCount = 60;

   public Case4GWifi(Main2Activity activity, CaseEnum anEnum) {
       super(activity, anEnum);
       // TODO Auto-generated constructor stub
   }

private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case CONNECTED_SUCCESS://车机和手机连接成功
Log.d(TAG, "receive CONNECTED_SUCCESS");
isReceiverMessage = true;
loopReceiverMessage();
Log.d(TAG, "m4GRounterSSID = " + m4GRounterSSID);
send_ssid_to_usb(m4GRounterSSID);
//send_ssid_to_usb("wifi-test"); //for debug
break;

case RECEIVER_MESSAGE_SUCCESS://成功接受到数据
Log.d(TAG, "receive RECEIVER_MESSAGE_SUCCESS");
Log.d(TAG, "msg = " + mStringBuffer.toString());
resetState();
mGotDataFromPhone = true;

String str_gson = mStringBuffer.toString();
WifiInfor parseObject = JSON.parseObject(str_gson, WifiInfor.class);
Log.d(TAG, "infor level = " + parseObject.getApLevel());
Log.d(TAG, "infor test result = " + parseObject.getTestResult());
Log.d(TAG, "infor mTestSetup = " + mTestSetup);

if (mTestSetup == MAIN_STEP) {
   Log.d(TAG, "主天线测试完成");
   mMainAntennaLevel = parseObject.getApLevel();
   if (parseObject.getTestResult().contains("Passed") || parseObject.getTestResult().contains("passed")) {
       mMainAntennaTestResult = true;
} else {
   mMainAntennaTestResult = false;
}
   Log.d(TAG, "mMainAntennaTestResult = " + mMainAntennaTestResult);
   mTestingInfor.append("主天线wifi信号强度: " + parseObject.getApLevel() + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);

   mHandler.sendEmptyMessage(REQUEST_ROUTER_SUB_SSID);
} else if (mTestSetup == SUB_STEP) {
   Log.d(TAG, "副天线测试完成");
   mSubAntennaLevel = parseObject.getApLevel();
   if (parseObject.getTestResult().contains("Passed") || parseObject.getTestResult().contains("passed")) {
       mSubAntennaTestResult = true;
   } else {
       mSubAntennaTestResult = false;
   }
   Log.d(TAG, "mSubAntennaTestResult = " + mSubAntennaTestResult);
   mTestingInfor.append("副天线wifi信号强度: " + parseObject.getApLevel() + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);

mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
}
break;

case SEND_MESSAGE_SUCCESS://成功发送数据
Log.d(TAG, "receive SEND_MESSAGE_SUCCESS");
break;

//请求路由器的主SSID
case REQUEST_ROUTER_MAIN_SSID:
   Log.d(TAG, "获取路由器主天线SSID......");
   mTestSetup = MAIN_STEP;
   m4GRounterSSID = null;
   mGotSSID = false;
   mGetReceiverWaitCount = 0;

   mTestingInfor.setLength(0);
   mTestingInfor.append("获取路由器主天线SSID......" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);

       Intent req_intent = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
       req_intent.putExtra("check_wifi_antenna_ssid", "get_ssid_main");
       context.sendBroadcast(req_intent);

       mTimer1 = new Timer();
                   mTimer1.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mGotSSID == true) {
                               if (mTimer1 != null) {
                                   Log.d(TAG, "cancel 请求路由器的主SSID timer");
                                   mTimer1.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetRecevierWaitMaxCount) {
                               if (mTimer1 != null) {
                                   Log.d(TAG, "cancel 请求路由器的主SSID timer");
                                   mTimer1.cancel();
                               }
                               mTestingInfor.append("获取路由器主天线SSID失败" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 500);
   break;

//请求路由器主SSID完成
case GETTED_ROUTER_MAIN_SSID:
   Log.d(TAG, "获取路由器主天线完成");
   mGotSSID = true;
   if (m4GRounterSSID == null) {
       Log.d(TAG, "请求主天线SSID失败");
       mTestingInfor.append("获取路由器主天线SSID失败" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
   } else {
       Log.d(TAG, "请求主天线SSID成功,开始获取信号强度");
       mTestingInfor.append("获取路由器主天线SSID成功" + "(" + m4GRounterSSID + ")" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(CHANGE_TO_MAIN_ANTENNA);
   }
   break;

//切换到主天线
case CHANGE_TO_MAIN_ANTENNA:
   Log.d(TAG, "切换到主天线......");
   mGetReceiverWaitCount = 0;
   mChangedToMainAntenna = false;

   mTestingInfor.append("切换到主天线......" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

           Intent intent = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
           intent.putExtra("change_wifi_antenna", "main");
           context.sendBroadcast(intent);

           mTimer2 = new Timer();
           mTimer2.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mChangedToMainAntenna == true) {
                               if (mTimer2 != null) {
                                   Log.d(TAG, "cancel 切换到主天线 timer");
                                   mTimer2.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetRecevierWaitMaxCount) {
                               if (mTimer2 != null) {
                                   Log.d(TAG, "cancel 切换到主天线 timer");
                                   mTimer2.cancel();
                               }
                               mTestingInfor.append("切换到主天线失败" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 500);
   break;

//切换到主天线成功
case CHANGE_TO_MAIN_ANTENNA_SUCCESS:
Log.d(TAG, "切换到主天线成功");
mChangedToMainAntenna = true;

   mTestingInfor.append("切换到主天线成功" + ", 开始获取信号强度" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

   mMainAntennaTestResult = false;
   mMainAntennaLevel = "-100";
   mGotDataFromPhone = false;
   mGetReceiverWaitCount = 0;
   start_test();

   mTimer6 = new Timer();
                   mTimer6.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mGotDataFromPhone == true) {
                               if (mTimer6 != null) {
                                   Log.d(TAG, "cancel 获取主天线信号强度 timer");
                                   mTimer6.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetDataFromPhoneWaitMaxCount) {
                               mGotDataFromPhone = false;
                               if (mTimer6 != null) {
                                   Log.d(TAG, "cancel 获取主天线信号强度 timer");
                                   mTimer6.cancel();
                               }
                               mTestingInfor.append("获取主天线信号强度超时" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 1000);
   break;

//获取路由器副天线SSID
case REQUEST_ROUTER_SUB_SSID:
   Log.d(TAG, "获取路由器副天线SSID......");
   mTestSetup = SUB_STEP;
   m4GRounterSSID = null;
   mGotSSID = false;
   mGetReceiverWaitCount = 0;

   mTestingInfor.append("获取路由器副天线SSID......" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);

       Intent req_intent1 = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
       req_intent1.putExtra("check_wifi_antenna_ssid", "get_ssid_sub");
       context.sendBroadcast(req_intent1);

       mTimer3 = new Timer();
                   mTimer3.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mGotSSID == true) {
                               if (mTimer3 != null) {
                                   Log.d(TAG, "cancel 请求副天线SSID timer");
                                   mTimer3.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetRecevierWaitMaxCount) {
                               if (mTimer3 != null) {
                                   Log.d(TAG, "cancel 请求副天线SSID timer");
                                   mTimer3.cancel();
                               }
                               mTestingInfor.append("获取路由器副天线SSID失败" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 1000);
   break;

//获取路由器副天线SSID成功
case GETTED_ROUTER_SUB_SSID:
   Log.d(TAG, "获取路由器副天线SSID完成");
   mGotSSID = true;

       if (m4GRounterSSID == null) {
       Log.d(TAG, "请求副天线SSID失败");
       mTestingInfor.append("获取路由器副天线SSID失败" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
   } else {
       Log.d(TAG, "请求副天线SSID成功,开始获取信号强度");
       mTestingInfor.append("获取路由器副天线SSID成功" + "(" + m4GRounterSSID + ")" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(CHANGE_TO_SUB_ANTENNA);
   }
   break;

//切换到副天线
case CHANGE_TO_SUB_ANTENNA:
   Log.d(TAG, "切换到副天线......");
   mGetReceiverWaitCount = 0;
   mChangedToSubAntenna = false;

   mTestingInfor.append("切换到副天线......" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

           Intent intent3 = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
           intent3.putExtra("change_wifi_antenna", "sub");
           context.sendBroadcast(intent3);

           mTimer4 = new Timer();
           mTimer4.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mChangedToSubAntenna == true) {
                               if (mTimer4 != null) {
                                   Log.d(TAG, "cancel 切换到副天线 timer");
                                   mTimer4.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetRecevierWaitMaxCount) {
                               if (mTimer4 != null) {
                                   Log.d(TAG, "cancel 切换到副天线 timer");
                                   mTimer4.cancel();
                               }
                               mTestingInfor.append("切换到副天线失败" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 500);
   break;

//切换到副天线成功,然后测试副天线
case CHANGE_TO_SUB_ANTENNA_SUCCESS:
   Log.d(TAG, "切换到副天线成功");
   mChangedToSubAntenna = true;
   mTestingInfor.append("切换到副天线成功" + ", 开始获取信号强度" + "\n");
   mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_READY);
           postMsg(mCaseResult);

           mSubAntennaTestResult = false;
   mSubAntennaLevel = "-100";
   mGotDataFromPhone = false;
   mGetReceiverWaitCount = 0;
   start_test();

   mTimer7 = new Timer();
                   mTimer7.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mGotDataFromPhone == true) {
                               if (mTimer7 != null) {
                                   Log.d(TAG, "cancel 获取副天线信号强度 timer");
                                   mTimer7.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetDataFromPhoneWaitMaxCount) {
                               mGotDataFromPhone = false;
                               if (mTimer7 != null) {
                                   Log.d(TAG, "cancel 获取副天线信号强度 timer");
                                   mTimer7.cancel();
                               }
                               mTestingInfor.append("获取副天线信号强度超时" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                           }
                       }
                   }, 100, 1000);
   break;

case FINISH_ANTENNA_TEST:
   resetState();
   mGotWriteRouterResult = false;
   mGetReceiverWaitCount = 0;

Log.d("wujiang", "mMainAntennaTestResult = " + mMainAntennaTestResult);
Log.d("wujiang", "mSubAntennaTestResult = " + mSubAntennaTestResult);

   if(mMainAntennaTestResult && mSubAntennaTestResult) {
       /*mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_SUCCEED);
           postMsg(mCaseResult);*/

           //反馈测试结果给路由器
           Intent intent1 = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
           intent1.putExtra("check_wifi_antenna_result", "true");
           context.sendBroadcast(intent1);
   } else {
       /*mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);*/

           //反馈测试结果给路由器
           Intent intent2 = new Intent(NesIntent.ACTION_NES_ROUTER_WIFI_TEST);
           intent2.putExtra("check_wifi_antenna_result", "false");
           context.sendBroadcast(intent2);
   }

   mTimer5 = new Timer();
           mTimer5.schedule(new TimerTask() {

                       @Override
                       public void run() {
                           // TODO Auto-generated method stub
                           mGetReceiverWaitCount++;

                           if (mGotWriteRouterResult == true) {
                               if (mTimer5 != null) {
                                   Log.d(TAG, "cancel 写测试结果到路由器返回值 timer");
                                   mTimer5.cancel();
                               }
                           }

                           if (mGetReceiverWaitCount >= mGetRecevierWaitMaxCount) {
                               if (mTimer5 != null) {
                                   Log.d(TAG, "cancel 写测试结果到路由器返回值 timer");
                                   mTimer5.cancel();
                               }
                               mTestingInfor.append("测试结果写入路由器超时" + "\n");
                               mCaseResult.setMessage(mTestingInfor.toString());
                               mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                               postMsg(mCaseResult);

                               isTestting = false;
                           }
                       }
                   }, 100, 500);
   break;

//显示测试结果写入到路由器是否成功
case SHOW_WRITE_ROUTER_RESULT:
   Log.d(TAG, "测试结果写入路由器成功");
   mGotWriteRouterResult = true;

String msg_obj = (String) msg.obj;

   if(mMainAntennaTestResult && mSubAntennaTestResult && msg_obj.equals("true")) {
       mTestingInfor.append("测试结果写入路由器成功" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_SUCCEED);
       postMsg(mCaseResult);
   } else {
       if (msg_obj.equals("false")) {
           mTestingInfor.append("测试结果写入路由器失败" + "\n");
       } else {
           mTestingInfor.append("测试结果写入路由器成功" + "\n");
       }
       mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_FIAL);
       postMsg(mCaseResult);
   }
   isTestting = false;
   break;
}
}
};

private void resetState() {
   Log.d("wujiang", "call resetState");
   isReceiverMessage = false;
   mToggle = false;
mUsbEndpointOut = null;
mUsbEndpointIn = null;

if (mUsbDeviceConnection != null) {
mUsbDeviceConnection.releaseInterface(mUsbInterface);
mUsbDeviceConnection.close();
mUsbDeviceConnection = null;
}

if (mTimer1 != null) {
   mTimer1.cancel();
}
if (mTimer2 != null) {
   mTimer2.cancel();
}
if (mTimer3 != null) {
   mTimer3.cancel();
}
if (mTimer4 != null) {
   mTimer4.cancel();
}
}

private void send_ssid_to_usb(final String ssid) {
   if (ssid != null && ssid.length() > 0) {
       mThreadPool.execute(new Runnable() {

               @Override
               public void run() {
                   // TODO Auto-generated method stub
                   mUsbDeviceConnection.bulkTransfer(mUsbEndpointOut, ssid.getBytes(), ssid.getBytes().length, 3000);
               }
           });
   }
}

   @Override
   public void init() {
       // TODO Auto-generated method stub
       Log.d(TAG, "Case4GWifi: init");

mCaseResult = new CaseResult();
mCaseResult.setCaseEnum(mCaseEnum);

       initReceiver();
       initData();
       isTestting = false;
   }

private void initReceiver() {
Log.d(TAG, "Case4GWifi: initReceiver");
mUsbDetachedReceiver = new UsbDetachedReceiver(this);
IntentFilter intentFilter = new IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED);
intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
context.registerReceiver(mUsbDetachedReceiver, intentFilter);

pendingIntent = PendingIntent.getBroadcast(context.getApplicationContext(), 0, new Intent(USB_ACTION), 0);
IntentFilter intentFilter1 = new IntentFilter(USB_ACTION);
mOpenDevicesReceiver = new OpenDevicesReceiver(this);
context.registerReceiver(mOpenDevicesReceiver, intentFilter1);

mWifi4GRouterChangeReceiver = new Wifi4GRouterChangeReceiver(this);
IntentFilter intentFilter2 = new IntentFilter(NesIntent.ACTION_NES_ROUTER_WIFI_TEST_RESULT);
context.registerReceiver(mWifi4GRouterChangeReceiver, intentFilter2);
}

   private void destoryReceiver() {
       context.unregisterReceiver(mUsbDetachedReceiver);
       context.unregisterReceiver(mOpenDevicesReceiver);
       context.unregisterReceiver(mWifi4GRouterChangeReceiver);
   }

   private void initData() {
       mThreadPool = Executors.newFixedThreadPool(5);
       mUsbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
   }

   private void start_test() {
       Log.d("wujiang", "call start_test");
       mToggle = true;
       openDevices();
   }

   private void openDevices() {
Log.d(TAG, "call openDevices");
boolean found_device = false;

//列举设备(手机)
HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
Log.d(TAG, "openDevices: device count = " + mUsbManager.getDeviceList().size());
if (deviceList != null) {
   if (mUsbManager.getDeviceList().size() <= 0) {
       mTestingInfor.append("没发现手机设备" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
           return;
   }
for (UsbDevice usbDevice : deviceList.values()) {
int productId = usbDevice.getProductId();
Log.d(TAG, "openDevices: productId = " + productId);
Log.d(TAG, "openDevices: ManufacturerName = " + usbDevice.getManufacturerName());
Log.d(TAG, "openDevices: DeviceName = " + usbDevice.getDeviceName());
Log.d(TAG, "openDevices: SerialNumber = " + usbDevice.getSerialNumber());

//if (productId != 46945 && productId != 1401 && productId != 5783) {
if (mUsbManager.hasPermission(usbDevice)) {
found_device = true;
initAccessory(usbDevice);
} else {
mUsbManager.requestPermission(usbDevice, pendingIntent);
}
//}
}

if (found_device == false) {
   mTestingInfor.append("没发现任何USB设备" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
} else {
   initDevice();
}
} else {
   mTestingInfor.append("没发现手机设备" + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
           mCaseResult.setResultType(BaseCase.STATUS_FIAL);
           postMsg(mCaseResult);

           mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
}
}

   /**
* 发送命令 , 让手机进入Accessory模式
*
* @param usbDevice
*/
private void initAccessory(UsbDevice usbDevice) {
Log.d(TAG, "call initAccessory");
UsbDeviceConnection usbDeviceConnection = mUsbManager.openDevice(usbDevice);
if (usbDeviceConnection == null) {
mCaseResult.setMessage(context.getString(R.string.wifi_no_device));
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);
       isReceiverMessage = false;

       mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
return;
}

Log.d(TAG, "call initAccessory 1");

//根据AOA协议打开Accessory模式
initStringControlTransfer(usbDeviceConnection, 0, "Google, Inc."); // MANUFACTURER
initStringControlTransfer(usbDeviceConnection, 1, "AccessoryChat"); // MODEL
initStringControlTransfer(usbDeviceConnection, 2, "Accessory Chat"); // DESCRIPTION
initStringControlTransfer(usbDeviceConnection, 3, "1.0"); // VERSION
initStringControlTransfer(usbDeviceConnection, 4, "http://www.android.com"); // URI
initStringControlTransfer(usbDeviceConnection, 5, "0123456789"); // SERIAL
usbDeviceConnection.controlTransfer(0x40, 53, 0, 0, new byte[]{}, 0, 100);
usbDeviceConnection.close();
Log.d(TAG, "initAccessory success");
//initDevice();
}

private void initStringControlTransfer(UsbDeviceConnection deviceConnection, int index, String string) {
deviceConnection.controlTransfer(0x40, 52, 0, index, string.getBytes(), string.length(), 100);
}

/**
* 初始化设备(手机) , 当手机进入Accessory模式后 , 手机的PID会变为Google定义的2个常量值其中的一个 ,
*/
int find_phone_device_count = 0;
int find_phone_device_max_count = 20;
   private void initDevice() {
       Log.d(TAG, "call initDevice");
       find_phone_device_count = 0;
       mThreadPool.execute(new Runnable() {
           @Override
           public void run() {
               while (mToggle) {
                   Log.d(TAG, "initDevice, while exe");
                   find_phone_device_count++;
                   if (find_phone_device_count > find_phone_device_max_count) {
                       mToggle = false;
                   }
                   SystemClock.sleep(1000);
                   HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
                   Collection<UsbDevice> values = deviceList.values();
                   if (!values.isEmpty()) {
                       Log.d(TAG, "initDevice: deviceList size = " + values.size());
                       for (UsbDevice usbDevice : values) {
                           int productId = usbDevice.getProductId();
                           Log.d(TAG, "initDevice: productId = " + productId);
                           Log.d(TAG, "initDevice: ManufacturerName =" + usbDevice.getManufacturerName());
                           Log.d(TAG, "initDevice: DeviceName = " + usbDevice.getDeviceName());
                           Log.d(TAG, "initDevice: SerialNumber = " + usbDevice.getSerialNumber());
                           if (productId == 11520 || productId == 11521) {
                               if (mUsbManager.hasPermission(usbDevice)) {
                                   mUsbDeviceConnection = mUsbManager.openDevice(usbDevice);
                                   if (mUsbDeviceConnection != null) {
                                       mUsbInterface = usbDevice.getInterface(0);
                                       int endpointCount = mUsbInterface.getEndpointCount();
                                       Log.d(TAG, "initDevice: endpointCount = " + endpointCount);
                                       for (int i = 0; i < endpointCount; i++) {
                                           UsbEndpoint usbEndpoint = mUsbInterface.getEndpoint(i);
                                           if (usbEndpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                                               if (usbEndpoint.getDirection() == UsbConstants.USB_DIR_OUT) {
                                                   mUsbEndpointOut = usbEndpoint;
                                               } else if (usbEndpoint.getDirection() == UsbConstants.USB_DIR_IN) {
                                                   mUsbEndpointIn = usbEndpoint;
                                               }
                                           }
                                       }
                                       if (mUsbEndpointOut != null && mUsbEndpointIn != null) {
                                           Log.d(TAG, "initDevice:connected success");
                                           //mHandler.sendEmptyMessage(CONNECTED_SUCCESS);
                                           mToggle = false;
                                           isDetached = true;
                                       }
                                   }
                               } else {
                                   mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(context, 0, new Intent(""), 0));
                               }
                           }
                       }
                   } else {
                       mCaseResult.setMessage(context.getString(R.string.wifi_no_device));
                       mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                       postMsg(mCaseResult);

                       mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
                   }
               }

               if (mUsbEndpointOut != null && mUsbEndpointIn != null) {
                   Log.d(TAG, "initDevice:send CONNECTED_SUCCESS");
                   mHandler.sendEmptyMessage(CONNECTED_SUCCESS);
               } else {
                   Log.d(TAG, "没发现手机设备");
                   mCaseResult.setMessage("没发现手机设备");
                   mCaseResult.setResultType(BaseCase.STATUS_FIAL);
                   postMsg(mCaseResult);

mHandler.sendEmptyMessage(FINISH_ANTENNA_TEST);
}

               Log.d(TAG, "initDevice: exit initDevice");
           }
       });
   }

/**
* 接受消息线程 , 此线程在设备(手机)初始化完成后 , 就一直循环接受消息
*/
   private void loopReceiverMessage() {
       mThreadPool.execute(new Runnable() {
           @Override
           public void run() {
               SystemClock.sleep(2000);
               while (isReceiverMessage) {
                   /**
                   * 循环接受数据的地方 , 只接受byte数据类型的数据
                   */
                   if (mUsbDeviceConnection != null && mUsbEndpointIn != null) {
                       int i = mUsbDeviceConnection.bulkTransfer(mUsbEndpointIn, mBytes, mBytes.length, 3000);
                       //MyApplication.printLogDebug(i + "");
                       Log.d(TAG, "loopReceiverMessage: i = " + i);
                       if (i > 0) {
                           isReceiverMessage = false;
                           mStringBuffer.setLength(0);
                           mStringBuffer.append(new String(mBytes, 0, i) + "\n");
                           mHandler.sendEmptyMessage(RECEIVER_MESSAGE_SUCCESS);
                       }
                   }
               }
               Log.d(TAG, "exit loopReceiverMessage");
           }
       });
   }

   @Override
   public void runTask(int modle) {
       // TODO Auto-generated method stub
       Log.d(TAG, "Case4GWifi: runTask");
       //start_test();

       if (isTestting == false) {
           isTestting = true;
           Log.d(TAG, "Case4GWifi: 开始测试");
           mHandler.sendEmptyMessage(REQUEST_ROUTER_MAIN_SSID);
       } else {
           Log.d(TAG, "Case4GWifi: 已经在测试中");
       }
   }

   /*
   * usb 拔出 callback
   * */
   @Override
   public void usbDetached() {
       // TODO Auto-generated method stub
       if (isDetached) {

}
       Log.d(TAG, "call usbDetached");

resetState();

       mTestingInfor.append(context.getString(R.string.wifi_no_device) + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);
   }

   /*
   * usb 插入 callback
   * */
   @Override
   public void usbAttached() {
       // TODO Auto-generated method stub
       Log.d(TAG, "call usbAttached");
       mTestingInfor.append(context.getString(R.string.wifi_find_device) + "\n");
       mCaseResult.setMessage(mTestingInfor.toString());
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);
   }

   @Override
   public void openAccessoryModel(UsbDevice usbDevice) {
       // TODO Auto-generated method stub
       Log.d(TAG, "call openAccessoryModel");
       initAccessory(usbDevice);
   }

   @Override
   public void openDevicesError() {
       // TODO Auto-generated method stub
       mCaseResult.setMessage(context.getString(R.string.wifi_usb_error));
       mCaseResult.setResultType(BaseCase.STATUS_READY);
       postMsg(mCaseResult);
       isReceiverMessage = false;
   }

   private static class WifiInfor {
public String apSsid;
public String apLevel;
public String testResult;

public String getApSsid() {
return apSsid;
}

public void SetApSsid(String ssid) {
apSsid = ssid;
}

public String getApLevel() {
return apLevel;
}

public void setApLevel(String level) {
apLevel = level;
}

public String getTestResult() {
return testResult;
}

public void setTestResult(String result) {
testResult = result;
}
}

   @Override
   public void Wifi4GRouterChanged(Intent intent) {
       // TODO Auto-generated method stub
       if (intent != null && intent.getAction() != null) {
           Log.d("wujiang", "intent.getAction() = " + intent.getAction());

           if (intent.getAction() == NesIntent.ACTION_NES_ROUTER_WIFI_TEST_RESULT) {
               if(intent.getStringExtra("check_wifi_antenna_ssid") != null) {
                   m4GRounterSSID = intent.getStringExtra("check_wifi_antenna_ssid");
                   Log.d(TAG, "Wifi4GRouterChanged: get main ssid success, ssid = " + m4GRounterSSID);
                   if (mTestSetup == MAIN_STEP) {
                       mHandler.sendEmptyMessage(GETTED_ROUTER_MAIN_SSID);
                   } else if (mTestSetup == SUB_STEP) {
                       mHandler.sendEmptyMessage(GETTED_ROUTER_SUB_SSID);
                   }
               } else if (intent.getStringExtra("change_wifi_antenna") != null) {
                   Log.d(TAG, "Wifi4GRouterChanged: change_wifi_antenna");
                   if(intent.getStringExtra("change_wifi_antenna").contains("change_main_ok")) {
                       //切换到主天线成功
                       mHandler.sendEmptyMessage(CHANGE_TO_MAIN_ANTENNA_SUCCESS);
                       Log.d(TAG, "Wifi4GRouterChanged: CHANGE_TO_MAIN_ANTENNA_SUCCESS");
                   } else if(intent.getStringExtra("change_wifi_antenna").contains("change_sub_ok")) {
                       //切换到副天线成功
                       mHandler.sendEmptyMessage(CHANGE_TO_SUB_ANTENNA_SUCCESS);
                       Log.d(TAG, "Wifi4GRouterChanged: CHANGE_TO_SUB_ANTENNA_SUCCESS");
                   } else {
                       Log.d(TAG, "Wifi4GRouterChanged: change_wifi_antenna error");
                   }
               } else if (intent.getStringExtra("check_wifi_antenna_result") != null) {
                   Log.d(TAG, "Wifi4GRouterChanged: SHOW_WRITE_ROUTER_RESULT");
                   Message message = Message.obtain();
                   message.what = SHOW_WRITE_ROUTER_RESULT;
                   if (intent.getStringExtra("check_wifi_antenna_result").equals("true")) {
                       message.obj= "true";
                   } else {
                       message.obj= "false";
                   }
                   mHandler.sendMessage(message);
               }
           }
       }
   }
}

手机端：

PermissionInterface.java:

public interface PermissionInterface {
    /**
     * 可设置请求权限请求码
     */
    int getPermissionsRequestCode();

    /**
     * 设置需要请求的权限
     */
    String[] getPermissions();

    /**
     * 请求权限成功回调
     */
    void requestPermissionsSuccess();

    /**
     * 请求权限失败回调
     */
    void requestPermissionsFail();
}

PermissionHelper.java:

public class PermissionHelper {
    private Activity mActivity;
    private PermissionInterface mPermissionInterface;

    public PermissionHelper(Activity activity, PermissionInterface permissionInterface) {
        mActivity = activity;
        mPermissionInterface = permissionInterface;
    }

    /**
     * 开始请求权限。
     * 方法内部已经对Android M 或以上版本进行了判断，外部使用不再需要重复判断。
     * 如果设备还不是M或以上版本，则也会回调到requestPermissionsSuccess方法。
     */
    public void requestPermissions() {
        String[] deniedPermissions = PermissionUtil.getDeniedPermissions(mActivity, mPermissionInterface.getPermissions());
        if (deniedPermissions != null && deniedPermissions.length > 0) {
            PermissionUtil.requestPermissions(mActivity, deniedPermissions, mPermissionInterface.getPermissionsRequestCode());
        } else {
            mPermissionInterface.requestPermissionsSuccess();
        }
    }

    /**
     * 在Activity中的onRequestPermissionsResult中调用
     *
     * @param requestCode
     * @param permissions
     * @param grantResults
     * @return true 代表对该requestCode感兴趣，并已经处理掉了。false 对该requestCode不感兴趣，不处理。
     */
    public boolean requestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        if (requestCode == mPermissionInterface.getPermissionsRequestCode()) {
            boolean isAllGranted = true;//是否全部权限已授权
            for (int result : grantResults) {
                if (result == PackageManager.PERMISSION_DENIED) {
                    isAllGranted = false;
                    break;
                }
            }
            if (isAllGranted) {
                //已全部授权
                mPermissionInterface.requestPermissionsSuccess();
            } else {
                //权限有缺失
                mPermissionInterface.requestPermissionsFail();
            }
            return true;
        }
        return false;
    }
}

OpenAccessoryReceiver.java:

public class OpenAccessoryReceiver extends BroadcastReceiver {

    private OpenAccessoryListener mOpenAccessoryListener;

    public OpenAccessoryReceiver(OpenAccessoryListener openAccessoryListener) {
        mOpenAccessoryListener = openAccessoryListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        UsbAccessory usbAccessory = intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
            if (usbAccessory != null) {
                mOpenAccessoryListener.openAccessoryModel(usbAccessory);
            } else {
                mOpenAccessoryListener.openAccessoryError();
            }
        } else {
            mOpenAccessoryListener.openAccessoryError();
        }
    }

    public interface OpenAccessoryListener {
        /**
         * 打开Accessory模式
         *
         * @param usbAccessory
         */
        void openAccessoryModel(UsbAccessory usbAccessory);

        /**
         * 打开设备(手机)失败
         */
        void openAccessoryError();
    }
}

MainActivity.java:

package com.example.android.wifi_factory_test;

import android.Manifest;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import com.example.android.wifi_interface.PermissionInterface;
import com.example.android.wifi_receiver.OpenAccessoryReceiver;
import com.example.android.wifi_receiver.UsbDetachedReceiver;
import com.google.gson.Gson;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MainActivity extends Activity implements View.OnClickListener, PermissionInterface, UsbDetachedReceiver.UsbDetachedListener,
        OpenAccessoryReceiver.OpenAccessoryListener {
    private static final int SEND_MESSAGE_SUCCESS     = 0;
    private static final int RECEIVER_MESSAGE_SUCCESS = 1;
    private static final int FIND_TESTING_WIFI = 2;
    private static final int SEND_TEST_RESULT = 3;
    private static final int SHOW_TESTED_TIMES = 4;

    private static final int UPDATE_AP_LIST = 100;
    public static final int REQUEST_CODE = 10;
    public static final String TEST_WIFI_NAME = "wifi-test";
    public static final String SHAREDATA = "ShareData";
    public static final String MINVALUE = "minValue";
    public static final String MAXVALUE = "maxValue";
    public static final String USB_ACTION = "com.tcl.navigator.accessorychart";
    public static final String TEST_PASSED = "Passed";
    public static final String TEST_FAIL = "Fail";
    private static final String PASSWORD = "121212";

    private Context mContext;
    private WifiManager mWifiManager = null;
    private MyHandle mHandler = null;

    private WiFi_ListView_Adapter mWiFiListViewAdapter = null;
    private ListView mWiFiListView = null;
    private Button mUpdateButton = null;
    private Button mReturnLevelButton = null;
    private Button mSaveButton = null;
    private TextView mWiFiName = null;
    private TextView mWiFiLevel = null;
    private TextView mWifiTestTimes = null;
    private EditText mEditTextMin = null;
    private EditText mEditTextMax = null;
    private String mCurrentApName;

    private LinearLayout mLlEnter;
    private LinearLayout mLlRange;
    private LinearLayout mLlPassword;
    private Button mEnterButton;
    private EditText mPasswordEdit;
    private TextView mPasswordText;

    private PermissionHelper mPermissionHelper;

    List<ScanResult> mScanResultList;
    WifiUtils mWifiUtils = null;

    private SharedPreferences mPreferences;
    private UsbManager mUsbManager;
    private ExecutorService mThreadPool;
    private UsbDetachedReceiver mUsbDetachedReceiver;
    private OpenAccessoryReceiver mOpenAccessoryReceiver;
    private ParcelFileDescriptor mParcelFileDescriptor;
    private FileInputStream mFileInputStream;
    private FileOutputStream mFileOutputStream;
    private byte[] mBytes = new byte[1024];
    private StringBuffer mStringBuffer = new StringBuffer();

    private HandleMessages mHandleMessages;
    private int mPassedMinValue;
    private int mPassedMaxValue;

    private Timer mTimer;
    private int mFindTestingSsidCount = 0;
    private final int mFindTestingSsidCountMaxCount = 10;

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

        mContext = MainActivity.this;
        mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);

        mHandleMessages = new HandleMessages(this);

        mPreferences = mContext.getSharedPreferences(SHAREDATA, Context.MODE_PRIVATE);
        mPassedMinValue = mPreferences.getInt(MINVALUE, -55);
        mPassedMaxValue = mPreferences.getInt(MAXVALUE, -30);

        Log.d("wujiang","onCreate: mPassedMaxValue = " + mPassedMaxValue);
        Log.d("wujiang","onCreate: mPassedMaxValue = " + mPassedMaxValue);


        mScanResultList = new ArrayList<>();
        mWifiUtils = new WifiUtils(mContext);
        mCurrentApName = TEST_WIFI_NAME;

        //初始化并发起权限申请
        mPermissionHelper = new PermissionHelper(this, this);
        mPermissionHelper.requestPermissions();

        //requestWiFiPermission();
    }

    /*public void requestWiFiPermission() {
        //判断是否已经赋予权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            //如果应用之前请求过此权限但用户拒绝了请求，此方法将返回 true。
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
                //这里可以写个对话框之类的项向用户解释为什么要申请权限，并在对话框的确认键后续再次申请权限
            } else {
                //申请权限，字符串数组内是一个或多个要申请的权限，1是申请权限结果的返回参数，在onRequestPermissionsResult可以得知申请结果
                ActivityCompat.requestPermissions(this, getPermissions(), REQUEST_CODE);
            }
        } else {
            initViews();
        }
    }*/

    private void initViews() {
        mLlEnter = findViewById(R.id.ll_enter);
        mEnterButton = findViewById(R.id.enter_button);
        mPasswordText = findViewById(R.id.password_text);
        mPasswordEdit = findViewById(R.id.password_edit);
        mLlRange = findViewById(R.id.ll_range);
        mLlPassword = findViewById(R.id.ll_password);

        mWiFiListView = findViewById(R.id.wifiListView);
        mUpdateButton = findViewById(R.id.update);
        mReturnLevelButton = findViewById(R.id.return_value);
        mSaveButton = findViewById(R.id.save);
        mWiFiName = findViewById(R.id.txt_wifi_name);
        mWiFiLevel = findViewById(R.id.txt_wifi_level);
        mWifiTestTimes = findViewById(R.id.txt_test_times);
        mEditTextMin = findViewById(R.id.min_value);
        mEditTextMax = findViewById(R.id.max_value);
        mWiFiListViewAdapter = new WiFi_ListView_Adapter(this);
        mWiFiListView.setAdapter(mWiFiListViewAdapter);
        mHandler = new MyHandle();
        mUpdateButton.setOnClickListener(this);
        mReturnLevelButton.setOnClickListener(this);
        mSaveButton.setOnClickListener(this);
        mEnterButton.setOnClickListener(this);

        mEditTextMin.setHint(String.valueOf(mPassedMinValue * (-1)));
        mEditTextMax.setHint(String.valueOf(mPassedMaxValue * (-1)));

        mWiFiListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                mCurrentApName = mWiFiListViewAdapter.getClickPointApName(position);
                Log.d("wujiang","mCurrentApName = " + mCurrentApName);
                //Toast.makeText(MainActivity.this, mCurrentApName, Toast.LENGTH_LONG).show();
                showWiFiInfor(mCurrentApName);
            }
        });

        mEditTextMin.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (s != null && s.length() >0) {
                    mPassedMinValue = Integer.parseInt(s.toString()) * (-1);
                    Log.d("wujiang", "mPassedMinValue = " + mPassedMinValue);
                }
            }

            @Override
            public void afterTextChanged(Editable s) {

            }
        });

        mEditTextMax.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (s != null && s.length() > 0) {
                    mPassedMaxValue = Integer.parseInt(s.toString()) * (-1);
                    Log.d("wujiang", "mPassedMaxValue = " + mPassedMaxValue);
                }
            }

            @Override
            public void afterTextChanged(Editable s) {

            }
        });

        mPasswordEdit.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (s != null && s.length() > 0) {
                    if (s.toString().equals(PASSWORD)) {
                        mLlEnter.setVisibility(View.GONE);
                        mLlRange.setVisibility(View.VISIBLE);
                    }
                }
            }

            @Override
            public void afterTextChanged(Editable s) {

            }
        });

        mUpdateButton.requestFocus();

        mLlRange.setVisibility(View.GONE);

        wifiResume();
        updateUI();
    }

    private void initData() {
        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        mThreadPool = Executors.newFixedThreadPool(3);

        mUsbDetachedReceiver = new UsbDetachedReceiver(this);
        IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
        registerReceiver(mUsbDetachedReceiver, filter);

        mOpenAccessoryReceiver = new OpenAccessoryReceiver(this);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(USB_ACTION), 0);
        IntentFilter intentFilter = new IntentFilter(USB_ACTION);
        registerReceiver(mOpenAccessoryReceiver, intentFilter);

        IntentFilter wifiResultIntentFilter = new IntentFilter();
        wifiResultIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        registerReceiver(mWifiResultAvailableReceiver, wifiResultIntentFilter);

        UsbAccessory[] accessories = mUsbManager.getAccessoryList();
        UsbAccessory usbAccessory = (accessories == null ? null : accessories[0]);
        if (usbAccessory != null) {
            if (mUsbManager.hasPermission(usbAccessory)) {
                openAccessory(usbAccessory);
            } else {
                mUsbManager.requestPermission(usbAccessory, pendingIntent);
            }
        }
    }


    /**
     * 打开Accessory模式
     *
     * @param usbAccessory
     */
    private void openAccessory(UsbAccessory usbAccessory) {
        mParcelFileDescriptor = mUsbManager.openAccessory(usbAccessory);
        if (mParcelFileDescriptor != null) {
            FileDescriptor fileDescriptor = mParcelFileDescriptor.getFileDescriptor();
            mFileInputStream = new FileInputStream(fileDescriptor);
            mFileOutputStream = new FileOutputStream(fileDescriptor);

            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    int i = 0;
                    while (i >= 0) {
                        try {
                            i = mFileInputStream.read(mBytes);
                        } catch (IOException e) {
                            e.printStackTrace();
                            break;
                        }
                        if (i > 0) {
                            mHandler.sendEmptyMessage(UPDATE_AP_LIST);
                            mStringBuffer.setLength(0);
                            mStringBuffer.append(new String(mBytes, 0, i)); //后面不能加换行符
                            mCurrentApName = mStringBuffer.toString();

                            Log.d("wujiang", "openAccessory: mCurrentApName = " + mCurrentApName);
                            Log.d("wujiang", "openAccessory: send FIND_TESTING_WIFI");
                            mHandler.sendEmptyMessage(FIND_TESTING_WIFI);

                            /*String receive_ssid = mStringBuffer.toString();
                            Message msg = Message.obtain();
                            msg.what = RECEIVER_MESSAGE_SUCCESS;
                            msg.obj = receive_ssid;
                            mHandler.sendMessageDelayed(msg, 3000);*/
                        }
                    }
                }
            });
        }
    }

    private void showWifiInfo(int index) {
        int level;
        mWiFiName.setText(mScanResultList.get(index).SSID);
        level = mWifiUtils.getWifiLevel(mScanResultList.get(index));
        mWiFiLevel.setText(String.valueOf(level));
    }

    private void showWiFiInfor(String apName) {
        int level = -100;
        int i;
        mScanResultList = mWiFiListViewAdapter.getScanResultList();

        mWiFiName.setText(apName);
        mWiFiLevel.setText(String.valueOf(level));

        if (mScanResultList.size() >0 ) {
           for(i=0; i<mScanResultList.size(); i++) {
                if (mScanResultList.get(i).SSID.equals(apName)) {
                    mWiFiName.setText(mScanResultList.get(i).SSID);
                    level = mWifiUtils.getWifiLevel(mScanResultList.get(i));
                    mWiFiLevel.setText(String.valueOf(level));
                    break;
                }
            }

            if (i >= mScanResultList.size()) {
                mWiFiLevel.setText("-100");
            }
        }
    }

    private void sendTestResult() {
        int testValue;

        testValue = Integer.parseInt(mWiFiLevel.getText().toString());
        Log.d("wujiang", "sendTestResult: testValue = " + testValue);

        if (testValue >= mPassedMinValue && testValue <= mPassedMaxValue) {
            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Gson gson = new Gson();
                        WifiInfor wifiInfor = new WifiInfor(mWiFiName.getText().toString(), mWiFiLevel.getText().toString(), TEST_PASSED);
                        String mSendMessageContent = gson.toJson(wifiInfor);
                        mFileOutputStream.write(mSendMessageContent.getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        } else {
            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Gson gson = new Gson();
                        WifiInfor wifiInfor = new WifiInfor(mWiFiName.getText().toString(), mWiFiLevel.getText().toString(), TEST_FAIL);
                        String mSendMessageContent = gson.toJson(wifiInfor);
                        mFileOutputStream.write(mSendMessageContent.getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.enter_button:
                mEnterButton.setVisibility(View.GONE);
                mLlPassword.setVisibility(View.VISIBLE);
                mPasswordEdit.setText("");
                break;

            case R.id.update:
                wifiResume();
                break;

            case R.id.return_value:
                //sendTestResult();
                break;

            case R.id.save:
                int temp;
                SharedPreferences.Editor editor = mPreferences.edit();

                if(mPassedMinValue > mPassedMaxValue) {
                    temp = mPassedMinValue;
                    mPassedMinValue = mPassedMaxValue;
                    mPassedMaxValue = temp;
                }

                Log.d("wujiang", "onClick: mPassedMinValue = " + mPassedMinValue);
                Log.d("wujiang", "onClick: mPassedMaxValue = " + mPassedMaxValue);

                editor.putInt(MINVALUE, mPassedMinValue);
                editor.putInt(MAXVALUE, mPassedMaxValue);
                editor.commit();
                Toast.makeText(mContext, "保存成功", Toast.LENGTH_SHORT).show();

                mLlEnter.setVisibility(View.VISIBLE);
                mLlRange.setVisibility(View.GONE);

                mEnterButton.setVisibility(View.VISIBLE);
                mLlPassword.setVisibility(View.GONE);

                break;

            default:
                break;
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
    }

    @Override
    protected void onDestroy() {
        mHandler.removeCallbacksAndMessages(null);
        super.onDestroy();

        unregisterReceiver(mOpenAccessoryReceiver);
        unregisterReceiver(mUsbDetachedReceiver);
        unregisterReceiver(mWifiResultAvailableReceiver);

        if (mParcelFileDescriptor != null) {
            try {
                mParcelFileDescriptor.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mFileInputStream != null) {
            try {
                mFileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mFileOutputStream != null) {
            try {
                mFileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        if(mPermissionHelper.requestPermissionsResult(requestCode, permissions, grantResults)){
            //权限请求结果，并已经处理了该回调
            return;
        }
    }

    private void wifiResume() {
        mWifiManager.setWifiEnabled(true);
        mWifiManager.startScan();
        mHandleMessages.showMessage("", "Scanning...");
    }

    private void updateUI() {
        mWiFiListViewAdapter.updateAccesspointList();
    }

    @Override
    public int getPermissionsRequestCode() {
        //设置权限请求requestCode，只有不跟onRequestPermissionsResult方法中的其他请求码冲突即可。
        return REQUEST_CODE;
    }

    @Override
    public String[] getPermissions() {
        //设置该界面所需的全部权限
        return new String[]{
                Manifest.permission.INTERNET,
                Manifest.permission.CHANGE_WIFI_STATE,
                Manifest.permission.ACCESS_WIFI_STATE,
                Manifest.permission.ACCESS_NETWORK_STATE,
                Manifest.permission.CHANGE_NETWORK_STATE,
                Manifest.permission.ACCESS_FINE_LOCATION,
                Manifest.permission.ACCESS_COARSE_LOCATION,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
        };
    }

    @Override
    public void requestPermissionsSuccess() {
        initViews();

        initData();
    }

    @Override
    public void requestPermissionsFail() {
        //权限请求不被用户允许。可以提示并退出或者提示权限的用途并重新发起权限申请。
        Log.d("wujiang","requestPermissionsFail");
        Toast.makeText(this, "Your have no permission ", Toast.LENGTH_LONG).show();
    }

    @Override
    public void usbDetached() {
        finish();
    }

    @Override
    public void openAccessoryModel(UsbAccessory usbAccessory) {
        openAccessory(usbAccessory);
    }

    @Override
    public void openAccessoryError() {

    }

    private class MyHandle extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_AP_LIST:
                    wifiResume();
                    break;

                case SEND_MESSAGE_SUCCESS:
                    Log.d("wujiang", "receive SEND_MESSAGE_SUCCESS");
                    Toast.makeText(MainActivity.this, "返回结果成功",Toast.LENGTH_SHORT).show();
                    break;

                case RECEIVER_MESSAGE_SUCCESS:
                    Log.d("wujiang", "receive RECEIVER_MESSAGE_SUCCESS");
                    //mCurrentApName = (String) msg.obj;
                    showWiFiInfor(mCurrentApName);
                    mHandler.sendEmptyMessageDelayed(SEND_TEST_RESULT, 500);
                    break;

                case FIND_TESTING_WIFI:
                    Log.d("wujiang", "receive FIND_TESTING_WIFI");
                    mFindTestingSsidCount = 0;
                    mTimer = new Timer();
                    mTimer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            mFindTestingSsidCount++;
                            Log.d("wujiang", "mFindTestingSsidCount = " + mFindTestingSsidCount);
                            mScanResultList = mWiFiListViewAdapter.getScanResultList();
                            mHandler.sendEmptyMessage(SHOW_TESTED_TIMES);

                            if (mFindTestingSsidCount >= mFindTestingSsidCountMaxCount) {
                                if (mTimer != null) {
                                    mTimer.cancel();
                                }
                                Log.d("wujiang", "send msg RECEIVER_MESSAGE_SUCCESS for find max time in timer");
                                mHandler.removeMessages(UPDATE_AP_LIST);
                                mHandler.sendEmptyMessage(RECEIVER_MESSAGE_SUCCESS);
                            } else {
                                Log.d("wujiang", "send msg UPDATE_AP_LIST in timer");
                                mHandler.sendEmptyMessage(UPDATE_AP_LIST);
                            }
                        }
                    }, 100, 3000);

                    break;

                case SEND_TEST_RESULT:
                    sendTestResult();
                    break;

                case SHOW_TESTED_TIMES:
                    mWifiTestTimes.setText(String.valueOf(mFindTestingSsidCount));
                    break;

                default:
                    break;
            }
        }
    }

    public class WifiInfor {
        public String apSsid;
        public String apLevel;
        public String testResult;

        public WifiInfor(String ssid, String level, String result) {
            apSsid = ssid;
            apLevel = level;
            testResult = result;
        }

        public String getApSsid() {
            return apSsid;
        }

        public String getApLevel() {
            return apLevel;
        }

        public String getTestResult() {
            return testResult;
        }
    }

    private BroadcastReceiver mWifiResultAvailableReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (Objects.equals(action, WifiManager.SCAN_RESULTS_AVAILABLE_ACTION )) {
                mHandleMessages.endMessage();
                updateUI();
                showWiFiInfor(mCurrentApName);
            }
        }
    };
}

WiFi_ListView_Adapter.java:

public class WiFi_ListView_Adapter extends BaseAdapter {
    private Context mContext;
    private LayoutInflater mInflater;
    List<ScanResult> mScanResultList;
    WifiUtils mWifiUtils = null;

    public final static int[] wifi_level_drawable = {R.drawable.wifi_level_02, R.drawable.wifi_level_03, R.drawable.wifi_level_04, R.drawable.wifi_level_05 };

    public WiFi_ListView_Adapter(Context context) {
        this.mContext = context;
        this.mInflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        this.mScanResultList = new ArrayList<>();
        this.mWifiUtils = new WifiUtils(mContext);
    }

    @Override
    public int getCount() {
        if (mScanResultList == null) {
            return 0;
        }

        Log.d("wujiang", "getCount = " + mScanResultList.size());
        return mScanResultList.size();
    }

    @Override
    public Object getItem(int index) {
        if (mScanResultList != null) {
            return mScanResultList.get(index);
        }
        return null;
    }

    @Override
    public long getItemId(int arg0) {
        return arg0;
    }

    class sortByLevel implements Comparator<ScanResult> {
        public int compare(ScanResult obj1, ScanResult obj2) {
            if (obj1.level > obj2.level)
                return 1;
            else
                return 0;
        }
    }

    public void updateAccesspointList() {
        mScanResultList = mWifiUtils.getWifiAccessPointList();
        Log.d("wujiang", "updateAccesspointList: mScanResultList size = " + mScanResultList.size());
        notifyDataSetChanged();
    }

    public int getCurrentAccessPointSecurityType(int index) {
        return mWifiUtils.getSecurityType(mScanResultList.get(index));
    }

    public String getClickPointApName(int index) {
        return mScanResultList.get(index).SSID;
    }

    public List<ScanResult> getScanResultList() {
        return mScanResultList;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ItemViewHolder holder;

        if (convertView == null) {
            convertView = LayoutInflater.from(mContext).inflate(R.layout.accesspoint_item, null);
            holder = new ItemViewHolder();
            holder.wifi_lock = convertView.findViewById(R.id.lock);
            holder.wifi_ap_name = convertView.findViewById(R.id.wifiName);
            holder.wifi_level = convertView.findViewById(R.id.level);
            holder.wifi_level_value = convertView.findViewById(R.id.level_value);
            holder.wifi_level_value.setTextColor(Color.RED);
            convertView.setTag(holder);
        } else {
            holder = (ItemViewHolder) convertView.getTag();
        }

        int level = mWifiUtils.getWifiLevel(mScanResultList.get(position));
        holder.wifi_level.setBackgroundResource(wifi_level_drawable[WifiManager.calculateSignalLevel(level, 4)]);

        if (getCurrentAccessPointSecurityType(position) == 0 || getCurrentAccessPointSecurityType(position) == 4) {
            holder.wifi_lock.setVisibility(View.INVISIBLE);
        } else {
            holder.wifi_lock.setVisibility(View.VISIBLE);
        }

        holder.wifi_ap_name.setText(mScanResultList.get(position).SSID);

        holder.wifi_level_value.setText(String.valueOf(level));

        Log.d("wujiang", "getView: SSID = " + mScanResultList.get(position).SSID);
        Log.d("wujiang", "getView: level = " + mScanResultList.get(position).level);

        return convertView;
    }

    public class ItemViewHolder {
        public ImageView    wifi_lock;
        public TextView     wifi_ap_name;
        public ImageView    wifi_level;
        public TextView     wifi_level_value;
    }
}

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="0px"
        android:layout_height="0px"
        android:focusable="true"
        android:focusableInTouchMode="true">
    </LinearLayout>

    <LinearLayout
        android:id="@+id/ll_enter"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:background="@android:color/darker_gray"
        android:gravity="center"
        android:orientation="horizontal">

        <Button
            android:id="@+id/enter_button"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:layout_weight="1"
            android:background="@android:color/transparent"
            android:text="设置"
            android:textColor="@android:color/black" />

        <LinearLayout
            android:id="@+id/ll_password"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="2"
            android:gravity="center"
            android:orientation="horizontal"
            android:visibility="gone">

            <TextView
                android:id="@+id/password_text"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:text="输入密码: "
                android:textColor="@android:color/black" />

            <EditText
                android:id="@+id/password_edit"
                android:layout_width="120dp"
                android:layout_height="match_parent"
                android:gravity="center_vertical"
                android:inputType="numberDecimal"
                android:textColor="@android:color/black" />
        </LinearLayout>
    </LinearLayout>

    <LinearLayout
        android:id="@+id/ll_range"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:background="@android:color/darker_gray"
        android:orientation="horizontal">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="left|center"
            android:gravity="left|center"
            android:paddingLeft="10dp"
            android:text="设置通过范围:"
            android:textColor="@android:color/black" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="left|center"
            android:gravity="left|center"
            android:paddingLeft="10dp"
            android:text="-"
            android:textColor="@android:color/holo_red_light"
            android:textSize="24sp" />

        <EditText
            android:id="@+id/min_value"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:gravity="left|center"
            android:inputType="numberDecimal"
            android:textColor="@android:color/black" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:gravity="center"
            android:text="到"
            android:textColor="@android:color/black" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="left|center"
            android:gravity="center"
            android:paddingLeft="10dp"
            android:text="-"
            android:textColor="@android:color/holo_red_light"
            android:textSize="24sp" />

        <EditText
            android:id="@+id/max_value"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:gravity="left|center"
            android:inputType="numberDecimal"
            android:textColor="@android:color/black" />

        <Button
            android:id="@+id/save"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:text="保存生效"
            android:textColor="@android:color/black" />
    </LinearLayout>

    <ListView
        android:id="@+id/wifiListView"
        android:layout_width="360dp"
        android:layout_height="290dp"
        android:layout_gravity="center"
        android:background="@drawable/wifi_background">
    </ListView>

    <LinearLayout
        android:layout_width="360dp"
        android:layout_height="35dp"
        android:layout_gravity="center"
        android:background="@android:color/darker_gray"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="0.7"
            android:gravity="left|center"
            android:paddingLeft="10dp"
            android:singleLine="true"
            android:text="WiFi名称: "
            android:textColor="@android:color/black"
            android:textSize="20sp" />

        <TextView
            android:id="@+id/txt_wifi_name"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="left|center"
            android:singleLine="true"
            android:textColor="@android:color/black"
            android:textSize="25sp" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="360dp"
        android:layout_height="35dp"
        android:layout_gravity="center"
        android:background="@android:color/darker_gray"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="0.7"
            android:gravity="left|center"
            android:paddingLeft="10dp"
            android:text="信号强度: "
            android:textColor="@android:color/black"
            android:textSize="20sp" />

        <TextView
            android:id="@+id/txt_wifi_level"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="center|left"
            android:textColor="@android:color/black"
            android:textSize="25sp" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="360dp"
        android:layout_height="35dp"
        android:layout_gravity="center"
        android:background="@android:color/darker_gray"
        android:orientation="horizontal">

        <TextView
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="0.7"
            android:gravity="left|center"
            android:paddingLeft="10dp"
            android:singleLine="true"
            android:text="刷新次数: "
            android:textColor="@android:color/black"
            android:textSize="20sp" />

        <TextView
            android:id="@+id/txt_test_times"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="left|center"
            android:singleLine="true"
            android:textColor="@android:color/black"
            android:textSize="25sp" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:gravity="center"
        android:orientation="horizontal">

        <Button
            android:id="@+id/update"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:text="刷新" />

        <Button
            android:id="@+id/return_value"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:text="返回结果"
            android:textAllCaps="false"
            android:visibility="gone" />

    </LinearLayout>


</LinearLayout>

AndroidManifest:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.wifi_factory_test">

    <!--android:sharedUserId="android.uid.system"-->

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

    <uses-feature android:name="android.hardware.usb.accessory"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <action android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"/>

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            <meta-data
                android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"
                android:resource="@xml/accessory_filter"/>
        </activity>
    </application>

</manifest>

xml/accessory_filter.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!--<usb-accessory />-->
    <usb-accessory
        manufacturer="Google, Inc."
        model="AccessoryChat"
        type="Sample Program"
        version="1.0"/>
</resources>

accesspoint_item.xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content">

    <TextView
        android:id="@+id/wifiName"
        android:layout_width="220dp"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_centerVertical="true"
        android:layout_marginLeft="10dp"
        android:ellipsize="marquee"
        android:singleLine="true"
        android:textColor="@android:color/white"
        android:textSize="22dp" />

    <ImageView
        android:id="@+id/lock"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_toLeftOf="@id/level"
        android:src="@drawable/lock">
    </ImageView>

    <ImageView
        android:id="@+id/level"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:layout_centerVertical="true"
        android:layout_marginRight="10dp">
    </ImageView>

    <TextView
        android:id="@+id/level_value"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_toLeftOf="@id/lock" />

</RelativeLayout>

build gradle里的dependencies里加上implementation 'com.google.code.gson:gson:2.8.5'

THE END

wujiang_android

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
android盒子与手机相互通讯

android的盒子大多数是有USB接口的，USB接口可以连接手机的。如果我们需要盒子和手机相互通讯，怎么实现呢？下面给出我的工程代码，测试盒子wifi信号用的，通讯的关键代码需自己去体会啦。盒子端：OpenDevicesReceiver.java:public class OpenDevicesReceiver extends BroadcastRecei...
复制链接

扫一扫