यूएसबी होस्ट की खास जानकारी

जब Android डिवाइस, यूएसबी होस्ट मोड में होता है, तो वह यूएसबी होस्ट के तौर पर काम करता है. साथ ही, बस को पावर देता है और कनेक्ट किए गए यूएसबी डिवाइसों की गिनती करता है. यूएसबी होस्ट मोड, Android 3.1 और इसके बाद के वर्शन पर काम करता है.

एपीआई के बारे में खास जानकारी

शुरू करने से पहले, आपको उन क्लास के बारे में जानना ज़रूरी है जिनके साथ आपको काम करना है. यहां दी गई टेबल में, android.hardware.usb पैकेज में मौजूद यूएसबी होस्ट एपीआई के बारे में बताया गया है.

टेबल 1. यूएसबी होस्ट एपीआई

कक्षा ब्यौरा
UsbManager इससे, कनेक्ट किए गए यूएसबी डिवाइसों की सूची बनाई जा सकती है और उनसे कम्यूनिकेट किया जा सकता है.
UsbDevice यह कनेक्ट किए गए यूएसबी डिवाइस को दिखाता है. इसमें, डिवाइस की पहचान ज़ाहिर करने वाली जानकारी, इंटरफ़ेस, और एंडपॉइंट को ऐक्सेस करने के तरीके शामिल होते हैं.
UsbInterface यह यूएसबी डिवाइस के इंटरफ़ेस को दिखाता है. इससे डिवाइस के लिए, सुविधाओं का एक सेट तय होता है. किसी डिवाइस में एक या उससे ज़्यादा इंटरफ़ेस हो सकते हैं, जिनकी मदद से कम्यूनिकेट किया जा सकता है.
UsbEndpoint यह इंटरफ़ेस एंडपॉइंट को दिखाता है. यह इस इंटरफ़ेस के लिए कम्यूनिकेशन चैनल है. किसी इंटरफ़ेस में एक या उससे ज़्यादा एंडपॉइंट हो सकते हैं. आम तौर पर, डिवाइस के साथ दोनों तरफ़ से कम्यूनिकेशन के लिए, इनपुट और आउटपुट एंडपॉइंट होते हैं.
UsbDeviceConnection यह डिवाइस से कनेक्शन को दिखाता है, जो एंडपॉइंट पर डेटा ट्रांसफ़र करता है. इस क्लास की मदद से, डेटा को सिंक्रोनस या असिंक्रोनस तरीके से भेजा और वापस पाया जा सकता है.
UsbRequest यह UsbDeviceConnection के ज़रिए किसी डिवाइस से कम्यूनिकेट करने के लिए, एसिंक्रोनस रिक्वेस्ट को दिखाता है.
UsbConstants यह यूएसबी कॉन्स्टेंट तय करता है, जो Linux कर्नेल के linux/usb/ch9.h में दी गई परिभाषाओं से मेल खाते हैं.

ज़्यादातर मामलों में, यूएसबी डिवाइस से कम्यूनिकेट करते समय आपको इन सभी क्लास का इस्तेमाल करना होगा. हालांकि, UsbRequest का इस्तेमाल सिर्फ़ तब करना होगा, जब आपको एसिंक्रोनस कम्यूनिकेशन करना हो. आम तौर पर, आपको अपनी पसंद का UsbDevice पाने के लिए, UsbManager की ज़रूरत होती है. डिवाइस होने पर, आपको सही UsbInterface और उस इंटरफ़ेस का UsbEndpoint ढूंढना होगा, ताकि आप कम्यूनिकेट कर सकें. सही एंडपॉइंट मिलने के बाद, यूएसबी डिवाइस से कम्यूनिकेट करने के लिए UsbDeviceConnection खोलें.

Android मेनिफ़ेस्ट से जुड़ी ज़रूरी शर्तें

