通过usb从Android设备向热敏打印机发送数据

我正在从应用程序向热敏打印机发送数据。我已经让它在网络上正常工作，并且我的数据打印正确。现在有一个额外的要求，我们也必须能够通过usb打印

以下是我尝试过的：

    private UsbManager mUsbManager;
    private UsbDevice mDevice;
    private UsbDeviceConnection mConnection;
    private UsbInterface mInterface;
    private UsbEndpoint mEndPoint;
    private PendingIntent mPermissionIntent;
    private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
    private static Boolean forceCLaim = true;

    HashMap<String, UsbDevice> mDeviceList;
    Iterator<UsbDevice> mDeviceIterator;


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

        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        mDeviceList = mUsbManager.getDeviceList();    
        mDeviceIterator = mDeviceList.values().iterator();

        Button print = (Button)findViewById(R.id.print);

        Toast.makeText(this, "Device List Size: " + String.valueOf(mDeviceList.size()), Toast.LENGTH_SHORT).show();
        TextView textView = (TextView) findViewById(R.id.usbDevice);
        String usbDevice = "";
        //This is just testing what devices are connected
        while (mDeviceIterator.hasNext()) {
            UsbDevice usbDevice1 = mDeviceIterator.next();
            usbDevice += "\n" +
                    "DeviceID: " + usbDevice1.getDeviceId() + "\n" +
                    "DeviceName: " + usbDevice1.getDeviceName() + "\n" +
                    "DeviceClass: " + usbDevice1.getDeviceClass() + " - " + translateDeviceClass(usbDevice1.getDeviceClass()) + "\n" +
                    "DeviceSubClass: " + usbDevice1.getDeviceSubclass() + "\n" +
                    "VendorID: " + usbDevice1.getVendorId() + "\n" +
                    "ProductID: " + usbDevice1.getProductId() + "\n";

            int interfaceCount = usbDevice1.getInterfaceCount();
            Toast.makeText(this, "INTERFACE COUNT: " + String.valueOf(interfaceCount), Toast.LENGTH_SHORT).show();

            mDevice = usbDevice1;

            if (mDevice == null) {
                Toast.makeText(this, "mDevice is null", Toast.LENGTH_SHORT).show();
            }else{
                Toast.makeText(this, "mDevice is not null", Toast.LENGTH_SHORT).show();
            }
            textView.setText(usbDevice);
        }

        if (mDevice == null) {
            Toast.makeText(this, "mDevice is null", Toast.LENGTH_SHORT).show();
        }else{
            Toast.makeText(this, "mDevice is not null", Toast.LENGTH_SHORT).show();
        }

        mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
        IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
        registerReceiver(mUsbReceiver, filter);
        mUsbManager.requestPermission(mDevice, mPermissionIntent);

  print.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //setup();
                print(mConnection, mInterface);
            }
        });
}

   private String translateDeviceClass(int deviceClass){
        switch(deviceClass){
            case UsbConstants.USB_CLASS_APP_SPEC:
                return "Application specific USB class";
            case UsbConstants.USB_CLASS_AUDIO:
                return "USB class for audio devices";
            case UsbConstants.USB_CLASS_CDC_DATA:
                return "USB class for CDC devices (communications device class)";
            case UsbConstants.USB_CLASS_COMM:
                return "USB class for communication devices";
            case UsbConstants.USB_CLASS_CONTENT_SEC:
                return "USB class for content security devices";
            case UsbConstants.USB_CLASS_CSCID:
                return "USB class for content smart card devices";
            case UsbConstants.USB_CLASS_HID:
                return "USB class for human interface devices (for example, mice and keyboards)";
            case UsbConstants.USB_CLASS_HUB:
                return "USB class for USB hubs";
            case UsbConstants.USB_CLASS_MASS_STORAGE:
                return "USB class for mass storage devices";
            case UsbConstants.USB_CLASS_MISC:
                return "USB class for wireless miscellaneous devices";
            case UsbConstants.USB_CLASS_PER_INTERFACE:
                return "USB class indicating that the class is determined on a per-interface basis";
            case UsbConstants.USB_CLASS_PHYSICA:
                return "USB class for physical devices";
            case UsbConstants.USB_CLASS_PRINTER:
                return "USB class for printers";
            case UsbConstants.USB_CLASS_STILL_IMAGE:
                return "USB class for still image devices (digital cameras)";
            case UsbConstants.USB_CLASS_VENDOR_SPEC:
                return "Vendor specific USB class";
            case UsbConstants.USB_CLASS_VIDEO:
                return "USB class for video devices";
            case UsbConstants.USB_CLASS_WIRELESS_CONTROLLER:
                return "USB class for wireless controller devices";
            default: return "Unknown USB class!";
        }
//Broadcast receiver to obtain permission from user for connection
 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
                            mInterface = device.getInterface(0);
                            mEndPoint = mInterface.getEndpoint(0);
                            mConnection = mUsbManager.openDevice(device);

                            //setup();
                        }
                    }
                    else {
                        //Log.d("SUB", "permission denied for device " + device);
                        Toast.makeText(context, "PERMISSION DENIED FOR THIS DEVICE", Toast.LENGTH_SHORT).show();
                    }
                }
            }
        }
    };

 private void print(UsbDeviceConnection connection, UsbInterface intrface){

        String test = "THIS IS A PRINT TEST";
        byte [] testBytes = test.getBytes();

        if(intrface==null){
            Toast.makeText(this, "INTERFACE IS NULL", Toast.LENGTH_SHORT).show();
        }
        if(connection==null){
            Toast.makeText(this, "CONNECTION IS NULL", Toast.LENGTH_SHORT).show();
        }

        if(forceCLaim==null){
            Toast.makeText(this, "FORCE CLAIM IS NULL", Toast.LENGTH_SHORT).show();
        }   

        connection.claimInterface(intrface, forceCLaim);
        connection.bulkTransfer(mEndPoint, testBytes, testBytes.length, 0);

    }

