Java 使用线程和USB连接后的空白应用程序屏幕

我是Android的初学者。我试图开发一个通过USB连接进行通信的基本应用程序。我必须等待传入的数据，因为我真的不知道它是在什么时候出现的，所以我用而（true）解决了它。对于这个while循环，我尝试使用线程。我没有太多的线程经验

但问题是，现在每当我按下手机上的后退按钮，然后我再次尝试打开我的应用程序时，它只会显示一个空白的应用程序屏幕

你能帮我吗？谢谢

主要活动类别：

public class MainActivity extends AppCompatActivity {

UsbDevice device;
Button bShow;
private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
UsbManager mUsbManager;
PendingIntent mPermissionIntent;
TextView tvTest, tvAppend;
String sendText = "@V\r\n";
private byte[] bytes;
private static int TIMEOUT = 0;
private boolean forceClaim = true;
int controlTransferResult;
byte[] readBytes = new byte[128];
//byte[] data = new byte[4096];
UsbEndpoint epOut = null, epIn = null;
UsbDeviceConnection connection;
int recvBytes;
String readString = "";
Thread thread;
Runnable r;
UsbInterface intf;

Handler handler= new Handler(){
    @Override
    public void handleMessage(Message msg) {
        tvAppend.append(readString);
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    tvTest = (TextView) findViewById(R.id.textView);
    tvAppend = (TextView) findViewById(R.id.textView2);
    bShow= (Button)findViewById(R.id.button);
    showData();

}

@Override
public void onPause() {
    super.onPause();  // Always call the superclass method first
    thread.interrupt();
}

@Override
protected void onStop() {
    super.onStop();
    thread.interrupt();

}

@Override
protected void onResume() {
    super.onResume();
    thread = new Thread(r);
    thread.start();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    thread.interrupt();

}

@Override
protected void onRestart() {
    super.onRestart();
    thread = new Thread(r);
    thread.start();
}

public void showData(){
    UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
    HashMap<String, UsbDevice> deviceList = manager.getDeviceList();

    if(deviceList.toString().equals("{}")){
        Toast.makeText(MainActivity.this,"No USB device found!", Toast.LENGTH_SHORT).show();
        return;
    }else{
        tvTest.setText(deviceList.toString());
    }
    Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
    device = deviceIterator.next();
    mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
    IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
    registerReceiver(mUsbReceiver, filter);
    mUsbManager.requestPermission(device, mPermissionIntent);

    bShow.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            r = new Runnable() {
                @Override
                public void run() {
                    synchronized (this) {
                        while (true) {
                            Arrays.fill(readBytes, (byte) 0);

                            recvBytes = connection.bulkTransfer(epIn, readBytes, readBytes.length, 0);
                            if (recvBytes != 2) {
                                readString = new String(readBytes);
                                readString = readString.replace("\u0001`","");
                                handler.sendEmptyMessage(0);
                            }

                        }
                    }
                }

            };
            thread = new Thread(r);
            thread.start();
        }
    });
}
private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {

    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (ACTION_USB_PERMISSION.equals(action)) {
            synchronized (this) {
                UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    if(device != null){
                        //call method to set up device communication
                        intf = device.getInterface(0);

                        // look for our bulk endpoints
                        for (int i = 0; i < intf.getEndpointCount(); i++) {
                            UsbEndpoint ep = intf.getEndpoint(i);

                            if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                                if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
                                    epOut = ep;
                                } else if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
                                    epIn = ep;
                                }
                            }
                        }
                        if (epOut == null || epIn == null) {
                            throw new IllegalArgumentException("Not all endpoints found.");
                        }
                        connection = mUsbManager.openDevice(device);
                        connection.claimInterface(intf, forceClaim);
                        bytes = sendText.getBytes();
                        tvAppend.setText("a" +  bytes.length);
                        connection.controlTransfer(0x40, 0, 0, 0, null, 0, 0);// reset
                        connection.controlTransfer(0x40, 0, 1, 0, null, 0, 0);// clear Rx
                        connection.controlTransfer(0x40, 0, 2, 0, null, 0, 0);// clear Tx
                        controlTransferResult = connection.controlTransfer(0x40, 0x03, 0x4138, 0, null, 0, 0);
                        ByteBuffer buffer = ByteBuffer.allocate(bytes.length+1);
                        UsbRequest request = new UsbRequest();
                        buffer.put(bytes);
                        request.initialize(connection, epOut);
                        request.queue(buffer, bytes.length);



                    }
                }
                else {
                    Log.d("MyActivity", "permission denied for device " + device);
                }
            }
        }
    }
};


}