यहां दी गई सूची में बताया गया है कि यूएसबी होस्ट एपीआई के साथ काम करने से पहले, आपको अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में क्या जोड़ना होगा:

  • इस बात की कोई गारंटी नहीं है कि Android की सुविधा वाले सभी डिवाइसों पर, यूएसबी होस्ट एपीआई काम करेंगे. इसलिए, <uses-feature> एलिमेंट शामिल करें. इससे यह पता चलता है कि आपका ऐप्लिकेशन, android.hardware.usb.host सुविधा का इस्तेमाल करता है.
  • ऐप्लिकेशन के लिए, एसडीके का कम से कम वर्शन एपीआई लेवल 12 या इसके बाद के वर्शन पर सेट करें. यूएसबी होस्ट एपीआई, पुराने एपीआई लेवल पर मौजूद नहीं होते.
  • अगर आपको अपने ऐप्लिकेशन को अटैच किए गए यूएसबी डिवाइस की सूचना देनी है, तो अपनी मुख्य गतिविधि में android.hardware.usb.action.USB_DEVICE_ATTACHED इंटेंट के लिए, <intent-filter> और <meta-data> एलिमेंट पेयर की जानकारी दें. <meta-data> एलिमेंट, किसी बाहरी एक्सएमएल रिसॉर्स फ़ाइल पर ले जाता है. इस फ़ाइल में, उस डिवाइस की पहचान ज़ाहिर करने वाली जानकारी होती है जिसका पता लगाना है.

    एक्सएमएल रिसॉर्स फ़ाइल में, उन यूएसबी डिवाइसों के लिए <usb-device> एलिमेंट का एलान करें जिन्हें आपको फ़िल्टर करना है. यहां दी गई सूची में, <usb-device> के एट्रिब्यूट के बारे में बताया गया है. आम तौर पर, अगर आपको किसी खास डिवाइस के लिए फ़िल्टर करना है, तो वेंडर और प्रॉडक्ट आईडी का इस्तेमाल करें. अगर आपको यूएसबी डिवाइसों के किसी ग्रुप के लिए फ़िल्टर करना है, तो क्लास, सबक्लास, और प्रोटोकॉल का इस्तेमाल करें. जैसे, मास स्टोरेज डिवाइस या डिजिटल कैमरे. इनमें से किसी भी एट्रिब्यूट की जानकारी नहीं दी जा सकती या सभी एट्रिब्यूट की जानकारी दी जा सकती है. कोई एट्रिब्यूट तय न करने पर, हर यूएसबी डिवाइस मैच हो जाता है. इसलिए, ऐसा सिर्फ़ तब करें, जब आपके ऐप्लिकेशन को इसकी ज़रूरत हो:

    • vendor-id
    • product-id
    • class
    • subclass
    • protocol (डिवाइस या इंटरफ़ेस)

    संसाधन फ़ाइल को res/xml/ डायरेक्ट्री में सेव करें. संसाधन फ़ाइल का नाम (.xml एक्सटेंशन के बिना) वही होना चाहिए जो आपने <meta-data> एलिमेंट में बताया है. एक्सएमएल रिसॉर्स फ़ाइल का फ़ॉर्मैट, इस उदाहरण में दिखाया गया है.

मेनिफ़ेस्ट और संसाधन फ़ाइल के उदाहरण

यहां दिए गए उदाहरण में, सैंपल मेनिफ़ेस्ट और उससे जुड़ी संसाधन फ़ाइल दिखाई गई है:

<manifest ...>
    <uses-feature android:name="android.hardware.usb.host" />
    <uses-sdk android:minSdkVersion="12" />
    ...
    <application>
        <activity ...>
            ...
            <intent-filter>
                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
            </intent-filter>

            <meta-data android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
                android:resource="@xml/device_filter" />
        </activity>
    </application>
</manifest>

इस मामले में, यहां दी गई संसाधन फ़ाइल को res/xml/device_filter.xml में सेव किया जाना चाहिए. साथ ही, यह बताया जाना चाहिए कि बताए गए एट्रिब्यूट वाले किसी भी यूएसबी डिवाइस को फ़िल्टर किया जाना चाहिए:

<?xml version="1.0" encoding="utf-8"?>

<resources>
    <usb-device vendor-id="1234" product-id="5678" class="255" subclass="66" protocol="1" />
</resources>

डिवाइसों के साथ काम करना