私人UsbManager mUsbManager；
私人USB设备；
专用UsbDeviceConnection mConnection；
私人UsbInterface mInterface；
私人UsbEndpoint mEndPoint；
私人悬而未决的侵权意图；
私有静态最终字符串操作\u USB\u PERMISSION=“com.android.example.USB\u PERMISSION”；
私有静态布尔forceCLaim=true；
HashMap-mDeviceList；
迭代器mDeviceIterator；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_my）；
mUsbManager=（UsbManager）getSystemService（Context.USB_服务）；
mDeviceList=mUsbManager.getDeviceList（）；
mDeviceIterator=mDeviceList.values（）.iterator（）；
按钮打印=（按钮）findViewById（R.id.print）；
Toast.makeText（此“设备列表大小：”+String.valueOf（mDeviceList.Size（）），Toast.LENGTH_SHORT.show（）；
TextView TextView=（TextView）findViewById（R.id.usbDevice）；
字符串usbDevice=“”；
//这只是测试连接了哪些设备
while（mDeviceIterator.hasNext（））{
UsbDevice usbDevice1=mDeviceIterator.next（）；
usbDevice+=“\n”+
设备ID:“+usbDevice1.getDeviceId（）+”\n”+
DeviceName:“+usbDevice1.getDeviceName（）+”\n+
设备类：“+usbDevice1.getDeviceClass（）+”-“+translateDeviceClass（usbDevice1.getDeviceClass（））+”\n+
DeviceSubClass:“+usbDevice1.getDeviceSubclass（）+”\n+
“VendorID:”+usbDevice1.getVendorId（）+“\n”+
ProductID:“+usbDevice1.getProductId（）+”\n”；
int interfaceCount=usbDevice1.getInterfaceCount（）；
Toast.makeText（这个，“接口计数：”+String.valueOf（interfaceCount），Toast.LENGTH\u SHORT.show（）；
mDevice=usbDevice1；
if（mDevice==null）{
Toast.makeText（这个“mDevice为null”，Toast.LENGTH_SHORT.show（）；
}否则{
Toast.makeText（这个“mDevice不为null”，Toast.LENGTH_SHORT.show（）；
}
textView.setText（usbDevice）；
}
if（mDevice==null）{
Toast.makeText（这个“mDevice为null”，Toast.LENGTH_SHORT.show（）；
}否则{
Toast.makeText（这个“mDevice不为null”，Toast.LENGTH_SHORT.show（）；
}
mPermissionIntent=PendingIntent.getBroadcast（this，0，新意图（ACTION\u USB\u权限），0）；
IntentFilter筛选器=新建IntentFilter（操作\u USB\u权限）；
寄存器接收器（mUsbReceiver，过滤器）；
请求权限（mDevice、mPermissionIntent）；
print.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
//设置（）；
打印（mConnection，mInterface）；
}
});
}
私有字符串translateDeviceClass（int deviceClass）{
开关（设备类）{
案例UsbConstants.USB\u类\u应用\u规范：
返回“特定于应用程序的USB类”；
案例UsbConstants.USB_CLASS_音频：
返回“音频设备的USB类”；
案例UsbConstants.USB\u类\u CDC\u数据：
返回“CDC设备的USB类（通信设备类）”；
案例UsbConstants.USB_类_通信：
返回“通信设备的USB类”；
案例UsbConstants.USB\u类\u内容\u秒：
返回“内容安全设备的USB类”；
案例UsbConstants.USB_CLASS_CSCID：
返回“内容智能卡设备的USB类”；
案例UsbConstants.USB\u类\u HID：
返回“用于人机界面设备（例如鼠标和键盘）的USB类”；
案例UsbConstants.USB\u类\u集线器：
返回“USB集线器的USB类”；
案例UsbConstants.USB_类_大容量_存储：
返回“大容量存储设备的USB类”；
案例UsbConstants.USB_CLASS_杂项：
返回“无线杂项设备的USB类”；
案例UsbConstants.USB_类每个接口：
返回“USB类，表示该类是根据每个接口确定的”；
案例UsbConstants.USB_CLASS_PHYSICA:
返回“物理设备的USB类”；
case UsbConstants.USB_CLASS_打印机：
返回“打印机的USB类”；
案例UsbConstants.USB\u类\u静止\u图像：
返回“静态图像设备（数码相机）的USB类”；
案例UsbConstants.USB\u类别\u供应商\u规范：
返回“特定于供应商的USB类”；
案例UsbConstants.USB_CLASS_视频：
返回“视频设备的USB类”；
案例UsbConstants.USB_CLASS_无线_控制器：
返回“无线控制器设备的USB类”；
默认值：返回“未知USB类！”；
}
//广播接收器从用户处获取连接权限
专用最终广播接收器mUsbReceiver=新广播接收器（）{
公共void onReceive（上下文、意图）{
String action=intent.getAction（）；
if（动作\u USB\u权限等于（动作））{
已同步（此）{
UsbDevice设备=（UsbDevice）intent.getParcelableExtra（UsbManager.EXTRA_设备）；
if（intent.getBooleanExtra（UsbManager.EXTRA_权限_授予，false））{
private void print(UsbDeviceConnection connection, UsbInterface intrface) {

     String test = "THIS IS A PRINT TEST";
     byte [] testBytes = test.getBytes();

     if(intrface == null) {
         Toast.makeText(this, "INTERFACE IS NULL", Toast.LENGTH_SHORT).show();
     }

     if(connection == null) {
         Toast.makeText(this, "CONNECTION IS NULL", Toast.LENGTH_SHORT).show();
     }

     if(forceCLaim == null) {
         Toast.makeText(this, "FORCE CLAIM IS NULL", Toast.LENGTH_SHORT).show();
     }   

     connection.claimInterface(intrface, forceCLaim);
     connection.bulkTransfer(mEndPoint, testBytes, testBytes.length, 0);
     //Just Add 
     connection.close();    
 }

Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
   connection.bulkTransfer(mEndPoint, testBytes, testBytes.length, 0);
   }
});
thread.run(); //or thread.start(); -as you wish

Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
      connection.bulkTransfer(mEndPoint, testBytes, testBytes.length, 0);
      connection.bulkTransfer(mEndPoint, cut_paper, cut_paper.length, 0);
   }
});
thread.run();

private void print(final UsbDeviceConnection connection, final UsbInterface usbInterface) {
    final String test = ed_txt.getText().toString() + "\n\n";
    testBytes = test.getBytes();
    Log.e(TAG, "print Click........................ ");
    if (usbInterface == null) {
        Log.e(TAG, "INTERFACE IS NULL");
    } else if (connection == null) {
        Log.e(TAG, "CONNECTION IS NULL");
    } else if (forceCLaim == null) {
        Log.e(TAG, "FORCE CLAIM IS NULL");
    } else {
        Log.e(TAG, "Prepare print... ");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.e(TAG, "Printing.. ");
                UsbInterface intf = mDevice.getInterface(0);
                UsbEndpoint endpoint = intf.getEndpoint(0);
                UsbDeviceConnection conn = mUsbManager.openDevice(mDevice);
                conn.claimInterface(intf, true);

                byte[] cut_paper = {0x1D, 0x56, 0x41, 0x10};
                conn.bulkTransfer(endpoint, testBytes, testBytes.length, 0);
                conn.bulkTransfer(endpoint, cut_paper, cut_paper.length, 0);
            }
        });
        thread.run();
    }
}