使用UsbDeviceConnection android重新启动后，热敏打印机仅打印一次

在我的一个android应用程序中，我集成了一个功能，可以使用热敏打印机直接从应用程序打印收据。我正在使用“UsbDeviceConnection”类打印我的收据

这不是每次都能正常工作。比如，如果我打印收据，它会打印一次，如果我再次发送打印，它会将所有字节写入打印机连接，但实际上它不会打印收据

若要再次打印收据，我必须重新启动打印机一次。所以，如果我将重新启动热敏打印机，那么我可以再次打印收据

我正在使用下课打印收据

public class UsbCommunicator {

    private UsbManager mUsbManager;
    private PendingIntent mPermissionIntent;
    private UsbDevice selectedUsbDevice;
    private UsbInterface selectedUsbInterface;
    private int endpointOutId;
    private int endpointInId;
    private final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";

    public UsbCommunicator2(Context context) {
        // Create USB manager
        mUsbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);

        // Set USB permissions broadcaster
        mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0);
        context.registerReceiver(mUsbReceiver, new IntentFilter(ACTION_USB_PERMISSION));
    }

    public ArrayList<UsbDevice> getConnectedDevices() {
        ArrayList<UsbDevice> usbDevices = new ArrayList<>();
        // Get every connected USB device and store in HashMap
        HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
        Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
        // Loop through every connected USB device
        while (deviceIterator.hasNext()) {
            UsbDevice device = deviceIterator.next();
            usbDevices.add(device);
        }
        return usbDevices;
    }

    public void setDevice(UsbDevice device) {
        if (!mUsbManager.hasPermission(device))
            mUsbManager.requestPermission(device, mPermissionIntent);
        else {
            selectedUsbDevice = device;
            setDeviceInterface(device);
            setDeviceEndpoints(device);
        }
    }

    public void sendData(byte[] bytes, CommunicationListener commListener) {
        if (!deviceSelected() || !hasPermission()) return;
        UsbEndpoint outputEndpoint = selectedUsbInterface.getEndpoint(endpointOutId);

        new CommunicatorTask(commListener, outputEndpoint, bytes).execute();
    }

    public boolean deviceSelected() {
        return selectedUsbDevice != null ? true : false;
    }

    public boolean hasPermission() {
        return deviceSelected() && mUsbManager.hasPermission(selectedUsbDevice);
    }

    private void setDeviceInterface(UsbDevice device) {
        // Get the device interface, this is known to be 0 for the targetted Star and Sanei devices, but can vary for other devices
        selectedUsbInterface = device.getInterface(0);
    }

    private void setDeviceEndpoints(UsbDevice device) {
        if (selectedUsbInterface == null) return;
        // Loop through every end point on the interface to find the right end points
        for (int i = 0; i < selectedUsbInterface.getEndpointCount(); i++) {
            UsbEndpoint endpoint = selectedUsbInterface.getEndpoint(i);
            if (endpoint.getDirection() == UsbConstants.USB_DIR_OUT)
                endpointOutId = i;
            else if (endpoint.getDirection() == UsbConstants.USB_DIR_IN)
                endpointInId = i;
        }
    }

    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 = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                    // Device permission was granted
                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                        if (device != null) {
                            selectedUsbDevice = device;
                            setDeviceInterface(device);
                            setDeviceEndpoints(device);
                        }
                    }
                }
            }
        }
    };

    private class CommunicatorTask extends AsyncTask<Void, Void, Integer> {

        private CommunicationListener commListener;
        private UsbEndpoint outputEndpoint;
        private byte[] bytes;
        private UsbDeviceConnection connection;

        public CommunicatorTask(CommunicationListener commListener, UsbEndpoint outputEndpoint, byte[] bytes) {
            this.commListener = commListener;
            this.outputEndpoint = outputEndpoint;
            this.bytes = bytes;

            connection = mUsbManager.openDevice(selectedUsbDevice);
            connection.claimInterface(selectedUsbInterface, true);
        }

        protected Integer doInBackground(Void... unused) {
            int bytesWritten = 0;
            while (bytesWritten < bytes.length) {
                bytesWritten += connection.bulkTransfer(outputEndpoint, bytes, bytesWritten, bytes.length - bytesWritten, 0);
            }
            return bytesWritten;
        }

        protected void onPostExecute(Integer bytesTransferred) {
            connection.close();
            commListener.onComplete(bytesTransferred);
        }
    }
}