जब उपयोगकर्ता, Android डिवाइस से यूएसबी डिवाइस कनेक्ट करते हैं, तो Android सिस्टम यह तय कर सकता है कि आपका ऐप्लिकेशन, कनेक्ट किए गए डिवाइस के साथ काम करता है या नहीं. अगर ऐसा है, तो आपके पास डिवाइस के साथ कम्यूनिकेशन सेट अप करने का विकल्प है. इसके लिए, आपके ऐप्लिकेशन को:

  1. कनेक्ट किए गए यूएसबी डिवाइसों का पता लगाने के लिए, इंटेंट फ़िल्टर का इस्तेमाल करें. इससे उपयोगकर्ता को यूएसबी डिवाइस कनेक्ट करने पर सूचना मिलेगी. इसके अलावा, पहले से कनेक्ट किए गए यूएसबी डिवाइसों की सूची बनाकर भी ऐसा किया जा सकता है.
  2. अगर पहले से अनुमति नहीं मिली है, तो यूएसबी डिवाइस से कनेक्ट करने के लिए उपयोगकर्ता से अनुमति मांगें.
  3. सही इंटरफ़ेस एंडपॉइंट पर डेटा को पढ़कर और लिखकर, यूएसबी डिवाइस से कम्यूनिकेट करना.

कोई डिवाइस ढूंढना

आपका ऐप्लिकेशन, यूएसबी डिवाइसों का पता लगा सकता है. इसके लिए, इंटेंट फ़िल्टर का इस्तेमाल करके सूचना पाने की सुविधा चालू की जा सकती है. इससे उपयोगकर्ता के डिवाइस कनेक्ट करने पर सूचना मिलती है. इसके अलावा, पहले से कनेक्ट किए गए यूएसबी डिवाइसों की सूची बनाकर भी ऐसा किया जा सकता है. अगर आपको अपने ऐप्लिकेशन से किसी डिवाइस का अपने-आप पता लगाना है, तो इंटेंट फ़िल्टर का इस्तेमाल करना फ़ायदेमंद होता है. कनेक्ट किए गए यूएसबी डिवाइसों की सूची बनाना तब फ़ायदेमंद होता है, जब आपको सभी कनेक्ट किए गए डिवाइसों की सूची चाहिए या आपके ऐप्लिकेशन ने किसी इंटेंट के लिए फ़िल्टर नहीं किया है.

इंटेंट फ़िल्टर का इस्तेमाल करना

अपने ऐप्लिकेशन को किसी खास यूएसबी डिवाइस का पता लगाने की अनुमति देने के लिए, इंटेंट फ़िल्टर तय किया जा सकता है. इससे android.hardware.usb.action.USB_DEVICE_ATTACHED इंटेंट को फ़िल्टर किया जा सकता है. इस इंटेंट फ़िल्टर के साथ, आपको एक ऐसी रिसॉर्स फ़ाइल देनी होगी जिसमें यूएसबी डिवाइस की प्रॉपर्टी की जानकारी हो. जैसे, प्रॉडक्ट और वेंडर आईडी. जब उपयोगकर्ता आपके डिवाइस फ़िल्टर से मैच होने वाले किसी डिवाइस को कनेक्ट करते हैं, तो सिस्टम उन्हें एक डायलॉग दिखाता है. इसमें उनसे पूछा जाता है कि क्या उन्हें आपका ऐप्लिकेशन शुरू करना है. अगर उपयोगकर्ता अनुमति देते हैं, तो आपके ऐप्लिकेशन को डिवाइस को ऐक्सेस करने की अनुमति अपने-आप मिल जाती है. यह अनुमति तब तक रहती है, जब तक डिवाइस डिसकनेक्ट नहीं हो जाता.

यहां दिए गए उदाहरण में, इंटेंट फ़िल्टर को तय करने का तरीका बताया गया है:

<activity ...>
...
    <intent-filter>
        <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
    </intent-filter>

    <meta-data android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
        android:resource="@xml/device_filter" />
</activity>