public类MainActivity扩展了AppCompatActivity{
USB设备；
按钮显示；
私有静态最终字符串操作\u USB\u PERMISSION=“com.android.example.USB\u PERMISSION”；
UsbManager musbanager；
悬而未决的犯罪意图；
文本视图tvTest，tvAppend；
字符串sendText=“@V\r\n”；
专用字节[]字节；
私有静态int超时=0；
私有布尔forceClaim=true；
int控制传递结果；
字节[]读取字节=新字节[128]；
//字节[]数据=新字节[4096]；
UsbEndpoint epOut=null，epIn=null；
UsbDeviceConnection连接；
int recvBytes；
字符串readString=“”；
螺纹；
可运行r；
UsbInterface intf；
Handler=newhandler（）{
@凌驾
公共无效handleMessage（消息消息消息）{
append.append（readString）；
}
};
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
tvTest=（TextView）findViewById（R.id.TextView）；
tvAppend=（TextView）findViewById（R.id.textView2）；
bShow=（按钮）findViewById（R.id.Button）；
showData（）；
}
@凌驾
公共无效暂停（）{
super.onPause（）；//始终首先调用超类方法
thread.interrupt（）；
}
@凌驾
受保护的void onStop（）{
super.onStop（）；
thread.interrupt（）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
螺纹=新螺纹（r）；
thread.start（）；
}
@凌驾
受保护的空onDestroy（）{
super.ondestory（）；
thread.interrupt（）；
}
@凌驾
受保护的void onRestart（）{
super.onRestart（）；
螺纹=新螺纹（r）；
thread.start（）；
}
公共void showData（）{
UsbManager manager=（UsbManager）getSystemService（Context.USB_服务）；
HashMap deviceList=manager.getDeviceList（）；
if（deviceList.toString（）.equals（“{}”））{
Toast.makeText（MainActivity.this，“未找到USB设备！”，Toast.LENGTH\u SHORT.show（）；
返回；
}否则{
tvetest.setText（deviceList.toString（））；
}
迭代器deviceIterator=deviceList.values（）.Iterator（）；
device=deviceIterator.next（）；
mUsbManager=（UsbManager）getSystemService（Context.USB_服务）；
mPermissionIntent=PendingIntent.getBroadcast（this，0，新意图（ACTION\u USB\u权限），0）；
IntentFilter筛选器=新建IntentFilter（操作\u USB\u权限）；
寄存器接收器（mUsbReceiver，过滤器）；
请求权限（设备、mPermissionIntent）；
bShow.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
r=新的可运行（）{
@凌驾
公开募捐{
已同步（此）{
while（true）{
数组.fill（readBytes，（byte）0）；
recvBytes=connection.bulkTransfer（epIn，readBytes，readBytes.length，0）；
如果（recvBytes！=2）{
readString=新字符串（readBytes）；
readString=readString.replace（“\u0001`”，”）；
handler.sendEmptyMessage（0）；
}
}
}
}
};
螺纹=新螺纹（r）；
thread.start（）；
}
});
}
专用最终广播接收器mUsbReceiver=新广播接收器（）{
公共void onReceive（上下文、意图）{
String action=intent.getAction（）；
if（动作\u USB\u权限等于（动作））{
已同步（此）{
UsbDevice设备=（UsbDevice）intent.getParcelableExtra（UsbManager.EXTRA_设备）；
if（intent.getBooleanExtra（UsbManager.EXTRA_权限_授予，false））{
如果（设备！=null）{
//调用方法来设置设备通信
intf=device.getInterface（0）；
//寻找我们的批量端点
对于（int i=0；i