公共类UsbCommunicator{
私人UsbManager mUsbManager；
私人悬而未决的侵权意图；
专用USB设备选择的USB设备；
专用USB接口选择的USB接口；
私有int-endpointOutId；
私有int端点ID；
私有最终字符串操作\u USB\u PERMISSION=“com.android.example.USB\u PERMISSION”；
公共UsbCommunicator2（上下文）{
//创建USB管理器
mUsbManager=（UsbManager）context.getSystemService（context.USB_服务）；
//设置USB广播权限
mPermissionIntent=pendingent.getBroadcast（上下文，0，新意图（操作权限），0）；
registerReceiver（mUsbReceiver，新的IntentFilter（ACTION_USB_PERMISSION））；
}
公共阵列列表getConnectedDevices（）{
ArrayList usbDevices=新的ArrayList（）；
//获取每个连接的USB设备并存储在HashMap中
HashMap deviceList=mUsbManager.getDeviceList（）；
迭代器deviceIterator=deviceList.values（）.Iterator（）；
//循环通过每个连接的USB设备
while（deviceIterator.hasNext（））{
UsbDevice device=deviceIterator.next（）；
usbDevices.add（设备）；
}
返回usbDevices；
}
公用设备（USB设备）{
如果（！mUsbManager.hasPermission（设备））
请求权限（设备、mPermissionIntent）；
否则{
选择edusbDevice=设备；
设置设备接口（设备）；
设置设备端点（设备）；
}
}
public void sendData（字节[]字节，通信侦听器commListener）{
如果（！deviceSelected（）| |！hasPermission（））返回；
UsbEndpoint outpundpoint=selectedusinterface.getEndpoint（endpointOutId）；
新的通信端口任务（commListener、OutpundPoint、bytes）。执行（）；
}
公共布尔设备selected（）{
返回selectedUsbDevice！=null？真：假；
}
公共权限（）{
返回设备selected（）&&mUsbManager.hasPermission（selectedUsbDevice）；
}
专用void设置设备接口（USB设备）{
//获取设备接口，已知目标Star和Sanei设备的接口为0，但其他设备的接口可能不同
选择EdusInterface=device.getInterface（0）；
}
专用void setDeviceEndpoints（UsbDevice设备）{
if（selectedUsbInterface==null）返回；
//循环遍历接口上的每个端点，以找到正确的端点
对于（int i=0；i

下面是我的活动文件中的代码

UsbCommunicator usbComm = new UsbCommunicator(context);

ArrayList<UsbDevice> connectedDevices = usbComm.getConnectedDevices();

if(connectedDevices.size() == 0) {
    Toast.makeText(context, "No USB Printer Detected", Toast.LENGTH_SHORT).show();
    return;
}

UsbDevice device = connectedDevices.get(0);
usbComm.setDevice(device);
Bytes[] bytes = createSampleReceipt(imgPath); << This method will convert Image to Bytes array

usbComm.sendData(bytes, new CommunicationListener(){

    @Override
    public void onComplete(int bytesTransferred) {
        Toast.makeText(context, "Printer Success", Toast.LENGTH_SHORT).show();
    }
});

UsbCommunicator usbComm=新的UsbCommunicator（上下文）；
ArrayList connectedDevices=usbComm.getConnectedDevices（）；
if（connectedDevices.size（）=0）{
Toast.makeText（上下文，“未检测到USB打印机”，Toast.LENGTH_SHORT.show（）；
返回；
}
UsbDevice device=connectedDevices.get（0）；
usbComm.setDevice（设备）；
Bytes[]Bytes=createSampleCeipt（imgPath） 已经修好了

while (bytesWritten < bytes.length) {
     bytesWritten += connection.bulkTransfer(outputEndpoint, bytes, bytesWritten, bytes.length - bytesWritten, 0);
}

bytesWritten = connection.bulkTransfer(outputEndpoint, bytes, bytes.length, 2000);