यहां दिए गए उदाहरण में, मिलती-जुलती संसाधन फ़ाइल को तय करने का तरीका बताया गया है. इससे उन यूएसबी डिवाइसों के बारे में पता चलता है जिनमें आपकी दिलचस्पी है:

<?xml version="1.0" encoding="utf-8"?>

<resources>
    <usb-device vendor-id="1234" product-id="5678" />
</resources>

अपनी गतिविधि में, UsbDevice को हासिल किया जा सकता है. यह इस तरह के इंटेंट से अटैच किए गए डिवाइस को दिखाता है:

Kotlin

val device: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)

Java

UsbDevice device = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

डिवाइसों की सूची बनाएं

अगर आपका ऐप्लिकेशन, फ़िलहाल कनेक्ट किए गए सभी यूएसबी डिवाइसों की जांच करना चाहता है, तो ऐप्लिकेशन के चलने के दौरान, वह बस पर मौजूद डिवाइसों की गिनती कर सकता है. कनेक्ट किए गए सभी यूएसबी डिवाइसों का हैश मैप पाने के लिए, getDeviceList() तरीके का इस्तेमाल करें. अगर आपको मैप से कोई डिवाइस ढूंढना है, तो हैश मैप को यूएसबी डिवाइस के नाम से की (key) किया जाता है.

Kotlin

val manager = getSystemService(Context.USB_SERVICE) as UsbManager
...
val deviceList = manager.getDeviceList()
val device = deviceList.get("deviceName")

Java

UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
...
HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
UsbDevice device = deviceList.get("deviceName");

अगर आप चाहें, तो हैश मैप से सिर्फ़ एक इटरेटर हासिल करके, हर डिवाइस को एक-एक करके प्रोसेस किया जा सकता है:

Kotlin

val manager = getSystemService(Context.USB_SERVICE) as UsbManager
..
val deviceList: HashMap<String, UsbDevice> = manager.deviceList
deviceList.values.forEach { device ->
    // your code
}

Java

UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
...
HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
while(deviceIterator.hasNext()){
    UsbDevice device = deviceIterator.next();
    // your code
}

किसी डिवाइस से कनेक्ट करने की अनुमति पाना

यूएसबी डिवाइस से कम्यूनिकेट करने से पहले, आपके ऐप्लिकेशन को उपयोगकर्ताओं से अनुमति लेनी होगी.

ध्यान दें: अगर आपका ऐप्लिकेशन यूएसबी डिवाइसों के कनेक्ट होने पर उनका पता लगाने के लिए, इंटेंट फ़िल्टर का इस्तेमाल करता है, तो उसे अपने-आप अनुमति मिल जाती है. ऐसा तब होता है, जब उपयोगकर्ता आपके ऐप्लिकेशन को इंटेंट मैनेज करने की अनुमति देता है. अगर ऐसा नहीं है, तो आपको डिवाइस से कनेक्ट करने से पहले, अपने ऐप्लिकेशन में साफ़ तौर पर अनुमति का अनुरोध करना होगा.

कुछ मामलों में, साफ़ तौर पर अनुमति मांगना ज़रूरी हो सकता है. जैसे, जब आपका ऐप्लिकेशन पहले से कनेक्ट किए गए यूएसबी डिवाइसों की गिनती करता है और फिर उनमें से किसी एक के साथ कम्यूनिकेट करना चाहता है. किसी डिवाइस से कम्यूनिकेट करने से पहले, आपको यह देखना होगा कि आपके पास उसे ऐक्सेस करने की अनुमति है या नहीं. अगर ऐसा नहीं है, तो उपयोगकर्ता के डिवाइस को ऐक्सेस करने की अनुमति न देने पर, आपको रनटाइम से जुड़ी गड़बड़ी का मैसेज मिलेगा.

अनुमति पाने के लिए, पहले एक ब्रॉडकास्ट रिसीवर बनाएं. यह रिसीवर, requestPermission() को कॉल करने पर ब्रॉडकास्ट होने वाले इंटेंट को सुनता है. requestPermission() को कॉल करने पर, उपयोगकर्ता को एक डायलॉग बॉक्स दिखता है. इसमें डिवाइस से कनेक्ट करने की अनुमति मांगी जाती है. यहां दिए गए सैंपल कोड में, ब्रॉडकास्ट रिसीवर बनाने का तरीका बताया गया है:

Kotlin

private const val ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"

private val usbReceiver = object : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        if (ACTION_USB_PERMISSION == intent.action) {
            synchronized(this) {
                val device: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)

                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    device?.apply {
                        // call method to set up device communication
                    }
                } else {
                    Log.d(TAG, "permission denied for device $device")
                }
            }
        }
    }
}

Java

private static final String ACTION_USB_PERMISSION =
    "com.android.example.USB_PERMISSION";
private final BroadcastReceiver usbReceiver = 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
                   }
                }
                else {
                    Log.d(TAG, "permission denied for device " + device);
                }
            }
        }
    }
};

ब्रॉडकास्ट रिसीवर को रजिस्टर करने के लिए, इसे अपनी गतिविधि के onCreate() तरीके में जोड़ें:

Kotlin

private const val ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"
...
val manager = getSystemService(Context.USB_SERVICE) as UsbManager
...
permissionIntent = PendingIntent.getBroadcast(this, 0,
                  Intent(ACTION_USB_PERMISSION), PendingIntent.FLAG_IMMUTABLE)
val filter = IntentFilter(ACTION_USB_PERMISSION)
registerReceiver(usbReceiver, filter)

Java

UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
private static final String ACTION_USB_PERMISSION =
    "com.android.example.USB_PERMISSION";
...
permissionIntent = PendingIntent.getBroadcast(this, 0,
              new Intent(ACTION_USB_PERMISSION), PendingIntent.FLAG_IMMUTABLE);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
registerReceiver(usbReceiver, filter);

उपयोगकर्ताओं से डिवाइस से कनेक्ट करने की अनुमति मांगने वाला डायलॉग दिखाने के लिए, requestPermission() तरीके को कॉल करें:

Kotlin

lateinit var device: UsbDevice
...
usbManager.requestPermission(device, permissionIntent)

Java

UsbDevice device;
...
usbManager.requestPermission(device, permissionIntent);

जब उपयोगकर्ता डायलॉग का जवाब देते हैं, तो आपके ब्रॉडकास्ट रिसीवर को वह इंटेंट मिलता है जिसमें EXTRA_PERMISSION_GRANTED अतिरिक्त शामिल होता है. यह एक बूलियन है, जो जवाब को दिखाता है. डिवाइस से कनेक्ट करने से पहले, इस एक्स्ट्रा की वैल्यू को true पर सेट करें.

किसी डिवाइस से कनेक्ट करना

यूएसबी डिवाइस के साथ कम्यूनिकेशन, सिंक्रोनस या असिंक्रोनस हो सकता है. दोनों ही मामलों में, आपको एक नया थ्रेड बनाना चाहिए, ताकि सभी डेटा ट्रांसमिशन किए जा सकें. इससे यूज़र इंटरफ़ेस (यूआई) थ्रेड ब्लॉक नहीं होगा. किसी डिवाइस के साथ सही तरीके से कम्यूनिकेशन सेट अप करने के लिए, आपको उस डिवाइस का सही UsbInterface और UsbEndpoint पाना होगा जिससे आपको कम्यूनिकेट करना है. साथ ही, आपको UsbDeviceConnection के साथ इस एंडपॉइंट पर अनुरोध भेजने होंगे. आम तौर पर, आपके कोड में ये चीज़ें होनी चाहिए:

  • UsbDevice ऑब्जेक्ट के एट्रिब्यूट देखें, जैसे कि प्रॉडक्ट आईडी, वेंडर आईडी या डिवाइस क्लास. इससे यह पता चलता है कि आपको डिवाइस से कम्यूनिकेट करना है या नहीं.
  • जब आपको पक्के तौर पर पता हो कि आपको डिवाइस से कम्यूनिकेट करना है, तो वह UsbInterface ढूंढें जिसका इस्तेमाल आपको कम्यूनिकेट करने के लिए करना है. साथ ही, उस इंटरफ़ेस का सही UsbEndpoint ढूंढें. इंटरफ़ेस में एक या उससे ज़्यादा एंडपॉइंट हो सकते हैं. आम तौर पर, दोतरफ़ा बातचीत के लिए, इनमें एक इनपुट और एक आउटपुट एंडपॉइंट होता है.
  • सही एंडपॉइंट मिलने पर, उस एंडपॉइंट पर UsbDeviceConnection खोलें.
  • bulkTransfer() या controlTransfer() तरीके का इस्तेमाल करके, एंडपॉइंट पर वह डेटा उपलब्ध कराएं जिसे आपको ट्रांसमिट करना है. आपको इस चरण को किसी दूसरी थ्रेड में पूरा करना चाहिए, ताकि मुख्य यूज़र इंटरफ़ेस (यूआई) थ्रेड को ब्लॉक होने से रोका जा सके. Android में थ्रेड इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, प्रोसेस और थ्रेड लेख पढ़ें.

यहां दिया गया कोड स्निपेट, सिंक्रोनस डेटा ट्रांसफ़र करने का एक आसान तरीका है. आपके कोड में, कम्यूनिकेट करने के लिए सही इंटरफ़ेस और एंडपॉइंट ढूंढने के लिए ज़्यादा लॉजिक होना चाहिए. साथ ही, डेटा को मुख्य यूज़र इंटरफ़ेस (यूआई) थ्रेड के बजाय किसी दूसरे थ्रेड में ट्रांसफ़र करना चाहिए:

Kotlin

private lateinit var bytes: ByteArray
private val TIMEOUT = 0
private val forceClaim = true

...

device?.getInterface(0)?.also { intf ->
    intf.getEndpoint(0)?.also { endpoint ->
        usbManager.openDevice(device)?.apply {
            claimInterface(intf, forceClaim)
            bulkTransfer(endpoint, bytes, bytes.size, TIMEOUT) //do in another thread
        }
    }
}

Java

private Byte[] bytes;
private static int TIMEOUT = 0;
private boolean forceClaim = true;

...

UsbInterface intf = device.getInterface(0);
UsbEndpoint endpoint = intf.getEndpoint(0);
UsbDeviceConnection connection = usbManager.openDevice(device);
connection.claimInterface(intf, forceClaim);
connection.bulkTransfer(endpoint, bytes, bytes.length, TIMEOUT); //do in another thread

एसिंक्रोनस तरीके से डेटा भेजने के लिए, UsbRequest क्लास का इस्तेमाल करके, एसिंक्रोनस अनुरोध को initialize और queue करें. इसके बाद, requestWait() का इस्तेमाल करके नतीजे का इंतज़ार करें.

किसी डिवाइस से कम्यूनिकेशन बंद करना

जब किसी डिवाइस के साथ कम्यूनिकेशन पूरा हो जाए या डिवाइस को अलग कर दिया जाए, तो releaseInterface() और close() को कॉल करके, UsbInterface और UsbDeviceConnection को बंद करें. डिटैच किए गए इवेंट के बारे में सुनने के लिए, नीचे दिए गए तरीके से ब्रॉडकास्ट रिसीवर बनाएं:

Kotlin

var usbReceiver: BroadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {

        if (UsbManager.ACTION_USB_DEVICE_DETACHED == intent.action) {
            val device: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
            device?.apply {
                // call your method that cleans up and closes communication with the device
            }
        }
    }
}

Java

BroadcastReceiver usbReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

      if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
            UsbDevice device = (UsbDevice)intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
            if (device != null) {
                // call your method that cleans up and closes communication with the device
            }
        }
    }
};

मेनिफ़ेस्ट के बजाय ऐप्लिकेशन में ब्रॉडकास्ट रिसीवर बनाने से, आपका ऐप्लिकेशन सिर्फ़ उन इवेंट को मैनेज कर पाता है जो उसके चलने के दौरान अलग हो जाते हैं. इस तरह, डिटैच किए गए इवेंट सिर्फ़ उस ऐप्लिकेशन को भेजे जाते हैं जो फ़िलहाल चल रहा है. इन्हें सभी ऐप्लिकेशन पर ब्रॉडकास्ट नहीं किया जाता.